From c2295de389b1c41215971ede55e0baf342a5bed0 Mon Sep 17 00:00:00 2001 From: David Zhao Date: Thu, 18 Jun 2026 11:26:53 +1000 Subject: [PATCH 1/8] Add ExportOutput action --- proto/relationalai/lqp/v1/transactions.proto | 14 ++++++++++++++ 1 file changed, 14 insertions(+) diff --git a/proto/relationalai/lqp/v1/transactions.proto b/proto/relationalai/lqp/v1/transactions.proto index 8c9ce432..ccceb560 100644 --- a/proto/relationalai/lqp/v1/transactions.proto +++ b/proto/relationalai/lqp/v1/transactions.proto @@ -144,6 +144,7 @@ message Read { WhatIf what_if = 3; Abort abort = 4; Export export = 5; + ExportOutput export_output = 6; } } @@ -174,3 +175,16 @@ message Abort { string name = 1; RelationId relation_id = 2; } + +message ExportCSVOutput { + ExportCSVSource csv_source = 1; + CSVConfig csv_config = 2; +} + +message ExportOutput { + // Supports export formats e.g., CSV and Iceberg, but considered to be part of txn results + oneof export_output { + ExportCSVOutput csv = 1; + } +} + From 86f8dfee5d739a4f8fc20757da891009202515db Mon Sep 17 00:00:00 2001 From: David Zhao Date: Thu, 18 Jun 2026 22:32:52 +1000 Subject: [PATCH 2/8] Extend grammar for ExportOutput action Co-Authored-By: Claude Opus 4.8 (1M context) --- meta/src/meta/grammar.y | 21 +++++++++++++++++++++ 1 file changed, 21 insertions(+) diff --git a/meta/src/meta/grammar.y b/meta/src/meta/grammar.y index 7df7da9b..17945067 100644 --- a/meta/src/meta/grammar.y +++ b/meta/src/meta/grammar.y @@ -115,9 +115,11 @@ %nonterm export_csv_column transactions.ExportCSVColumn %nonterm export_csv_columns_list Sequence[transactions.ExportCSVColumn] %nonterm export_csv_config transactions.ExportCSVConfig +%nonterm export_csv_output transactions.ExportCSVOutput %nonterm export_csv_path String %nonterm export_csv_source transactions.ExportCSVSource %nonterm export_iceberg_config transactions.ExportIcebergConfig +%nonterm export_output transactions.ExportOutput %nonterm export_iceberg_table_def logic.RelationId %nonterm iceberg_auth_properties Sequence[Tuple[String, String]] %nonterm iceberg_catalog_config logic.IcebergCatalogConfig @@ -1293,6 +1295,10 @@ read construct: $$ = transactions.Read(export=$1) deconstruct if builtin.has_proto_field($$, 'export'): $1: transactions.Export = $$.export + | export_output + construct: $$ = transactions.Read(export_output=$1) + deconstruct if builtin.has_proto_field($$, 'export_output'): + $1: transactions.ExportOutput = $$.export_output demand : "(" "demand" relation_id ")" @@ -1330,6 +1336,21 @@ export deconstruct if builtin.has_proto_field($$, 'iceberg_config'): $3: transactions.ExportIcebergConfig = $$.iceberg_config +# Like `export`, but the engine treats the result as part of the transaction results +# and chooses the output path itself (so no `path` is specified here). +export_output + : "(" "output_export" export_csv_output ")" + construct: $$ = transactions.ExportOutput(csv=$3) + deconstruct if builtin.has_proto_field($$, 'csv'): + $3: transactions.ExportCSVOutput = $$.csv + +export_csv_output + : "(" "csv" export_csv_source csv_config ")" + construct: $$ = transactions.ExportCSVOutput(csv_source=$3, csv_config=$4) + deconstruct: + $3: transactions.ExportCSVSource = $$.csv_source + $4: logic.CSVConfig = $$.csv_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) From b2e48ff68d18df01012bdbc549d55d8346d1cd3a Mon Sep 17 00:00:00 2001 From: David Zhao Date: Thu, 18 Jun 2026 22:48:46 +1000 Subject: [PATCH 3/8] Regenerate protobuf, parsers, and printers for ExportOutput Co-Authored-By: Claude Opus 4.8 (1M context) --- sdks/go/src/lqp/v1/transactions.pb.go | 326 +- sdks/go/src/parser.go | 5597 +++++++++-------- sdks/go/src/pretty.go | 3927 ++++++------ .../relationalai/lqp/v1/transactions_pb.jl | 95 +- .../LogicalQueryProtocol.jl/src/parser.jl | 4609 +++++++------- .../LogicalQueryProtocol.jl/src/pretty.jl | 3955 ++++++------ sdks/python/src/lqp/gen/parser.py | 4775 +++++++------- sdks/python/src/lqp/gen/pretty.py | 4495 ++++++------- .../src/lqp/proto/v1/transactions_pb2.py | 32 +- .../src/lqp/proto/v1/transactions_pb2.pyi | 20 +- 10 files changed, 14203 insertions(+), 13628 deletions(-) diff --git a/sdks/go/src/lqp/v1/transactions.pb.go b/sdks/go/src/lqp/v1/transactions.pb.go index b1a0ca1f..2096e0aa 100644 --- a/sdks/go/src/lqp/v1/transactions.pb.go +++ b/sdks/go/src/lqp/v1/transactions.pb.go @@ -1085,6 +1085,7 @@ type Read struct { // *Read_WhatIf // *Read_Abort // *Read_Export + // *Read_ExportOutput ReadType isRead_ReadType `protobuf_oneof:"read_type"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache @@ -1172,6 +1173,15 @@ func (x *Read) GetExport() *Export { return nil } +func (x *Read) GetExportOutput() *ExportOutput { + if x != nil { + if x, ok := x.ReadType.(*Read_ExportOutput); ok { + return x.ExportOutput + } + } + return nil +} + type isRead_ReadType interface { isRead_ReadType() } @@ -1196,6 +1206,10 @@ type Read_Export struct { Export *Export `protobuf:"bytes,5,opt,name=export,proto3,oneof"` } +type Read_ExportOutput struct { + ExportOutput *ExportOutput `protobuf:"bytes,6,opt,name=export_output,json=exportOutput,proto3,oneof"` +} + func (*Read_Demand) isRead_ReadType() {} func (*Read_Output) isRead_ReadType() {} @@ -1206,6 +1220,8 @@ func (*Read_Abort) isRead_ReadType() {} func (*Read_Export) isRead_ReadType() {} +func (*Read_ExportOutput) isRead_ReadType() {} + type Demand struct { state protoimpl.MessageState `protogen:"open.v1"` RelationId *RelationId `protobuf:"bytes,1,opt,name=relation_id,json=relationId,proto3" json:"relation_id,omitempty"` @@ -1488,6 +1504,126 @@ func (x *Abort) GetRelationId() *RelationId { return nil } +type ExportCSVOutput struct { + state protoimpl.MessageState `protogen:"open.v1"` + CsvSource *ExportCSVSource `protobuf:"bytes,1,opt,name=csv_source,json=csvSource,proto3" json:"csv_source,omitempty"` + CsvConfig *CSVConfig `protobuf:"bytes,2,opt,name=csv_config,json=csvConfig,proto3" json:"csv_config,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ExportCSVOutput) Reset() { + *x = ExportCSVOutput{} + mi := &file_relationalai_lqp_v1_transactions_proto_msgTypes[22] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ExportCSVOutput) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ExportCSVOutput) ProtoMessage() {} + +func (x *ExportCSVOutput) ProtoReflect() protoreflect.Message { + mi := &file_relationalai_lqp_v1_transactions_proto_msgTypes[22] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ExportCSVOutput.ProtoReflect.Descriptor instead. +func (*ExportCSVOutput) Descriptor() ([]byte, []int) { + return file_relationalai_lqp_v1_transactions_proto_rawDescGZIP(), []int{22} +} + +func (x *ExportCSVOutput) GetCsvSource() *ExportCSVSource { + if x != nil { + return x.CsvSource + } + return nil +} + +func (x *ExportCSVOutput) GetCsvConfig() *CSVConfig { + if x != nil { + return x.CsvConfig + } + return nil +} + +type ExportOutput struct { + state protoimpl.MessageState `protogen:"open.v1"` + // Supports export formats e.g., CSV and Iceberg, but considered to be part of txn results + // + // Types that are valid to be assigned to ExportOutput: + // + // *ExportOutput_Csv + ExportOutput isExportOutput_ExportOutput `protobuf_oneof:"export_output"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ExportOutput) Reset() { + *x = ExportOutput{} + mi := &file_relationalai_lqp_v1_transactions_proto_msgTypes[23] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ExportOutput) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ExportOutput) ProtoMessage() {} + +func (x *ExportOutput) ProtoReflect() protoreflect.Message { + mi := &file_relationalai_lqp_v1_transactions_proto_msgTypes[23] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ExportOutput.ProtoReflect.Descriptor instead. +func (*ExportOutput) Descriptor() ([]byte, []int) { + return file_relationalai_lqp_v1_transactions_proto_rawDescGZIP(), []int{23} +} + +func (x *ExportOutput) GetExportOutput() isExportOutput_ExportOutput { + if x != nil { + return x.ExportOutput + } + return nil +} + +func (x *ExportOutput) GetCsv() *ExportCSVOutput { + if x != nil { + if x, ok := x.ExportOutput.(*ExportOutput_Csv); ok { + return x.Csv + } + } + return nil +} + +type isExportOutput_ExportOutput interface { + isExportOutput_ExportOutput() +} + +type ExportOutput_Csv struct { + Csv *ExportCSVOutput `protobuf:"bytes,1,opt,name=csv,proto3,oneof"` +} + +func (*ExportOutput_Csv) isExportOutput_ExportOutput() {} + var File_relationalai_lqp_v1_transactions_proto protoreflect.FileDescriptor var file_relationalai_lqp_v1_transactions_proto_rawDesc = string([]byte{ @@ -1682,7 +1818,7 @@ var file_relationalai_lqp_v1_transactions_proto_rawDesc = string([]byte{ 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, + 0x62, 0x79, 0x74, 0x65, 0x73, 0x4a, 0x04, 0x08, 0x04, 0x10, 0x05, 0x22, 0xee, 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, @@ -1700,54 +1836,74 @@ var file_relationalai_lqp_v1_transactions_proto_rawDesc = string([]byte{ 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, - 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, + 0x78, 0x70, 0x6f, 0x72, 0x74, 0x12, 0x48, 0x0a, 0x0d, 0x65, 0x78, 0x70, 0x6f, 0x72, 0x74, 0x5f, + 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x21, 0x2e, 0x72, + 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, + 0x76, 0x31, 0x2e, 0x45, 0x78, 0x70, 0x6f, 0x72, 0x74, 0x4f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x48, + 0x00, 0x52, 0x0c, 0x65, 0x78, 0x70, 0x6f, 0x72, 0x74, 0x4f, 0x75, 0x74, 0x70, 0x75, 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, 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, 0x22, 0x95, 0x01, 0x0a, 0x0f, 0x45, 0x78, 0x70, 0x6f, 0x72, 0x74, 0x43, 0x53, 0x56, 0x4f, + 0x75, 0x74, 0x70, 0x75, 0x74, 0x12, 0x43, 0x0a, 0x0a, 0x63, 0x73, 0x76, 0x5f, 0x73, 0x6f, 0x75, + 0x72, 0x63, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x72, 0x65, 0x6c, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, + 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, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1e, + 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, + 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x53, 0x56, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x52, 0x09, + 0x63, 0x73, 0x76, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x22, 0x59, 0x0a, 0x0c, 0x45, 0x78, 0x70, + 0x6f, 0x72, 0x74, 0x4f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x12, 0x38, 0x0a, 0x03, 0x63, 0x73, 0x76, + 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, 0x4f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x48, 0x00, 0x52, 0x03, + 0x63, 0x73, 0x76, 0x42, 0x0f, 0x0a, 0x0d, 0x65, 0x78, 0x70, 0x6f, 0x72, 0x74, 0x5f, 0x6f, 0x75, + 0x74, 0x70, 0x75, 0x74, 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, 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, + 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 ( @@ -1763,7 +1919,7 @@ func file_relationalai_lqp_v1_transactions_proto_rawDescGZIP() []byte { } var file_relationalai_lqp_v1_transactions_proto_enumTypes = make([]protoimpl.EnumInfo, 1) -var file_relationalai_lqp_v1_transactions_proto_msgTypes = make([]protoimpl.MessageInfo, 23) +var file_relationalai_lqp_v1_transactions_proto_msgTypes = make([]protoimpl.MessageInfo, 25) var file_relationalai_lqp_v1_transactions_proto_goTypes = []any{ (MaintenanceLevel)(0), // 0: relationalai.lqp.v1.MaintenanceLevel (*Transaction)(nil), // 1: relationalai.lqp.v1.Transaction @@ -1788,13 +1944,15 @@ var file_relationalai_lqp_v1_transactions_proto_goTypes = []any{ (*Export)(nil), // 20: relationalai.lqp.v1.Export (*WhatIf)(nil), // 21: relationalai.lqp.v1.WhatIf (*Abort)(nil), // 22: relationalai.lqp.v1.Abort - nil, // 23: relationalai.lqp.v1.ExportIcebergConfig.TablePropertiesEntry - (*FragmentId)(nil), // 24: relationalai.lqp.v1.FragmentId - (*Fragment)(nil), // 25: relationalai.lqp.v1.Fragment - (*RelationId)(nil), // 26: relationalai.lqp.v1.RelationId - (*CSVConfig)(nil), // 27: relationalai.lqp.v1.CSVConfig - (*IcebergLocator)(nil), // 28: relationalai.lqp.v1.IcebergLocator - (*IcebergCatalogConfig)(nil), // 29: relationalai.lqp.v1.IcebergCatalogConfig + (*ExportCSVOutput)(nil), // 23: relationalai.lqp.v1.ExportCSVOutput + (*ExportOutput)(nil), // 24: relationalai.lqp.v1.ExportOutput + nil, // 25: relationalai.lqp.v1.ExportIcebergConfig.TablePropertiesEntry + (*FragmentId)(nil), // 26: relationalai.lqp.v1.FragmentId + (*Fragment)(nil), // 27: relationalai.lqp.v1.Fragment + (*RelationId)(nil), // 28: relationalai.lqp.v1.RelationId + (*CSVConfig)(nil), // 29: relationalai.lqp.v1.CSVConfig + (*IcebergLocator)(nil), // 30: relationalai.lqp.v1.IcebergLocator + (*IcebergCatalogConfig)(nil), // 31: relationalai.lqp.v1.IcebergCatalogConfig } var file_relationalai_lqp_v1_transactions_proto_depIdxs = []int32{ 5, // 0: relationalai.lqp.v1.Transaction.epochs:type_name -> relationalai.lqp.v1.Epoch @@ -1802,45 +1960,49 @@ var file_relationalai_lqp_v1_transactions_proto_depIdxs = []int32{ 4, // 2: relationalai.lqp.v1.Transaction.sync:type_name -> relationalai.lqp.v1.Sync 3, // 3: relationalai.lqp.v1.Configure.ivm_config:type_name -> relationalai.lqp.v1.IVMConfig 0, // 4: relationalai.lqp.v1.IVMConfig.level:type_name -> relationalai.lqp.v1.MaintenanceLevel - 24, // 5: relationalai.lqp.v1.Sync.fragments:type_name -> relationalai.lqp.v1.FragmentId + 26, // 5: relationalai.lqp.v1.Sync.fragments:type_name -> relationalai.lqp.v1.FragmentId 6, // 6: relationalai.lqp.v1.Epoch.writes:type_name -> relationalai.lqp.v1.Write 17, // 7: relationalai.lqp.v1.Epoch.reads:type_name -> relationalai.lqp.v1.Read 7, // 8: relationalai.lqp.v1.Write.define:type_name -> relationalai.lqp.v1.Define 8, // 9: relationalai.lqp.v1.Write.undefine:type_name -> relationalai.lqp.v1.Undefine 9, // 10: relationalai.lqp.v1.Write.context:type_name -> relationalai.lqp.v1.Context 11, // 11: relationalai.lqp.v1.Write.snapshot:type_name -> relationalai.lqp.v1.Snapshot - 25, // 12: relationalai.lqp.v1.Define.fragment:type_name -> relationalai.lqp.v1.Fragment - 24, // 13: relationalai.lqp.v1.Undefine.fragment_id:type_name -> relationalai.lqp.v1.FragmentId - 26, // 14: relationalai.lqp.v1.Context.relations:type_name -> relationalai.lqp.v1.RelationId - 26, // 15: relationalai.lqp.v1.SnapshotMapping.source_relation:type_name -> relationalai.lqp.v1.RelationId + 27, // 12: relationalai.lqp.v1.Define.fragment:type_name -> relationalai.lqp.v1.Fragment + 26, // 13: relationalai.lqp.v1.Undefine.fragment_id:type_name -> relationalai.lqp.v1.FragmentId + 28, // 14: relationalai.lqp.v1.Context.relations:type_name -> relationalai.lqp.v1.RelationId + 28, // 15: relationalai.lqp.v1.SnapshotMapping.source_relation:type_name -> relationalai.lqp.v1.RelationId 10, // 16: relationalai.lqp.v1.Snapshot.mappings:type_name -> relationalai.lqp.v1.SnapshotMapping 15, // 17: relationalai.lqp.v1.ExportCSVConfig.csv_source:type_name -> relationalai.lqp.v1.ExportCSVSource - 27, // 18: relationalai.lqp.v1.ExportCSVConfig.csv_config:type_name -> relationalai.lqp.v1.CSVConfig + 29, // 18: relationalai.lqp.v1.ExportCSVConfig.csv_config:type_name -> relationalai.lqp.v1.CSVConfig 13, // 19: relationalai.lqp.v1.ExportCSVConfig.data_columns:type_name -> relationalai.lqp.v1.ExportCSVColumn - 26, // 20: relationalai.lqp.v1.ExportCSVColumn.column_data:type_name -> relationalai.lqp.v1.RelationId + 28, // 20: relationalai.lqp.v1.ExportCSVColumn.column_data:type_name -> relationalai.lqp.v1.RelationId 13, // 21: relationalai.lqp.v1.ExportCSVColumns.columns:type_name -> relationalai.lqp.v1.ExportCSVColumn 14, // 22: relationalai.lqp.v1.ExportCSVSource.gnf_columns:type_name -> relationalai.lqp.v1.ExportCSVColumns - 26, // 23: relationalai.lqp.v1.ExportCSVSource.table_def:type_name -> relationalai.lqp.v1.RelationId - 28, // 24: relationalai.lqp.v1.ExportIcebergConfig.locator:type_name -> relationalai.lqp.v1.IcebergLocator - 29, // 25: relationalai.lqp.v1.ExportIcebergConfig.config:type_name -> relationalai.lqp.v1.IcebergCatalogConfig - 26, // 26: relationalai.lqp.v1.ExportIcebergConfig.table_def:type_name -> relationalai.lqp.v1.RelationId - 23, // 27: relationalai.lqp.v1.ExportIcebergConfig.table_properties:type_name -> relationalai.lqp.v1.ExportIcebergConfig.TablePropertiesEntry + 28, // 23: relationalai.lqp.v1.ExportCSVSource.table_def:type_name -> relationalai.lqp.v1.RelationId + 30, // 24: relationalai.lqp.v1.ExportIcebergConfig.locator:type_name -> relationalai.lqp.v1.IcebergLocator + 31, // 25: relationalai.lqp.v1.ExportIcebergConfig.config:type_name -> relationalai.lqp.v1.IcebergCatalogConfig + 28, // 26: relationalai.lqp.v1.ExportIcebergConfig.table_def:type_name -> relationalai.lqp.v1.RelationId + 25, // 27: relationalai.lqp.v1.ExportIcebergConfig.table_properties:type_name -> relationalai.lqp.v1.ExportIcebergConfig.TablePropertiesEntry 18, // 28: relationalai.lqp.v1.Read.demand:type_name -> relationalai.lqp.v1.Demand 19, // 29: relationalai.lqp.v1.Read.output:type_name -> relationalai.lqp.v1.Output 21, // 30: relationalai.lqp.v1.Read.what_if:type_name -> relationalai.lqp.v1.WhatIf 22, // 31: relationalai.lqp.v1.Read.abort:type_name -> relationalai.lqp.v1.Abort 20, // 32: relationalai.lqp.v1.Read.export:type_name -> relationalai.lqp.v1.Export - 26, // 33: relationalai.lqp.v1.Demand.relation_id:type_name -> relationalai.lqp.v1.RelationId - 26, // 34: relationalai.lqp.v1.Output.relation_id:type_name -> relationalai.lqp.v1.RelationId - 12, // 35: relationalai.lqp.v1.Export.csv_config:type_name -> relationalai.lqp.v1.ExportCSVConfig - 16, // 36: relationalai.lqp.v1.Export.iceberg_config:type_name -> relationalai.lqp.v1.ExportIcebergConfig - 5, // 37: relationalai.lqp.v1.WhatIf.epoch:type_name -> relationalai.lqp.v1.Epoch - 26, // 38: relationalai.lqp.v1.Abort.relation_id:type_name -> relationalai.lqp.v1.RelationId - 39, // [39:39] is the sub-list for method output_type - 39, // [39:39] is the sub-list for method input_type - 39, // [39:39] is the sub-list for extension type_name - 39, // [39:39] is the sub-list for extension extendee - 0, // [0:39] is the sub-list for field type_name + 24, // 33: relationalai.lqp.v1.Read.export_output:type_name -> relationalai.lqp.v1.ExportOutput + 28, // 34: relationalai.lqp.v1.Demand.relation_id:type_name -> relationalai.lqp.v1.RelationId + 28, // 35: relationalai.lqp.v1.Output.relation_id:type_name -> relationalai.lqp.v1.RelationId + 12, // 36: relationalai.lqp.v1.Export.csv_config:type_name -> relationalai.lqp.v1.ExportCSVConfig + 16, // 37: relationalai.lqp.v1.Export.iceberg_config:type_name -> relationalai.lqp.v1.ExportIcebergConfig + 5, // 38: relationalai.lqp.v1.WhatIf.epoch:type_name -> relationalai.lqp.v1.Epoch + 28, // 39: relationalai.lqp.v1.Abort.relation_id:type_name -> relationalai.lqp.v1.RelationId + 15, // 40: relationalai.lqp.v1.ExportCSVOutput.csv_source:type_name -> relationalai.lqp.v1.ExportCSVSource + 29, // 41: relationalai.lqp.v1.ExportCSVOutput.csv_config:type_name -> relationalai.lqp.v1.CSVConfig + 23, // 42: relationalai.lqp.v1.ExportOutput.csv:type_name -> relationalai.lqp.v1.ExportCSVOutput + 43, // [43:43] is the sub-list for method output_type + 43, // [43:43] is the sub-list for method input_type + 43, // [43:43] is the sub-list for extension type_name + 43, // [43:43] is the sub-list for extension extendee + 0, // [0:43] is the sub-list for field type_name } func init() { file_relationalai_lqp_v1_transactions_proto_init() } @@ -1869,18 +2031,22 @@ func file_relationalai_lqp_v1_transactions_proto_init() { (*Read_WhatIf)(nil), (*Read_Abort)(nil), (*Read_Export)(nil), + (*Read_ExportOutput)(nil), } file_relationalai_lqp_v1_transactions_proto_msgTypes[19].OneofWrappers = []any{ (*Export_CsvConfig)(nil), (*Export_IcebergConfig)(nil), } + file_relationalai_lqp_v1_transactions_proto_msgTypes[23].OneofWrappers = []any{ + (*ExportOutput_Csv)(nil), + } type x struct{} out := protoimpl.TypeBuilder{ File: protoimpl.DescBuilder{ GoPackagePath: reflect.TypeOf(x{}).PkgPath(), RawDescriptor: unsafe.Slice(unsafe.StringData(file_relationalai_lqp_v1_transactions_proto_rawDesc), len(file_relationalai_lqp_v1_transactions_proto_rawDesc)), NumEnums: 1, - NumMessages: 23, + NumMessages: 25, NumExtensions: 0, NumServices: 0, }, diff --git a/sdks/go/src/parser.go b/sdks/go/src/parser.go index a5962189..1514fad8 100644 --- a/sdks/go/src/parser.go +++ b/sdks/go/src/parser.go @@ -655,170 +655,170 @@ func toPascalCase(s string) string { // --- Helper functions --- func (p *Parser) _extract_value_int32(value *pb.Value, default_ int64) int32 { - var _t2101 interface{} + var _t2126 interface{} if (value != nil && hasProtoField(value, "int32_value")) { return value.GetInt32Value() } - _ = _t2101 + _ = _t2126 return int32(default_) } func (p *Parser) _extract_value_int64(value *pb.Value, default_ int64) int64 { - var _t2102 interface{} + var _t2127 interface{} if (value != nil && hasProtoField(value, "int_value")) { return value.GetIntValue() } - _ = _t2102 + _ = _t2127 return default_ } func (p *Parser) _extract_value_string(value *pb.Value, default_ string) string { - var _t2103 interface{} + var _t2128 interface{} if (value != nil && hasProtoField(value, "string_value")) { return value.GetStringValue() } - _ = _t2103 + _ = _t2128 return default_ } func (p *Parser) _extract_value_boolean(value *pb.Value, default_ bool) bool { - var _t2104 interface{} + var _t2129 interface{} if (value != nil && hasProtoField(value, "boolean_value")) { return value.GetBooleanValue() } - _ = _t2104 + _ = _t2129 return default_ } func (p *Parser) _extract_value_string_list(value *pb.Value, default_ []string) []string { - var _t2105 interface{} + var _t2130 interface{} if (value != nil && hasProtoField(value, "string_value")) { return []string{value.GetStringValue()} } - _ = _t2105 + _ = _t2130 return default_ } func (p *Parser) _try_extract_value_int64(value *pb.Value) *int64 { - var _t2106 interface{} + var _t2131 interface{} if (value != nil && hasProtoField(value, "int_value")) { return ptr(value.GetIntValue()) } - _ = _t2106 + _ = _t2131 return nil } func (p *Parser) _try_extract_value_float64(value *pb.Value) *float64 { - var _t2107 interface{} + var _t2132 interface{} if (value != nil && hasProtoField(value, "float_value")) { return ptr(value.GetFloatValue()) } - _ = _t2107 + _ = _t2132 return nil } func (p *Parser) _try_extract_value_bytes(value *pb.Value) []byte { - var _t2108 interface{} + var _t2133 interface{} if (value != nil && hasProtoField(value, "string_value")) { return []byte(value.GetStringValue()) } - _ = _t2108 + _ = _t2133 return nil } func (p *Parser) _try_extract_value_uint128(value *pb.Value) *pb.UInt128Value { - var _t2109 interface{} + var _t2134 interface{} if (value != nil && hasProtoField(value, "uint128_value")) { return value.GetUint128Value() } - _ = _t2109 + _ = _t2134 return nil } func (p *Parser) construct_csv_config(config_dict [][]interface{}, storage_integration_opt [][]interface{}) *pb.CSVConfig { config := dictFromList(config_dict) - _t2110 := p._extract_value_int32(dictGetValue(config, "csv_header_row"), 1) - header_row := _t2110 - _t2111 := p._extract_value_int64(dictGetValue(config, "csv_skip"), 0) - skip := _t2111 - _t2112 := p._extract_value_string(dictGetValue(config, "csv_new_line"), "") - new_line := _t2112 - _t2113 := p._extract_value_string(dictGetValue(config, "csv_delimiter"), ",") - delimiter := _t2113 - _t2114 := p._extract_value_string(dictGetValue(config, "csv_quotechar"), "\"") - quotechar := _t2114 - _t2115 := p._extract_value_string(dictGetValue(config, "csv_escapechar"), "\"") - escapechar := _t2115 - _t2116 := p._extract_value_string(dictGetValue(config, "csv_comment"), "") - comment := _t2116 - _t2117 := p._extract_value_string_list(dictGetValue(config, "csv_missing_strings"), []string{}) - missing_strings := _t2117 - _t2118 := p._extract_value_string(dictGetValue(config, "csv_decimal_separator"), ".") - decimal_separator := _t2118 - _t2119 := p._extract_value_string(dictGetValue(config, "csv_encoding"), "utf-8") - encoding := _t2119 - _t2120 := p._extract_value_string(dictGetValue(config, "csv_compression"), "") - compression := _t2120 - _t2121 := p._extract_value_int64(dictGetValue(config, "csv_partition_size_mb"), 0) - partition_size_mb := _t2121 - _t2122 := p.construct_csv_storage_integration(storage_integration_opt) - storage_integration := _t2122 - _t2123 := &pb.CSVConfig{HeaderRow: header_row, Skip: skip, NewLine: new_line, Delimiter: delimiter, Quotechar: quotechar, Escapechar: escapechar, Comment: comment, MissingStrings: missing_strings, DecimalSeparator: decimal_separator, Encoding: encoding, Compression: compression, PartitionSizeMb: partition_size_mb, StorageIntegration: storage_integration} - return _t2123 + _t2135 := p._extract_value_int32(dictGetValue(config, "csv_header_row"), 1) + header_row := _t2135 + _t2136 := p._extract_value_int64(dictGetValue(config, "csv_skip"), 0) + skip := _t2136 + _t2137 := p._extract_value_string(dictGetValue(config, "csv_new_line"), "") + new_line := _t2137 + _t2138 := p._extract_value_string(dictGetValue(config, "csv_delimiter"), ",") + delimiter := _t2138 + _t2139 := p._extract_value_string(dictGetValue(config, "csv_quotechar"), "\"") + quotechar := _t2139 + _t2140 := p._extract_value_string(dictGetValue(config, "csv_escapechar"), "\"") + escapechar := _t2140 + _t2141 := p._extract_value_string(dictGetValue(config, "csv_comment"), "") + comment := _t2141 + _t2142 := p._extract_value_string_list(dictGetValue(config, "csv_missing_strings"), []string{}) + missing_strings := _t2142 + _t2143 := p._extract_value_string(dictGetValue(config, "csv_decimal_separator"), ".") + decimal_separator := _t2143 + _t2144 := p._extract_value_string(dictGetValue(config, "csv_encoding"), "utf-8") + encoding := _t2144 + _t2145 := p._extract_value_string(dictGetValue(config, "csv_compression"), "") + compression := _t2145 + _t2146 := p._extract_value_int64(dictGetValue(config, "csv_partition_size_mb"), 0) + partition_size_mb := _t2146 + _t2147 := p.construct_csv_storage_integration(storage_integration_opt) + storage_integration := _t2147 + _t2148 := &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 _t2148 } func (p *Parser) construct_csv_storage_integration(storage_integration_opt [][]interface{}) *pb.StorageIntegration { - var _t2124 interface{} + var _t2149 interface{} if storage_integration_opt == nil { return nil } - _ = _t2124 + _ = _t2149 config := dictFromList(storage_integration_opt) - _t2125 := p._extract_value_string(dictGetValue(config, "provider"), "") - _t2126 := p._extract_value_string(dictGetValue(config, "azure_sas_token"), "") - _t2127 := p._extract_value_string(dictGetValue(config, "s3_region"), "") - _t2128 := p._extract_value_string(dictGetValue(config, "s3_access_key_id"), "") - _t2129 := p._extract_value_string(dictGetValue(config, "s3_secret_access_key"), "") - _t2130 := &pb.StorageIntegration{Provider: _t2125, AzureSasToken: _t2126, S3Region: _t2127, S3AccessKeyId: _t2128, S3SecretAccessKey: _t2129} - return _t2130 + _t2150 := p._extract_value_string(dictGetValue(config, "provider"), "") + _t2151 := p._extract_value_string(dictGetValue(config, "azure_sas_token"), "") + _t2152 := p._extract_value_string(dictGetValue(config, "s3_region"), "") + _t2153 := p._extract_value_string(dictGetValue(config, "s3_access_key_id"), "") + _t2154 := p._extract_value_string(dictGetValue(config, "s3_secret_access_key"), "") + _t2155 := &pb.StorageIntegration{Provider: _t2150, AzureSasToken: _t2151, S3Region: _t2152, S3AccessKeyId: _t2153, S3SecretAccessKey: _t2154} + return _t2155 } func (p *Parser) construct_betree_info(key_types []*pb.Type, value_types []*pb.Type, config_dict [][]interface{}) *pb.BeTreeInfo { config := dictFromList(config_dict) - _t2131 := p._try_extract_value_float64(dictGetValue(config, "betree_config_epsilon")) - epsilon := _t2131 - _t2132 := p._try_extract_value_int64(dictGetValue(config, "betree_config_max_pivots")) - max_pivots := _t2132 - _t2133 := p._try_extract_value_int64(dictGetValue(config, "betree_config_max_deltas")) - max_deltas := _t2133 - _t2134 := p._try_extract_value_int64(dictGetValue(config, "betree_config_max_leaf")) - max_leaf := _t2134 - _t2135 := &pb.BeTreeConfig{Epsilon: deref(epsilon, 0.0), MaxPivots: deref(max_pivots, 0), MaxDeltas: deref(max_deltas, 0), MaxLeaf: deref(max_leaf, 0)} - storage_config := _t2135 - _t2136 := p._try_extract_value_uint128(dictGetValue(config, "betree_locator_root_pageid")) - root_pageid := _t2136 - _t2137 := p._try_extract_value_bytes(dictGetValue(config, "betree_locator_inline_data")) - inline_data := _t2137 - _t2138 := p._try_extract_value_int64(dictGetValue(config, "betree_locator_element_count")) - element_count := _t2138 - _t2139 := p._try_extract_value_int64(dictGetValue(config, "betree_locator_tree_height")) - tree_height := _t2139 - _t2140 := &pb.BeTreeLocator{ElementCount: deref(element_count, 0), TreeHeight: deref(tree_height, 0)} + _t2156 := p._try_extract_value_float64(dictGetValue(config, "betree_config_epsilon")) + epsilon := _t2156 + _t2157 := p._try_extract_value_int64(dictGetValue(config, "betree_config_max_pivots")) + max_pivots := _t2157 + _t2158 := p._try_extract_value_int64(dictGetValue(config, "betree_config_max_deltas")) + max_deltas := _t2158 + _t2159 := p._try_extract_value_int64(dictGetValue(config, "betree_config_max_leaf")) + max_leaf := _t2159 + _t2160 := &pb.BeTreeConfig{Epsilon: deref(epsilon, 0.0), MaxPivots: deref(max_pivots, 0), MaxDeltas: deref(max_deltas, 0), MaxLeaf: deref(max_leaf, 0)} + storage_config := _t2160 + _t2161 := p._try_extract_value_uint128(dictGetValue(config, "betree_locator_root_pageid")) + root_pageid := _t2161 + _t2162 := p._try_extract_value_bytes(dictGetValue(config, "betree_locator_inline_data")) + inline_data := _t2162 + _t2163 := p._try_extract_value_int64(dictGetValue(config, "betree_locator_element_count")) + element_count := _t2163 + _t2164 := p._try_extract_value_int64(dictGetValue(config, "betree_locator_tree_height")) + tree_height := _t2164 + _t2165 := &pb.BeTreeLocator{ElementCount: deref(element_count, 0), TreeHeight: deref(tree_height, 0)} if root_pageid != nil { - _t2140.Location = &pb.BeTreeLocator_RootPageid{RootPageid: root_pageid} + _t2165.Location = &pb.BeTreeLocator_RootPageid{RootPageid: root_pageid} } else { - _t2140.Location = &pb.BeTreeLocator_InlineData{InlineData: inline_data} + _t2165.Location = &pb.BeTreeLocator_InlineData{InlineData: inline_data} } - relation_locator := _t2140 - _t2141 := &pb.BeTreeInfo{KeyTypes: key_types, ValueTypes: value_types, StorageConfig: storage_config, RelationLocator: relation_locator} - return _t2141 + relation_locator := _t2165 + _t2166 := &pb.BeTreeInfo{KeyTypes: key_types, ValueTypes: value_types, StorageConfig: storage_config, RelationLocator: relation_locator} + return _t2166 } func (p *Parser) default_configure() *pb.Configure { - _t2142 := &pb.IVMConfig{Level: pb.MaintenanceLevel_MAINTENANCE_LEVEL_OFF} - ivm_config := _t2142 - _t2143 := &pb.Configure{SemanticsVersion: 0, IvmConfig: ivm_config} - return _t2143 + _t2167 := &pb.IVMConfig{Level: pb.MaintenanceLevel_MAINTENANCE_LEVEL_OFF} + ivm_config := _t2167 + _t2168 := &pb.Configure{SemanticsVersion: 0, IvmConfig: ivm_config} + return _t2168 } func (p *Parser) construct_configure(config_dict [][]interface{}) *pb.Configure { @@ -840,4274 +840,4319 @@ func (p *Parser) construct_configure(config_dict [][]interface{}) *pb.Configure } } } - _t2144 := &pb.IVMConfig{Level: maintenance_level} - ivm_config := _t2144 - _t2145 := p._extract_value_int64(dictGetValue(config, "semantics_version"), 0) - semantics_version := _t2145 - _t2146 := &pb.Configure{SemanticsVersion: semantics_version, IvmConfig: ivm_config} - return _t2146 + _t2169 := &pb.IVMConfig{Level: maintenance_level} + ivm_config := _t2169 + _t2170 := p._extract_value_int64(dictGetValue(config, "semantics_version"), 0) + semantics_version := _t2170 + _t2171 := &pb.Configure{SemanticsVersion: semantics_version, IvmConfig: ivm_config} + return _t2171 } func (p *Parser) construct_export_csv_config(path string, columns []*pb.ExportCSVColumn, config_dict [][]interface{}) *pb.ExportCSVConfig { config := dictFromList(config_dict) - _t2147 := p._extract_value_int64(dictGetValue(config, "partition_size"), 0) - partition_size := _t2147 - _t2148 := p._extract_value_string(dictGetValue(config, "compression"), "") - compression := _t2148 - _t2149 := p._extract_value_boolean(dictGetValue(config, "syntax_header_row"), true) - syntax_header_row := _t2149 - _t2150 := p._extract_value_string(dictGetValue(config, "syntax_missing_string"), "") - syntax_missing_string := _t2150 - _t2151 := p._extract_value_string(dictGetValue(config, "syntax_delim"), ",") - syntax_delim := _t2151 - _t2152 := p._extract_value_string(dictGetValue(config, "syntax_quotechar"), "\"") - syntax_quotechar := _t2152 - _t2153 := p._extract_value_string(dictGetValue(config, "syntax_escapechar"), "\\") - syntax_escapechar := _t2153 - _t2154 := &pb.ExportCSVConfig{Path: path, DataColumns: columns, PartitionSize: ptr(partition_size), Compression: ptr(compression), SyntaxHeaderRow: ptr(syntax_header_row), SyntaxMissingString: ptr(syntax_missing_string), SyntaxDelim: ptr(syntax_delim), SyntaxQuotechar: ptr(syntax_quotechar), SyntaxEscapechar: ptr(syntax_escapechar)} - return _t2154 + _t2172 := p._extract_value_int64(dictGetValue(config, "partition_size"), 0) + partition_size := _t2172 + _t2173 := p._extract_value_string(dictGetValue(config, "compression"), "") + compression := _t2173 + _t2174 := p._extract_value_boolean(dictGetValue(config, "syntax_header_row"), true) + syntax_header_row := _t2174 + _t2175 := p._extract_value_string(dictGetValue(config, "syntax_missing_string"), "") + syntax_missing_string := _t2175 + _t2176 := p._extract_value_string(dictGetValue(config, "syntax_delim"), ",") + syntax_delim := _t2176 + _t2177 := p._extract_value_string(dictGetValue(config, "syntax_quotechar"), "\"") + syntax_quotechar := _t2177 + _t2178 := p._extract_value_string(dictGetValue(config, "syntax_escapechar"), "\\") + syntax_escapechar := _t2178 + _t2179 := &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 _t2179 } func (p *Parser) construct_export_csv_config_with_source(path string, csv_source *pb.ExportCSVSource, csv_config *pb.CSVConfig) *pb.ExportCSVConfig { - _t2155 := &pb.ExportCSVConfig{Path: path, CsvSource: csv_source, CsvConfig: csv_config} - return _t2155 + _t2180 := &pb.ExportCSVConfig{Path: path, CsvSource: csv_source, CsvConfig: csv_config} + return _t2180 } func (p *Parser) construct_iceberg_catalog_config(catalog_uri string, scope_opt *string, property_pairs [][]interface{}, auth_property_pairs [][]interface{}) *pb.IcebergCatalogConfig { props := stringMapFromPairs(property_pairs) auth_props := stringMapFromPairs(auth_property_pairs) - _t2156 := &pb.IcebergCatalogConfig{CatalogUri: catalog_uri, Scope: ptr(deref(scope_opt, "")), Properties: props, AuthProperties: auth_props} - return _t2156 + _t2181 := &pb.IcebergCatalogConfig{CatalogUri: catalog_uri, Scope: ptr(deref(scope_opt, "")), Properties: props, AuthProperties: auth_props} + return _t2181 } func (p *Parser) construct_iceberg_data(locator *pb.IcebergLocator, config *pb.IcebergCatalogConfig, columns []*pb.GNFColumn, from_snapshot_opt *string, to_snapshot_opt *string, returns_delta bool) *pb.IcebergData { - _t2157 := &pb.IcebergData{Locator: locator, Config: config, Columns: columns, FromSnapshot: ptr(deref(from_snapshot_opt, "")), ToSnapshot: ptr(deref(to_snapshot_opt, "")), ReturnsDelta: returns_delta} - return _t2157 + _t2182 := &pb.IcebergData{Locator: locator, Config: config, Columns: columns, FromSnapshot: ptr(deref(from_snapshot_opt, "")), ToSnapshot: ptr(deref(to_snapshot_opt, "")), ReturnsDelta: returns_delta} + return _t2182 } func (p *Parser) construct_export_iceberg_config_full(locator *pb.IcebergLocator, config *pb.IcebergCatalogConfig, table_def *pb.RelationId, table_property_pairs [][]interface{}, config_dict [][]interface{}) *pb.ExportIcebergConfig { - _t2158 := config_dict + _t2183 := config_dict if config_dict == nil { - _t2158 = [][]interface{}{} - } - cfg := dictFromList(_t2158) - _t2159 := p._extract_value_string(dictGetValue(cfg, "prefix"), "") - prefix := _t2159 - _t2160 := p._extract_value_int64(dictGetValue(cfg, "target_file_size_bytes"), 0) - target_file_size_bytes := _t2160 - _t2161 := p._extract_value_string(dictGetValue(cfg, "compression"), "") - compression := _t2161 + _t2183 = [][]interface{}{} + } + cfg := dictFromList(_t2183) + _t2184 := p._extract_value_string(dictGetValue(cfg, "prefix"), "") + prefix := _t2184 + _t2185 := p._extract_value_int64(dictGetValue(cfg, "target_file_size_bytes"), 0) + target_file_size_bytes := _t2185 + _t2186 := p._extract_value_string(dictGetValue(cfg, "compression"), "") + compression := _t2186 table_props := stringMapFromPairs(table_property_pairs) - _t2162 := &pb.ExportIcebergConfig{Locator: locator, Config: config, TableDef: table_def, Prefix: ptr(prefix), TargetFileSizeBytes: ptr(target_file_size_bytes), Compression: compression, TableProperties: table_props} - return _t2162 + _t2187 := &pb.ExportIcebergConfig{Locator: locator, Config: config, TableDef: table_def, Prefix: ptr(prefix), TargetFileSizeBytes: ptr(target_file_size_bytes), Compression: compression, TableProperties: table_props} + return _t2187 } // --- Parse functions --- func (p *Parser) parse_transaction() *pb.Transaction { - span_start673 := int64(p.spanStart()) + span_start681 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("transaction") - var _t1334 *pb.Configure + var _t1350 *pb.Configure if (p.matchLookaheadLiteral("(", 0) && p.matchLookaheadLiteral("configure", 1)) { - _t1335 := p.parse_configure() - _t1334 = _t1335 + _t1351 := p.parse_configure() + _t1350 = _t1351 } - configure667 := _t1334 - var _t1336 *pb.Sync + configure675 := _t1350 + var _t1352 *pb.Sync if (p.matchLookaheadLiteral("(", 0) && p.matchLookaheadLiteral("sync", 1)) { - _t1337 := p.parse_sync() - _t1336 = _t1337 - } - sync668 := _t1336 - xs669 := []*pb.Epoch{} - cond670 := p.matchLookaheadLiteral("(", 0) - for cond670 { - _t1338 := p.parse_epoch() - item671 := _t1338 - xs669 = append(xs669, item671) - cond670 = p.matchLookaheadLiteral("(", 0) - } - epochs672 := xs669 + _t1353 := p.parse_sync() + _t1352 = _t1353 + } + sync676 := _t1352 + xs677 := []*pb.Epoch{} + cond678 := p.matchLookaheadLiteral("(", 0) + for cond678 { + _t1354 := p.parse_epoch() + item679 := _t1354 + xs677 = append(xs677, item679) + cond678 = p.matchLookaheadLiteral("(", 0) + } + epochs680 := xs677 p.consumeLiteral(")") - _t1339 := p.default_configure() - _t1340 := configure667 - if configure667 == nil { - _t1340 = _t1339 + _t1355 := p.default_configure() + _t1356 := configure675 + if configure675 == nil { + _t1356 = _t1355 } - _t1341 := &pb.Transaction{Epochs: epochs672, Configure: _t1340, Sync: sync668} - result674 := _t1341 - p.recordSpan(int(span_start673), "Transaction") - return result674 + _t1357 := &pb.Transaction{Epochs: epochs680, Configure: _t1356, Sync: sync676} + result682 := _t1357 + p.recordSpan(int(span_start681), "Transaction") + return result682 } func (p *Parser) parse_configure() *pb.Configure { - span_start676 := int64(p.spanStart()) + span_start684 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("configure") - _t1342 := p.parse_config_dict() - config_dict675 := _t1342 + _t1358 := p.parse_config_dict() + config_dict683 := _t1358 p.consumeLiteral(")") - _t1343 := p.construct_configure(config_dict675) - result677 := _t1343 - p.recordSpan(int(span_start676), "Configure") - return result677 + _t1359 := p.construct_configure(config_dict683) + result685 := _t1359 + p.recordSpan(int(span_start684), "Configure") + return result685 } func (p *Parser) parse_config_dict() [][]interface{} { p.consumeLiteral("{") - xs678 := [][]interface{}{} - cond679 := p.matchLookaheadLiteral(":", 0) - for cond679 { - _t1344 := p.parse_config_key_value() - item680 := _t1344 - xs678 = append(xs678, item680) - cond679 = p.matchLookaheadLiteral(":", 0) - } - config_key_values681 := xs678 + xs686 := [][]interface{}{} + cond687 := p.matchLookaheadLiteral(":", 0) + for cond687 { + _t1360 := p.parse_config_key_value() + item688 := _t1360 + xs686 = append(xs686, item688) + cond687 = p.matchLookaheadLiteral(":", 0) + } + config_key_values689 := xs686 p.consumeLiteral("}") - return config_key_values681 + return config_key_values689 } func (p *Parser) parse_config_key_value() []interface{} { p.consumeLiteral(":") - symbol682 := p.consumeTerminal("SYMBOL").Value.str - _t1345 := p.parse_raw_value() - raw_value683 := _t1345 - return []interface{}{symbol682, raw_value683} + symbol690 := p.consumeTerminal("SYMBOL").Value.str + _t1361 := p.parse_raw_value() + raw_value691 := _t1361 + return []interface{}{symbol690, raw_value691} } func (p *Parser) parse_raw_value() *pb.Value { - span_start697 := int64(p.spanStart()) - var _t1346 int64 + span_start705 := int64(p.spanStart()) + var _t1362 int64 if p.matchLookaheadLiteral("true", 0) { - _t1346 = 12 + _t1362 = 12 } else { - var _t1347 int64 + var _t1363 int64 if p.matchLookaheadLiteral("missing", 0) { - _t1347 = 11 + _t1363 = 11 } else { - var _t1348 int64 + var _t1364 int64 if p.matchLookaheadLiteral("false", 0) { - _t1348 = 12 + _t1364 = 12 } else { - var _t1349 int64 + var _t1365 int64 if p.matchLookaheadLiteral("(", 0) { - var _t1350 int64 + var _t1366 int64 if p.matchLookaheadLiteral("datetime", 1) { - _t1350 = 1 + _t1366 = 1 } else { - var _t1351 int64 + var _t1367 int64 if p.matchLookaheadLiteral("date", 1) { - _t1351 = 0 + _t1367 = 0 } else { - _t1351 = -1 + _t1367 = -1 } - _t1350 = _t1351 + _t1366 = _t1367 } - _t1349 = _t1350 + _t1365 = _t1366 } else { - var _t1352 int64 + var _t1368 int64 if p.matchLookaheadTerminal("UINT32", 0) { - _t1352 = 7 + _t1368 = 7 } else { - var _t1353 int64 + var _t1369 int64 if p.matchLookaheadTerminal("UINT128", 0) { - _t1353 = 8 + _t1369 = 8 } else { - var _t1354 int64 + var _t1370 int64 if p.matchLookaheadTerminal("STRING", 0) { - _t1354 = 2 + _t1370 = 2 } else { - var _t1355 int64 + var _t1371 int64 if p.matchLookaheadTerminal("INT32", 0) { - _t1355 = 3 + _t1371 = 3 } else { - var _t1356 int64 + var _t1372 int64 if p.matchLookaheadTerminal("INT128", 0) { - _t1356 = 9 + _t1372 = 9 } else { - var _t1357 int64 + var _t1373 int64 if p.matchLookaheadTerminal("INT", 0) { - _t1357 = 4 + _t1373 = 4 } else { - var _t1358 int64 + var _t1374 int64 if p.matchLookaheadTerminal("FLOAT32", 0) { - _t1358 = 5 + _t1374 = 5 } else { - var _t1359 int64 + var _t1375 int64 if p.matchLookaheadTerminal("FLOAT", 0) { - _t1359 = 6 + _t1375 = 6 } else { - var _t1360 int64 + var _t1376 int64 if p.matchLookaheadTerminal("DECIMAL", 0) { - _t1360 = 10 + _t1376 = 10 } else { - _t1360 = -1 + _t1376 = -1 } - _t1359 = _t1360 + _t1375 = _t1376 } - _t1358 = _t1359 + _t1374 = _t1375 } - _t1357 = _t1358 + _t1373 = _t1374 } - _t1356 = _t1357 + _t1372 = _t1373 } - _t1355 = _t1356 + _t1371 = _t1372 } - _t1354 = _t1355 + _t1370 = _t1371 } - _t1353 = _t1354 + _t1369 = _t1370 } - _t1352 = _t1353 + _t1368 = _t1369 } - _t1349 = _t1352 + _t1365 = _t1368 } - _t1348 = _t1349 + _t1364 = _t1365 } - _t1347 = _t1348 + _t1363 = _t1364 } - _t1346 = _t1347 - } - prediction684 := _t1346 - var _t1361 *pb.Value - if prediction684 == 12 { - _t1362 := p.parse_boolean_value() - boolean_value696 := _t1362 - _t1363 := &pb.Value{} - _t1363.Value = &pb.Value_BooleanValue{BooleanValue: boolean_value696} - _t1361 = _t1363 + _t1362 = _t1363 + } + prediction692 := _t1362 + var _t1377 *pb.Value + if prediction692 == 12 { + _t1378 := p.parse_boolean_value() + boolean_value704 := _t1378 + _t1379 := &pb.Value{} + _t1379.Value = &pb.Value_BooleanValue{BooleanValue: boolean_value704} + _t1377 = _t1379 } else { - var _t1364 *pb.Value - if prediction684 == 11 { + var _t1380 *pb.Value + if prediction692 == 11 { p.consumeLiteral("missing") - _t1365 := &pb.MissingValue{} - _t1366 := &pb.Value{} - _t1366.Value = &pb.Value_MissingValue{MissingValue: _t1365} - _t1364 = _t1366 + _t1381 := &pb.MissingValue{} + _t1382 := &pb.Value{} + _t1382.Value = &pb.Value_MissingValue{MissingValue: _t1381} + _t1380 = _t1382 } else { - var _t1367 *pb.Value - if prediction684 == 10 { - decimal695 := p.consumeTerminal("DECIMAL").Value.decimal - _t1368 := &pb.Value{} - _t1368.Value = &pb.Value_DecimalValue{DecimalValue: decimal695} - _t1367 = _t1368 + var _t1383 *pb.Value + if prediction692 == 10 { + decimal703 := p.consumeTerminal("DECIMAL").Value.decimal + _t1384 := &pb.Value{} + _t1384.Value = &pb.Value_DecimalValue{DecimalValue: decimal703} + _t1383 = _t1384 } else { - var _t1369 *pb.Value - if prediction684 == 9 { - int128694 := p.consumeTerminal("INT128").Value.int128 - _t1370 := &pb.Value{} - _t1370.Value = &pb.Value_Int128Value{Int128Value: int128694} - _t1369 = _t1370 + var _t1385 *pb.Value + if prediction692 == 9 { + int128702 := p.consumeTerminal("INT128").Value.int128 + _t1386 := &pb.Value{} + _t1386.Value = &pb.Value_Int128Value{Int128Value: int128702} + _t1385 = _t1386 } else { - var _t1371 *pb.Value - if prediction684 == 8 { - uint128693 := p.consumeTerminal("UINT128").Value.uint128 - _t1372 := &pb.Value{} - _t1372.Value = &pb.Value_Uint128Value{Uint128Value: uint128693} - _t1371 = _t1372 + var _t1387 *pb.Value + if prediction692 == 8 { + uint128701 := p.consumeTerminal("UINT128").Value.uint128 + _t1388 := &pb.Value{} + _t1388.Value = &pb.Value_Uint128Value{Uint128Value: uint128701} + _t1387 = _t1388 } else { - var _t1373 *pb.Value - if prediction684 == 7 { - uint32692 := p.consumeTerminal("UINT32").Value.u32 - _t1374 := &pb.Value{} - _t1374.Value = &pb.Value_Uint32Value{Uint32Value: uint32692} - _t1373 = _t1374 + var _t1389 *pb.Value + if prediction692 == 7 { + uint32700 := p.consumeTerminal("UINT32").Value.u32 + _t1390 := &pb.Value{} + _t1390.Value = &pb.Value_Uint32Value{Uint32Value: uint32700} + _t1389 = _t1390 } else { - var _t1375 *pb.Value - if prediction684 == 6 { - float691 := p.consumeTerminal("FLOAT").Value.f64 - _t1376 := &pb.Value{} - _t1376.Value = &pb.Value_FloatValue{FloatValue: float691} - _t1375 = _t1376 + var _t1391 *pb.Value + if prediction692 == 6 { + float699 := p.consumeTerminal("FLOAT").Value.f64 + _t1392 := &pb.Value{} + _t1392.Value = &pb.Value_FloatValue{FloatValue: float699} + _t1391 = _t1392 } else { - var _t1377 *pb.Value - if prediction684 == 5 { - float32690 := p.consumeTerminal("FLOAT32").Value.f32 - _t1378 := &pb.Value{} - _t1378.Value = &pb.Value_Float32Value{Float32Value: float32690} - _t1377 = _t1378 + var _t1393 *pb.Value + if prediction692 == 5 { + float32698 := p.consumeTerminal("FLOAT32").Value.f32 + _t1394 := &pb.Value{} + _t1394.Value = &pb.Value_Float32Value{Float32Value: float32698} + _t1393 = _t1394 } else { - var _t1379 *pb.Value - if prediction684 == 4 { - int689 := p.consumeTerminal("INT").Value.i64 - _t1380 := &pb.Value{} - _t1380.Value = &pb.Value_IntValue{IntValue: int689} - _t1379 = _t1380 + var _t1395 *pb.Value + if prediction692 == 4 { + int697 := p.consumeTerminal("INT").Value.i64 + _t1396 := &pb.Value{} + _t1396.Value = &pb.Value_IntValue{IntValue: int697} + _t1395 = _t1396 } else { - var _t1381 *pb.Value - if prediction684 == 3 { - int32688 := p.consumeTerminal("INT32").Value.i32 - _t1382 := &pb.Value{} - _t1382.Value = &pb.Value_Int32Value{Int32Value: int32688} - _t1381 = _t1382 + var _t1397 *pb.Value + if prediction692 == 3 { + int32696 := p.consumeTerminal("INT32").Value.i32 + _t1398 := &pb.Value{} + _t1398.Value = &pb.Value_Int32Value{Int32Value: int32696} + _t1397 = _t1398 } else { - var _t1383 *pb.Value - if prediction684 == 2 { - string687 := p.consumeTerminal("STRING").Value.str - _t1384 := &pb.Value{} - _t1384.Value = &pb.Value_StringValue{StringValue: string687} - _t1383 = _t1384 + var _t1399 *pb.Value + if prediction692 == 2 { + string695 := p.consumeTerminal("STRING").Value.str + _t1400 := &pb.Value{} + _t1400.Value = &pb.Value_StringValue{StringValue: string695} + _t1399 = _t1400 } else { - var _t1385 *pb.Value - if prediction684 == 1 { - _t1386 := p.parse_raw_datetime() - raw_datetime686 := _t1386 - _t1387 := &pb.Value{} - _t1387.Value = &pb.Value_DatetimeValue{DatetimeValue: raw_datetime686} - _t1385 = _t1387 + var _t1401 *pb.Value + if prediction692 == 1 { + _t1402 := p.parse_raw_datetime() + raw_datetime694 := _t1402 + _t1403 := &pb.Value{} + _t1403.Value = &pb.Value_DatetimeValue{DatetimeValue: raw_datetime694} + _t1401 = _t1403 } else { - var _t1388 *pb.Value - if prediction684 == 0 { - _t1389 := p.parse_raw_date() - raw_date685 := _t1389 - _t1390 := &pb.Value{} - _t1390.Value = &pb.Value_DateValue{DateValue: raw_date685} - _t1388 = _t1390 + var _t1404 *pb.Value + if prediction692 == 0 { + _t1405 := p.parse_raw_date() + raw_date693 := _t1405 + _t1406 := &pb.Value{} + _t1406.Value = &pb.Value_DateValue{DateValue: raw_date693} + _t1404 = _t1406 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in raw_value", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1385 = _t1388 + _t1401 = _t1404 } - _t1383 = _t1385 + _t1399 = _t1401 } - _t1381 = _t1383 + _t1397 = _t1399 } - _t1379 = _t1381 + _t1395 = _t1397 } - _t1377 = _t1379 + _t1393 = _t1395 } - _t1375 = _t1377 + _t1391 = _t1393 } - _t1373 = _t1375 + _t1389 = _t1391 } - _t1371 = _t1373 + _t1387 = _t1389 } - _t1369 = _t1371 + _t1385 = _t1387 } - _t1367 = _t1369 + _t1383 = _t1385 } - _t1364 = _t1367 + _t1380 = _t1383 } - _t1361 = _t1364 + _t1377 = _t1380 } - result698 := _t1361 - p.recordSpan(int(span_start697), "Value") - return result698 + result706 := _t1377 + p.recordSpan(int(span_start705), "Value") + return result706 } func (p *Parser) parse_raw_date() *pb.DateValue { - span_start702 := int64(p.spanStart()) + span_start710 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("date") - int699 := p.consumeTerminal("INT").Value.i64 - int_3700 := p.consumeTerminal("INT").Value.i64 - int_4701 := p.consumeTerminal("INT").Value.i64 + int707 := p.consumeTerminal("INT").Value.i64 + int_3708 := p.consumeTerminal("INT").Value.i64 + int_4709 := p.consumeTerminal("INT").Value.i64 p.consumeLiteral(")") - _t1391 := &pb.DateValue{Year: int32(int699), Month: int32(int_3700), Day: int32(int_4701)} - result703 := _t1391 - p.recordSpan(int(span_start702), "DateValue") - return result703 + _t1407 := &pb.DateValue{Year: int32(int707), Month: int32(int_3708), Day: int32(int_4709)} + result711 := _t1407 + p.recordSpan(int(span_start710), "DateValue") + return result711 } func (p *Parser) parse_raw_datetime() *pb.DateTimeValue { - span_start711 := int64(p.spanStart()) + span_start719 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("datetime") - int704 := p.consumeTerminal("INT").Value.i64 - int_3705 := p.consumeTerminal("INT").Value.i64 - int_4706 := p.consumeTerminal("INT").Value.i64 - int_5707 := p.consumeTerminal("INT").Value.i64 - int_6708 := p.consumeTerminal("INT").Value.i64 - int_7709 := p.consumeTerminal("INT").Value.i64 - var _t1392 *int64 + int712 := p.consumeTerminal("INT").Value.i64 + int_3713 := p.consumeTerminal("INT").Value.i64 + int_4714 := p.consumeTerminal("INT").Value.i64 + int_5715 := p.consumeTerminal("INT").Value.i64 + int_6716 := p.consumeTerminal("INT").Value.i64 + int_7717 := p.consumeTerminal("INT").Value.i64 + var _t1408 *int64 if p.matchLookaheadTerminal("INT", 0) { - _t1392 = ptr(p.consumeTerminal("INT").Value.i64) + _t1408 = ptr(p.consumeTerminal("INT").Value.i64) } - int_8710 := _t1392 + int_8718 := _t1408 p.consumeLiteral(")") - _t1393 := &pb.DateTimeValue{Year: int32(int704), Month: int32(int_3705), Day: int32(int_4706), Hour: int32(int_5707), Minute: int32(int_6708), Second: int32(int_7709), Microsecond: int32(deref(int_8710, 0))} - result712 := _t1393 - p.recordSpan(int(span_start711), "DateTimeValue") - return result712 + _t1409 := &pb.DateTimeValue{Year: int32(int712), Month: int32(int_3713), Day: int32(int_4714), Hour: int32(int_5715), Minute: int32(int_6716), Second: int32(int_7717), Microsecond: int32(deref(int_8718, 0))} + result720 := _t1409 + p.recordSpan(int(span_start719), "DateTimeValue") + return result720 } func (p *Parser) parse_boolean_value() bool { - var _t1394 int64 + var _t1410 int64 if p.matchLookaheadLiteral("true", 0) { - _t1394 = 0 + _t1410 = 0 } else { - var _t1395 int64 + var _t1411 int64 if p.matchLookaheadLiteral("false", 0) { - _t1395 = 1 + _t1411 = 1 } else { - _t1395 = -1 + _t1411 = -1 } - _t1394 = _t1395 + _t1410 = _t1411 } - prediction713 := _t1394 - var _t1396 bool - if prediction713 == 1 { + prediction721 := _t1410 + var _t1412 bool + if prediction721 == 1 { p.consumeLiteral("false") - _t1396 = false + _t1412 = false } else { - var _t1397 bool - if prediction713 == 0 { + var _t1413 bool + if prediction721 == 0 { p.consumeLiteral("true") - _t1397 = true + _t1413 = true } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in boolean_value", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1396 = _t1397 + _t1412 = _t1413 } - return _t1396 + return _t1412 } func (p *Parser) parse_sync() *pb.Sync { - span_start718 := int64(p.spanStart()) + span_start726 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("sync") - xs714 := []*pb.FragmentId{} - cond715 := p.matchLookaheadLiteral(":", 0) - for cond715 { - _t1398 := p.parse_fragment_id() - item716 := _t1398 - xs714 = append(xs714, item716) - cond715 = p.matchLookaheadLiteral(":", 0) - } - fragment_ids717 := xs714 + xs722 := []*pb.FragmentId{} + cond723 := p.matchLookaheadLiteral(":", 0) + for cond723 { + _t1414 := p.parse_fragment_id() + item724 := _t1414 + xs722 = append(xs722, item724) + cond723 = p.matchLookaheadLiteral(":", 0) + } + fragment_ids725 := xs722 p.consumeLiteral(")") - _t1399 := &pb.Sync{Fragments: fragment_ids717} - result719 := _t1399 - p.recordSpan(int(span_start718), "Sync") - return result719 + _t1415 := &pb.Sync{Fragments: fragment_ids725} + result727 := _t1415 + p.recordSpan(int(span_start726), "Sync") + return result727 } func (p *Parser) parse_fragment_id() *pb.FragmentId { - span_start721 := int64(p.spanStart()) + span_start729 := int64(p.spanStart()) p.consumeLiteral(":") - symbol720 := p.consumeTerminal("SYMBOL").Value.str - result722 := &pb.FragmentId{Id: []byte(symbol720)} - p.recordSpan(int(span_start721), "FragmentId") - return result722 + symbol728 := p.consumeTerminal("SYMBOL").Value.str + result730 := &pb.FragmentId{Id: []byte(symbol728)} + p.recordSpan(int(span_start729), "FragmentId") + return result730 } func (p *Parser) parse_epoch() *pb.Epoch { - span_start725 := int64(p.spanStart()) + span_start733 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("epoch") - var _t1400 []*pb.Write + var _t1416 []*pb.Write if (p.matchLookaheadLiteral("(", 0) && p.matchLookaheadLiteral("writes", 1)) { - _t1401 := p.parse_epoch_writes() - _t1400 = _t1401 + _t1417 := p.parse_epoch_writes() + _t1416 = _t1417 } - epoch_writes723 := _t1400 - var _t1402 []*pb.Read + epoch_writes731 := _t1416 + var _t1418 []*pb.Read if p.matchLookaheadLiteral("(", 0) { - _t1403 := p.parse_epoch_reads() - _t1402 = _t1403 + _t1419 := p.parse_epoch_reads() + _t1418 = _t1419 } - epoch_reads724 := _t1402 + epoch_reads732 := _t1418 p.consumeLiteral(")") - _t1404 := epoch_writes723 - if epoch_writes723 == nil { - _t1404 = []*pb.Write{} + _t1420 := epoch_writes731 + if epoch_writes731 == nil { + _t1420 = []*pb.Write{} } - _t1405 := epoch_reads724 - if epoch_reads724 == nil { - _t1405 = []*pb.Read{} + _t1421 := epoch_reads732 + if epoch_reads732 == nil { + _t1421 = []*pb.Read{} } - _t1406 := &pb.Epoch{Writes: _t1404, Reads: _t1405} - result726 := _t1406 - p.recordSpan(int(span_start725), "Epoch") - return result726 + _t1422 := &pb.Epoch{Writes: _t1420, Reads: _t1421} + result734 := _t1422 + p.recordSpan(int(span_start733), "Epoch") + return result734 } func (p *Parser) parse_epoch_writes() []*pb.Write { p.consumeLiteral("(") p.consumeLiteral("writes") - xs727 := []*pb.Write{} - cond728 := p.matchLookaheadLiteral("(", 0) - for cond728 { - _t1407 := p.parse_write() - item729 := _t1407 - xs727 = append(xs727, item729) - cond728 = p.matchLookaheadLiteral("(", 0) - } - writes730 := xs727 + xs735 := []*pb.Write{} + cond736 := p.matchLookaheadLiteral("(", 0) + for cond736 { + _t1423 := p.parse_write() + item737 := _t1423 + xs735 = append(xs735, item737) + cond736 = p.matchLookaheadLiteral("(", 0) + } + writes738 := xs735 p.consumeLiteral(")") - return writes730 + return writes738 } func (p *Parser) parse_write() *pb.Write { - span_start736 := int64(p.spanStart()) - var _t1408 int64 + span_start744 := int64(p.spanStart()) + var _t1424 int64 if p.matchLookaheadLiteral("(", 0) { - var _t1409 int64 + var _t1425 int64 if p.matchLookaheadLiteral("undefine", 1) { - _t1409 = 1 + _t1425 = 1 } else { - var _t1410 int64 + var _t1426 int64 if p.matchLookaheadLiteral("snapshot", 1) { - _t1410 = 3 + _t1426 = 3 } else { - var _t1411 int64 + var _t1427 int64 if p.matchLookaheadLiteral("define", 1) { - _t1411 = 0 + _t1427 = 0 } else { - var _t1412 int64 + var _t1428 int64 if p.matchLookaheadLiteral("context", 1) { - _t1412 = 2 + _t1428 = 2 } else { - _t1412 = -1 + _t1428 = -1 } - _t1411 = _t1412 + _t1427 = _t1428 } - _t1410 = _t1411 + _t1426 = _t1427 } - _t1409 = _t1410 + _t1425 = _t1426 } - _t1408 = _t1409 + _t1424 = _t1425 } else { - _t1408 = -1 - } - prediction731 := _t1408 - var _t1413 *pb.Write - if prediction731 == 3 { - _t1414 := p.parse_snapshot() - snapshot735 := _t1414 - _t1415 := &pb.Write{} - _t1415.WriteType = &pb.Write_Snapshot{Snapshot: snapshot735} - _t1413 = _t1415 + _t1424 = -1 + } + prediction739 := _t1424 + var _t1429 *pb.Write + if prediction739 == 3 { + _t1430 := p.parse_snapshot() + snapshot743 := _t1430 + _t1431 := &pb.Write{} + _t1431.WriteType = &pb.Write_Snapshot{Snapshot: snapshot743} + _t1429 = _t1431 } else { - var _t1416 *pb.Write - if prediction731 == 2 { - _t1417 := p.parse_context() - context734 := _t1417 - _t1418 := &pb.Write{} - _t1418.WriteType = &pb.Write_Context{Context: context734} - _t1416 = _t1418 + var _t1432 *pb.Write + if prediction739 == 2 { + _t1433 := p.parse_context() + context742 := _t1433 + _t1434 := &pb.Write{} + _t1434.WriteType = &pb.Write_Context{Context: context742} + _t1432 = _t1434 } else { - var _t1419 *pb.Write - if prediction731 == 1 { - _t1420 := p.parse_undefine() - undefine733 := _t1420 - _t1421 := &pb.Write{} - _t1421.WriteType = &pb.Write_Undefine{Undefine: undefine733} - _t1419 = _t1421 + var _t1435 *pb.Write + if prediction739 == 1 { + _t1436 := p.parse_undefine() + undefine741 := _t1436 + _t1437 := &pb.Write{} + _t1437.WriteType = &pb.Write_Undefine{Undefine: undefine741} + _t1435 = _t1437 } else { - var _t1422 *pb.Write - if prediction731 == 0 { - _t1423 := p.parse_define() - define732 := _t1423 - _t1424 := &pb.Write{} - _t1424.WriteType = &pb.Write_Define{Define: define732} - _t1422 = _t1424 + var _t1438 *pb.Write + if prediction739 == 0 { + _t1439 := p.parse_define() + define740 := _t1439 + _t1440 := &pb.Write{} + _t1440.WriteType = &pb.Write_Define{Define: define740} + _t1438 = _t1440 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in write", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1419 = _t1422 + _t1435 = _t1438 } - _t1416 = _t1419 + _t1432 = _t1435 } - _t1413 = _t1416 + _t1429 = _t1432 } - result737 := _t1413 - p.recordSpan(int(span_start736), "Write") - return result737 + result745 := _t1429 + p.recordSpan(int(span_start744), "Write") + return result745 } func (p *Parser) parse_define() *pb.Define { - span_start739 := int64(p.spanStart()) + span_start747 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("define") - _t1425 := p.parse_fragment() - fragment738 := _t1425 + _t1441 := p.parse_fragment() + fragment746 := _t1441 p.consumeLiteral(")") - _t1426 := &pb.Define{Fragment: fragment738} - result740 := _t1426 - p.recordSpan(int(span_start739), "Define") - return result740 + _t1442 := &pb.Define{Fragment: fragment746} + result748 := _t1442 + p.recordSpan(int(span_start747), "Define") + return result748 } func (p *Parser) parse_fragment() *pb.Fragment { - span_start746 := int64(p.spanStart()) + span_start754 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("fragment") - _t1427 := p.parse_new_fragment_id() - new_fragment_id741 := _t1427 - xs742 := []*pb.Declaration{} - cond743 := p.matchLookaheadLiteral("(", 0) - for cond743 { - _t1428 := p.parse_declaration() - item744 := _t1428 - xs742 = append(xs742, item744) - cond743 = p.matchLookaheadLiteral("(", 0) - } - declarations745 := xs742 + _t1443 := p.parse_new_fragment_id() + new_fragment_id749 := _t1443 + xs750 := []*pb.Declaration{} + cond751 := p.matchLookaheadLiteral("(", 0) + for cond751 { + _t1444 := p.parse_declaration() + item752 := _t1444 + xs750 = append(xs750, item752) + cond751 = p.matchLookaheadLiteral("(", 0) + } + declarations753 := xs750 p.consumeLiteral(")") - result747 := p.constructFragment(new_fragment_id741, declarations745) - p.recordSpan(int(span_start746), "Fragment") - return result747 + result755 := p.constructFragment(new_fragment_id749, declarations753) + p.recordSpan(int(span_start754), "Fragment") + return result755 } func (p *Parser) parse_new_fragment_id() *pb.FragmentId { - span_start749 := int64(p.spanStart()) - _t1429 := p.parse_fragment_id() - fragment_id748 := _t1429 - p.startFragment(fragment_id748) - result750 := fragment_id748 - p.recordSpan(int(span_start749), "FragmentId") - return result750 + span_start757 := int64(p.spanStart()) + _t1445 := p.parse_fragment_id() + fragment_id756 := _t1445 + p.startFragment(fragment_id756) + result758 := fragment_id756 + p.recordSpan(int(span_start757), "FragmentId") + return result758 } func (p *Parser) parse_declaration() *pb.Declaration { - span_start756 := int64(p.spanStart()) - var _t1430 int64 + span_start764 := int64(p.spanStart()) + var _t1446 int64 if p.matchLookaheadLiteral("(", 0) { - var _t1431 int64 + var _t1447 int64 if p.matchLookaheadLiteral("iceberg_data", 1) { - _t1431 = 3 + _t1447 = 3 } else { - var _t1432 int64 + var _t1448 int64 if p.matchLookaheadLiteral("functional_dependency", 1) { - _t1432 = 2 + _t1448 = 2 } else { - var _t1433 int64 + var _t1449 int64 if p.matchLookaheadLiteral("edb", 1) { - _t1433 = 3 + _t1449 = 3 } else { - var _t1434 int64 + var _t1450 int64 if p.matchLookaheadLiteral("def", 1) { - _t1434 = 0 + _t1450 = 0 } else { - var _t1435 int64 + var _t1451 int64 if p.matchLookaheadLiteral("csv_data", 1) { - _t1435 = 3 + _t1451 = 3 } else { - var _t1436 int64 + var _t1452 int64 if p.matchLookaheadLiteral("betree_relation", 1) { - _t1436 = 3 + _t1452 = 3 } else { - var _t1437 int64 + var _t1453 int64 if p.matchLookaheadLiteral("algorithm", 1) { - _t1437 = 1 + _t1453 = 1 } else { - _t1437 = -1 + _t1453 = -1 } - _t1436 = _t1437 + _t1452 = _t1453 } - _t1435 = _t1436 + _t1451 = _t1452 } - _t1434 = _t1435 + _t1450 = _t1451 } - _t1433 = _t1434 + _t1449 = _t1450 } - _t1432 = _t1433 + _t1448 = _t1449 } - _t1431 = _t1432 + _t1447 = _t1448 } - _t1430 = _t1431 + _t1446 = _t1447 } else { - _t1430 = -1 - } - prediction751 := _t1430 - var _t1438 *pb.Declaration - if prediction751 == 3 { - _t1439 := p.parse_data() - data755 := _t1439 - _t1440 := &pb.Declaration{} - _t1440.DeclarationType = &pb.Declaration_Data{Data: data755} - _t1438 = _t1440 + _t1446 = -1 + } + prediction759 := _t1446 + var _t1454 *pb.Declaration + if prediction759 == 3 { + _t1455 := p.parse_data() + data763 := _t1455 + _t1456 := &pb.Declaration{} + _t1456.DeclarationType = &pb.Declaration_Data{Data: data763} + _t1454 = _t1456 } else { - var _t1441 *pb.Declaration - if prediction751 == 2 { - _t1442 := p.parse_constraint() - constraint754 := _t1442 - _t1443 := &pb.Declaration{} - _t1443.DeclarationType = &pb.Declaration_Constraint{Constraint: constraint754} - _t1441 = _t1443 + var _t1457 *pb.Declaration + if prediction759 == 2 { + _t1458 := p.parse_constraint() + constraint762 := _t1458 + _t1459 := &pb.Declaration{} + _t1459.DeclarationType = &pb.Declaration_Constraint{Constraint: constraint762} + _t1457 = _t1459 } else { - var _t1444 *pb.Declaration - if prediction751 == 1 { - _t1445 := p.parse_algorithm() - algorithm753 := _t1445 - _t1446 := &pb.Declaration{} - _t1446.DeclarationType = &pb.Declaration_Algorithm{Algorithm: algorithm753} - _t1444 = _t1446 + var _t1460 *pb.Declaration + if prediction759 == 1 { + _t1461 := p.parse_algorithm() + algorithm761 := _t1461 + _t1462 := &pb.Declaration{} + _t1462.DeclarationType = &pb.Declaration_Algorithm{Algorithm: algorithm761} + _t1460 = _t1462 } else { - var _t1447 *pb.Declaration - if prediction751 == 0 { - _t1448 := p.parse_def() - def752 := _t1448 - _t1449 := &pb.Declaration{} - _t1449.DeclarationType = &pb.Declaration_Def{Def: def752} - _t1447 = _t1449 + var _t1463 *pb.Declaration + if prediction759 == 0 { + _t1464 := p.parse_def() + def760 := _t1464 + _t1465 := &pb.Declaration{} + _t1465.DeclarationType = &pb.Declaration_Def{Def: def760} + _t1463 = _t1465 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in declaration", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1444 = _t1447 + _t1460 = _t1463 } - _t1441 = _t1444 + _t1457 = _t1460 } - _t1438 = _t1441 + _t1454 = _t1457 } - result757 := _t1438 - p.recordSpan(int(span_start756), "Declaration") - return result757 + result765 := _t1454 + p.recordSpan(int(span_start764), "Declaration") + return result765 } func (p *Parser) parse_def() *pb.Def { - span_start761 := int64(p.spanStart()) + span_start769 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("def") - _t1450 := p.parse_relation_id() - relation_id758 := _t1450 - _t1451 := p.parse_abstraction() - abstraction759 := _t1451 - var _t1452 []*pb.Attribute + _t1466 := p.parse_relation_id() + relation_id766 := _t1466 + _t1467 := p.parse_abstraction() + abstraction767 := _t1467 + var _t1468 []*pb.Attribute if p.matchLookaheadLiteral("(", 0) { - _t1453 := p.parse_attrs() - _t1452 = _t1453 + _t1469 := p.parse_attrs() + _t1468 = _t1469 } - attrs760 := _t1452 + attrs768 := _t1468 p.consumeLiteral(")") - _t1454 := attrs760 - if attrs760 == nil { - _t1454 = []*pb.Attribute{} + _t1470 := attrs768 + if attrs768 == nil { + _t1470 = []*pb.Attribute{} } - _t1455 := &pb.Def{Name: relation_id758, Body: abstraction759, Attrs: _t1454} - result762 := _t1455 - p.recordSpan(int(span_start761), "Def") - return result762 + _t1471 := &pb.Def{Name: relation_id766, Body: abstraction767, Attrs: _t1470} + result770 := _t1471 + p.recordSpan(int(span_start769), "Def") + return result770 } func (p *Parser) parse_relation_id() *pb.RelationId { - span_start766 := int64(p.spanStart()) - var _t1456 int64 + span_start774 := int64(p.spanStart()) + var _t1472 int64 if p.matchLookaheadLiteral(":", 0) { - _t1456 = 0 + _t1472 = 0 } else { - var _t1457 int64 + var _t1473 int64 if p.matchLookaheadTerminal("UINT128", 0) { - _t1457 = 1 + _t1473 = 1 } else { - _t1457 = -1 + _t1473 = -1 } - _t1456 = _t1457 - } - prediction763 := _t1456 - var _t1458 *pb.RelationId - if prediction763 == 1 { - uint128765 := p.consumeTerminal("UINT128").Value.uint128 - _ = uint128765 - _t1458 = &pb.RelationId{IdLow: uint128765.Low, IdHigh: uint128765.High} + _t1472 = _t1473 + } + prediction771 := _t1472 + var _t1474 *pb.RelationId + if prediction771 == 1 { + uint128773 := p.consumeTerminal("UINT128").Value.uint128 + _ = uint128773 + _t1474 = &pb.RelationId{IdLow: uint128773.Low, IdHigh: uint128773.High} } else { - var _t1459 *pb.RelationId - if prediction763 == 0 { + var _t1475 *pb.RelationId + if prediction771 == 0 { p.consumeLiteral(":") - symbol764 := p.consumeTerminal("SYMBOL").Value.str - _t1459 = p.relationIdFromString(symbol764) + symbol772 := p.consumeTerminal("SYMBOL").Value.str + _t1475 = p.relationIdFromString(symbol772) } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in relation_id", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1458 = _t1459 + _t1474 = _t1475 } - result767 := _t1458 - p.recordSpan(int(span_start766), "RelationId") - return result767 + result775 := _t1474 + p.recordSpan(int(span_start774), "RelationId") + return result775 } func (p *Parser) parse_abstraction() *pb.Abstraction { - span_start770 := int64(p.spanStart()) + span_start778 := int64(p.spanStart()) p.consumeLiteral("(") - _t1460 := p.parse_bindings() - bindings768 := _t1460 - _t1461 := p.parse_formula() - formula769 := _t1461 + _t1476 := p.parse_bindings() + bindings776 := _t1476 + _t1477 := p.parse_formula() + formula777 := _t1477 p.consumeLiteral(")") - _t1462 := &pb.Abstraction{Vars: listConcat(bindings768[0].([]*pb.Binding), bindings768[1].([]*pb.Binding)), Value: formula769} - result771 := _t1462 - p.recordSpan(int(span_start770), "Abstraction") - return result771 + _t1478 := &pb.Abstraction{Vars: listConcat(bindings776[0].([]*pb.Binding), bindings776[1].([]*pb.Binding)), Value: formula777} + result779 := _t1478 + p.recordSpan(int(span_start778), "Abstraction") + return result779 } func (p *Parser) parse_bindings() []interface{} { p.consumeLiteral("[") - xs772 := []*pb.Binding{} - cond773 := p.matchLookaheadTerminal("SYMBOL", 0) - for cond773 { - _t1463 := p.parse_binding() - item774 := _t1463 - xs772 = append(xs772, item774) - cond773 = p.matchLookaheadTerminal("SYMBOL", 0) - } - bindings775 := xs772 - var _t1464 []*pb.Binding + xs780 := []*pb.Binding{} + cond781 := p.matchLookaheadTerminal("SYMBOL", 0) + for cond781 { + _t1479 := p.parse_binding() + item782 := _t1479 + xs780 = append(xs780, item782) + cond781 = p.matchLookaheadTerminal("SYMBOL", 0) + } + bindings783 := xs780 + var _t1480 []*pb.Binding if p.matchLookaheadLiteral("|", 0) { - _t1465 := p.parse_value_bindings() - _t1464 = _t1465 + _t1481 := p.parse_value_bindings() + _t1480 = _t1481 } - value_bindings776 := _t1464 + value_bindings784 := _t1480 p.consumeLiteral("]") - _t1466 := value_bindings776 - if value_bindings776 == nil { - _t1466 = []*pb.Binding{} + _t1482 := value_bindings784 + if value_bindings784 == nil { + _t1482 = []*pb.Binding{} } - return []interface{}{bindings775, _t1466} + return []interface{}{bindings783, _t1482} } func (p *Parser) parse_binding() *pb.Binding { - span_start779 := int64(p.spanStart()) - symbol777 := p.consumeTerminal("SYMBOL").Value.str + span_start787 := int64(p.spanStart()) + symbol785 := p.consumeTerminal("SYMBOL").Value.str p.consumeLiteral("::") - _t1467 := p.parse_type() - type778 := _t1467 - _t1468 := &pb.Var{Name: symbol777} - _t1469 := &pb.Binding{Var: _t1468, Type: type778} - result780 := _t1469 - p.recordSpan(int(span_start779), "Binding") - return result780 + _t1483 := p.parse_type() + type786 := _t1483 + _t1484 := &pb.Var{Name: symbol785} + _t1485 := &pb.Binding{Var: _t1484, Type: type786} + result788 := _t1485 + p.recordSpan(int(span_start787), "Binding") + return result788 } func (p *Parser) parse_type() *pb.Type { - span_start796 := int64(p.spanStart()) - var _t1470 int64 + span_start804 := int64(p.spanStart()) + var _t1486 int64 if p.matchLookaheadLiteral("UNKNOWN", 0) { - _t1470 = 0 + _t1486 = 0 } else { - var _t1471 int64 + var _t1487 int64 if p.matchLookaheadLiteral("UINT32", 0) { - _t1471 = 13 + _t1487 = 13 } else { - var _t1472 int64 + var _t1488 int64 if p.matchLookaheadLiteral("UINT128", 0) { - _t1472 = 4 + _t1488 = 4 } else { - var _t1473 int64 + var _t1489 int64 if p.matchLookaheadLiteral("STRING", 0) { - _t1473 = 1 + _t1489 = 1 } else { - var _t1474 int64 + var _t1490 int64 if p.matchLookaheadLiteral("MISSING", 0) { - _t1474 = 8 + _t1490 = 8 } else { - var _t1475 int64 + var _t1491 int64 if p.matchLookaheadLiteral("INT32", 0) { - _t1475 = 11 + _t1491 = 11 } else { - var _t1476 int64 + var _t1492 int64 if p.matchLookaheadLiteral("INT128", 0) { - _t1476 = 5 + _t1492 = 5 } else { - var _t1477 int64 + var _t1493 int64 if p.matchLookaheadLiteral("INT", 0) { - _t1477 = 2 + _t1493 = 2 } else { - var _t1478 int64 + var _t1494 int64 if p.matchLookaheadLiteral("FLOAT32", 0) { - _t1478 = 12 + _t1494 = 12 } else { - var _t1479 int64 + var _t1495 int64 if p.matchLookaheadLiteral("FLOAT", 0) { - _t1479 = 3 + _t1495 = 3 } else { - var _t1480 int64 + var _t1496 int64 if p.matchLookaheadLiteral("DATETIME", 0) { - _t1480 = 7 + _t1496 = 7 } else { - var _t1481 int64 + var _t1497 int64 if p.matchLookaheadLiteral("DATE", 0) { - _t1481 = 6 + _t1497 = 6 } else { - var _t1482 int64 + var _t1498 int64 if p.matchLookaheadLiteral("BOOLEAN", 0) { - _t1482 = 10 + _t1498 = 10 } else { - var _t1483 int64 + var _t1499 int64 if p.matchLookaheadLiteral("(", 0) { - _t1483 = 9 + _t1499 = 9 } else { - _t1483 = -1 + _t1499 = -1 } - _t1482 = _t1483 + _t1498 = _t1499 } - _t1481 = _t1482 + _t1497 = _t1498 } - _t1480 = _t1481 + _t1496 = _t1497 } - _t1479 = _t1480 + _t1495 = _t1496 } - _t1478 = _t1479 + _t1494 = _t1495 } - _t1477 = _t1478 + _t1493 = _t1494 } - _t1476 = _t1477 + _t1492 = _t1493 } - _t1475 = _t1476 + _t1491 = _t1492 } - _t1474 = _t1475 + _t1490 = _t1491 } - _t1473 = _t1474 + _t1489 = _t1490 } - _t1472 = _t1473 + _t1488 = _t1489 } - _t1471 = _t1472 + _t1487 = _t1488 } - _t1470 = _t1471 - } - prediction781 := _t1470 - var _t1484 *pb.Type - if prediction781 == 13 { - _t1485 := p.parse_uint32_type() - uint32_type795 := _t1485 - _t1486 := &pb.Type{} - _t1486.Type = &pb.Type_Uint32Type{Uint32Type: uint32_type795} - _t1484 = _t1486 + _t1486 = _t1487 + } + prediction789 := _t1486 + var _t1500 *pb.Type + if prediction789 == 13 { + _t1501 := p.parse_uint32_type() + uint32_type803 := _t1501 + _t1502 := &pb.Type{} + _t1502.Type = &pb.Type_Uint32Type{Uint32Type: uint32_type803} + _t1500 = _t1502 } else { - var _t1487 *pb.Type - if prediction781 == 12 { - _t1488 := p.parse_float32_type() - float32_type794 := _t1488 - _t1489 := &pb.Type{} - _t1489.Type = &pb.Type_Float32Type{Float32Type: float32_type794} - _t1487 = _t1489 + var _t1503 *pb.Type + if prediction789 == 12 { + _t1504 := p.parse_float32_type() + float32_type802 := _t1504 + _t1505 := &pb.Type{} + _t1505.Type = &pb.Type_Float32Type{Float32Type: float32_type802} + _t1503 = _t1505 } else { - var _t1490 *pb.Type - if prediction781 == 11 { - _t1491 := p.parse_int32_type() - int32_type793 := _t1491 - _t1492 := &pb.Type{} - _t1492.Type = &pb.Type_Int32Type{Int32Type: int32_type793} - _t1490 = _t1492 + var _t1506 *pb.Type + if prediction789 == 11 { + _t1507 := p.parse_int32_type() + int32_type801 := _t1507 + _t1508 := &pb.Type{} + _t1508.Type = &pb.Type_Int32Type{Int32Type: int32_type801} + _t1506 = _t1508 } else { - var _t1493 *pb.Type - if prediction781 == 10 { - _t1494 := p.parse_boolean_type() - boolean_type792 := _t1494 - _t1495 := &pb.Type{} - _t1495.Type = &pb.Type_BooleanType{BooleanType: boolean_type792} - _t1493 = _t1495 + var _t1509 *pb.Type + if prediction789 == 10 { + _t1510 := p.parse_boolean_type() + boolean_type800 := _t1510 + _t1511 := &pb.Type{} + _t1511.Type = &pb.Type_BooleanType{BooleanType: boolean_type800} + _t1509 = _t1511 } else { - var _t1496 *pb.Type - if prediction781 == 9 { - _t1497 := p.parse_decimal_type() - decimal_type791 := _t1497 - _t1498 := &pb.Type{} - _t1498.Type = &pb.Type_DecimalType{DecimalType: decimal_type791} - _t1496 = _t1498 + var _t1512 *pb.Type + if prediction789 == 9 { + _t1513 := p.parse_decimal_type() + decimal_type799 := _t1513 + _t1514 := &pb.Type{} + _t1514.Type = &pb.Type_DecimalType{DecimalType: decimal_type799} + _t1512 = _t1514 } else { - var _t1499 *pb.Type - if prediction781 == 8 { - _t1500 := p.parse_missing_type() - missing_type790 := _t1500 - _t1501 := &pb.Type{} - _t1501.Type = &pb.Type_MissingType{MissingType: missing_type790} - _t1499 = _t1501 + var _t1515 *pb.Type + if prediction789 == 8 { + _t1516 := p.parse_missing_type() + missing_type798 := _t1516 + _t1517 := &pb.Type{} + _t1517.Type = &pb.Type_MissingType{MissingType: missing_type798} + _t1515 = _t1517 } else { - var _t1502 *pb.Type - if prediction781 == 7 { - _t1503 := p.parse_datetime_type() - datetime_type789 := _t1503 - _t1504 := &pb.Type{} - _t1504.Type = &pb.Type_DatetimeType{DatetimeType: datetime_type789} - _t1502 = _t1504 + var _t1518 *pb.Type + if prediction789 == 7 { + _t1519 := p.parse_datetime_type() + datetime_type797 := _t1519 + _t1520 := &pb.Type{} + _t1520.Type = &pb.Type_DatetimeType{DatetimeType: datetime_type797} + _t1518 = _t1520 } else { - var _t1505 *pb.Type - if prediction781 == 6 { - _t1506 := p.parse_date_type() - date_type788 := _t1506 - _t1507 := &pb.Type{} - _t1507.Type = &pb.Type_DateType{DateType: date_type788} - _t1505 = _t1507 + var _t1521 *pb.Type + if prediction789 == 6 { + _t1522 := p.parse_date_type() + date_type796 := _t1522 + _t1523 := &pb.Type{} + _t1523.Type = &pb.Type_DateType{DateType: date_type796} + _t1521 = _t1523 } else { - var _t1508 *pb.Type - if prediction781 == 5 { - _t1509 := p.parse_int128_type() - int128_type787 := _t1509 - _t1510 := &pb.Type{} - _t1510.Type = &pb.Type_Int128Type{Int128Type: int128_type787} - _t1508 = _t1510 + var _t1524 *pb.Type + if prediction789 == 5 { + _t1525 := p.parse_int128_type() + int128_type795 := _t1525 + _t1526 := &pb.Type{} + _t1526.Type = &pb.Type_Int128Type{Int128Type: int128_type795} + _t1524 = _t1526 } else { - var _t1511 *pb.Type - if prediction781 == 4 { - _t1512 := p.parse_uint128_type() - uint128_type786 := _t1512 - _t1513 := &pb.Type{} - _t1513.Type = &pb.Type_Uint128Type{Uint128Type: uint128_type786} - _t1511 = _t1513 + var _t1527 *pb.Type + if prediction789 == 4 { + _t1528 := p.parse_uint128_type() + uint128_type794 := _t1528 + _t1529 := &pb.Type{} + _t1529.Type = &pb.Type_Uint128Type{Uint128Type: uint128_type794} + _t1527 = _t1529 } else { - var _t1514 *pb.Type - if prediction781 == 3 { - _t1515 := p.parse_float_type() - float_type785 := _t1515 - _t1516 := &pb.Type{} - _t1516.Type = &pb.Type_FloatType{FloatType: float_type785} - _t1514 = _t1516 + var _t1530 *pb.Type + if prediction789 == 3 { + _t1531 := p.parse_float_type() + float_type793 := _t1531 + _t1532 := &pb.Type{} + _t1532.Type = &pb.Type_FloatType{FloatType: float_type793} + _t1530 = _t1532 } else { - var _t1517 *pb.Type - if prediction781 == 2 { - _t1518 := p.parse_int_type() - int_type784 := _t1518 - _t1519 := &pb.Type{} - _t1519.Type = &pb.Type_IntType{IntType: int_type784} - _t1517 = _t1519 + var _t1533 *pb.Type + if prediction789 == 2 { + _t1534 := p.parse_int_type() + int_type792 := _t1534 + _t1535 := &pb.Type{} + _t1535.Type = &pb.Type_IntType{IntType: int_type792} + _t1533 = _t1535 } else { - var _t1520 *pb.Type - if prediction781 == 1 { - _t1521 := p.parse_string_type() - string_type783 := _t1521 - _t1522 := &pb.Type{} - _t1522.Type = &pb.Type_StringType{StringType: string_type783} - _t1520 = _t1522 + var _t1536 *pb.Type + if prediction789 == 1 { + _t1537 := p.parse_string_type() + string_type791 := _t1537 + _t1538 := &pb.Type{} + _t1538.Type = &pb.Type_StringType{StringType: string_type791} + _t1536 = _t1538 } else { - var _t1523 *pb.Type - if prediction781 == 0 { - _t1524 := p.parse_unspecified_type() - unspecified_type782 := _t1524 - _t1525 := &pb.Type{} - _t1525.Type = &pb.Type_UnspecifiedType{UnspecifiedType: unspecified_type782} - _t1523 = _t1525 + var _t1539 *pb.Type + if prediction789 == 0 { + _t1540 := p.parse_unspecified_type() + unspecified_type790 := _t1540 + _t1541 := &pb.Type{} + _t1541.Type = &pb.Type_UnspecifiedType{UnspecifiedType: unspecified_type790} + _t1539 = _t1541 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in type", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1520 = _t1523 + _t1536 = _t1539 } - _t1517 = _t1520 + _t1533 = _t1536 } - _t1514 = _t1517 + _t1530 = _t1533 } - _t1511 = _t1514 + _t1527 = _t1530 } - _t1508 = _t1511 + _t1524 = _t1527 } - _t1505 = _t1508 + _t1521 = _t1524 } - _t1502 = _t1505 + _t1518 = _t1521 } - _t1499 = _t1502 + _t1515 = _t1518 } - _t1496 = _t1499 + _t1512 = _t1515 } - _t1493 = _t1496 + _t1509 = _t1512 } - _t1490 = _t1493 + _t1506 = _t1509 } - _t1487 = _t1490 + _t1503 = _t1506 } - _t1484 = _t1487 + _t1500 = _t1503 } - result797 := _t1484 - p.recordSpan(int(span_start796), "Type") - return result797 + result805 := _t1500 + p.recordSpan(int(span_start804), "Type") + return result805 } func (p *Parser) parse_unspecified_type() *pb.UnspecifiedType { - span_start798 := int64(p.spanStart()) + span_start806 := int64(p.spanStart()) p.consumeLiteral("UNKNOWN") - _t1526 := &pb.UnspecifiedType{} - result799 := _t1526 - p.recordSpan(int(span_start798), "UnspecifiedType") - return result799 + _t1542 := &pb.UnspecifiedType{} + result807 := _t1542 + p.recordSpan(int(span_start806), "UnspecifiedType") + return result807 } func (p *Parser) parse_string_type() *pb.StringType { - span_start800 := int64(p.spanStart()) + span_start808 := int64(p.spanStart()) p.consumeLiteral("STRING") - _t1527 := &pb.StringType{} - result801 := _t1527 - p.recordSpan(int(span_start800), "StringType") - return result801 + _t1543 := &pb.StringType{} + result809 := _t1543 + p.recordSpan(int(span_start808), "StringType") + return result809 } func (p *Parser) parse_int_type() *pb.IntType { - span_start802 := int64(p.spanStart()) + span_start810 := int64(p.spanStart()) p.consumeLiteral("INT") - _t1528 := &pb.IntType{} - result803 := _t1528 - p.recordSpan(int(span_start802), "IntType") - return result803 + _t1544 := &pb.IntType{} + result811 := _t1544 + p.recordSpan(int(span_start810), "IntType") + return result811 } func (p *Parser) parse_float_type() *pb.FloatType { - span_start804 := int64(p.spanStart()) + span_start812 := int64(p.spanStart()) p.consumeLiteral("FLOAT") - _t1529 := &pb.FloatType{} - result805 := _t1529 - p.recordSpan(int(span_start804), "FloatType") - return result805 + _t1545 := &pb.FloatType{} + result813 := _t1545 + p.recordSpan(int(span_start812), "FloatType") + return result813 } func (p *Parser) parse_uint128_type() *pb.UInt128Type { - span_start806 := int64(p.spanStart()) + span_start814 := int64(p.spanStart()) p.consumeLiteral("UINT128") - _t1530 := &pb.UInt128Type{} - result807 := _t1530 - p.recordSpan(int(span_start806), "UInt128Type") - return result807 + _t1546 := &pb.UInt128Type{} + result815 := _t1546 + p.recordSpan(int(span_start814), "UInt128Type") + return result815 } func (p *Parser) parse_int128_type() *pb.Int128Type { - span_start808 := int64(p.spanStart()) + span_start816 := int64(p.spanStart()) p.consumeLiteral("INT128") - _t1531 := &pb.Int128Type{} - result809 := _t1531 - p.recordSpan(int(span_start808), "Int128Type") - return result809 + _t1547 := &pb.Int128Type{} + result817 := _t1547 + p.recordSpan(int(span_start816), "Int128Type") + return result817 } func (p *Parser) parse_date_type() *pb.DateType { - span_start810 := int64(p.spanStart()) + span_start818 := int64(p.spanStart()) p.consumeLiteral("DATE") - _t1532 := &pb.DateType{} - result811 := _t1532 - p.recordSpan(int(span_start810), "DateType") - return result811 + _t1548 := &pb.DateType{} + result819 := _t1548 + p.recordSpan(int(span_start818), "DateType") + return result819 } func (p *Parser) parse_datetime_type() *pb.DateTimeType { - span_start812 := int64(p.spanStart()) + span_start820 := int64(p.spanStart()) p.consumeLiteral("DATETIME") - _t1533 := &pb.DateTimeType{} - result813 := _t1533 - p.recordSpan(int(span_start812), "DateTimeType") - return result813 + _t1549 := &pb.DateTimeType{} + result821 := _t1549 + p.recordSpan(int(span_start820), "DateTimeType") + return result821 } func (p *Parser) parse_missing_type() *pb.MissingType { - span_start814 := int64(p.spanStart()) + span_start822 := int64(p.spanStart()) p.consumeLiteral("MISSING") - _t1534 := &pb.MissingType{} - result815 := _t1534 - p.recordSpan(int(span_start814), "MissingType") - return result815 + _t1550 := &pb.MissingType{} + result823 := _t1550 + p.recordSpan(int(span_start822), "MissingType") + return result823 } func (p *Parser) parse_decimal_type() *pb.DecimalType { - span_start818 := int64(p.spanStart()) + span_start826 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("DECIMAL") - int816 := p.consumeTerminal("INT").Value.i64 - int_3817 := p.consumeTerminal("INT").Value.i64 + int824 := p.consumeTerminal("INT").Value.i64 + int_3825 := p.consumeTerminal("INT").Value.i64 p.consumeLiteral(")") - _t1535 := &pb.DecimalType{Precision: int32(int816), Scale: int32(int_3817)} - result819 := _t1535 - p.recordSpan(int(span_start818), "DecimalType") - return result819 + _t1551 := &pb.DecimalType{Precision: int32(int824), Scale: int32(int_3825)} + result827 := _t1551 + p.recordSpan(int(span_start826), "DecimalType") + return result827 } func (p *Parser) parse_boolean_type() *pb.BooleanType { - span_start820 := int64(p.spanStart()) + span_start828 := int64(p.spanStart()) p.consumeLiteral("BOOLEAN") - _t1536 := &pb.BooleanType{} - result821 := _t1536 - p.recordSpan(int(span_start820), "BooleanType") - return result821 + _t1552 := &pb.BooleanType{} + result829 := _t1552 + p.recordSpan(int(span_start828), "BooleanType") + return result829 } func (p *Parser) parse_int32_type() *pb.Int32Type { - span_start822 := int64(p.spanStart()) + span_start830 := int64(p.spanStart()) p.consumeLiteral("INT32") - _t1537 := &pb.Int32Type{} - result823 := _t1537 - p.recordSpan(int(span_start822), "Int32Type") - return result823 + _t1553 := &pb.Int32Type{} + result831 := _t1553 + p.recordSpan(int(span_start830), "Int32Type") + return result831 } func (p *Parser) parse_float32_type() *pb.Float32Type { - span_start824 := int64(p.spanStart()) + span_start832 := int64(p.spanStart()) p.consumeLiteral("FLOAT32") - _t1538 := &pb.Float32Type{} - result825 := _t1538 - p.recordSpan(int(span_start824), "Float32Type") - return result825 + _t1554 := &pb.Float32Type{} + result833 := _t1554 + p.recordSpan(int(span_start832), "Float32Type") + return result833 } func (p *Parser) parse_uint32_type() *pb.UInt32Type { - span_start826 := int64(p.spanStart()) + span_start834 := int64(p.spanStart()) p.consumeLiteral("UINT32") - _t1539 := &pb.UInt32Type{} - result827 := _t1539 - p.recordSpan(int(span_start826), "UInt32Type") - return result827 + _t1555 := &pb.UInt32Type{} + result835 := _t1555 + p.recordSpan(int(span_start834), "UInt32Type") + return result835 } func (p *Parser) parse_value_bindings() []*pb.Binding { p.consumeLiteral("|") - xs828 := []*pb.Binding{} - cond829 := p.matchLookaheadTerminal("SYMBOL", 0) - for cond829 { - _t1540 := p.parse_binding() - item830 := _t1540 - xs828 = append(xs828, item830) - cond829 = p.matchLookaheadTerminal("SYMBOL", 0) + xs836 := []*pb.Binding{} + cond837 := p.matchLookaheadTerminal("SYMBOL", 0) + for cond837 { + _t1556 := p.parse_binding() + item838 := _t1556 + xs836 = append(xs836, item838) + cond837 = p.matchLookaheadTerminal("SYMBOL", 0) } - bindings831 := xs828 - return bindings831 + bindings839 := xs836 + return bindings839 } func (p *Parser) parse_formula() *pb.Formula { - span_start846 := int64(p.spanStart()) - var _t1541 int64 + span_start854 := int64(p.spanStart()) + var _t1557 int64 if p.matchLookaheadLiteral("(", 0) { - var _t1542 int64 + var _t1558 int64 if p.matchLookaheadLiteral("true", 1) { - _t1542 = 0 + _t1558 = 0 } else { - var _t1543 int64 + var _t1559 int64 if p.matchLookaheadLiteral("relatom", 1) { - _t1543 = 11 + _t1559 = 11 } else { - var _t1544 int64 + var _t1560 int64 if p.matchLookaheadLiteral("reduce", 1) { - _t1544 = 3 + _t1560 = 3 } else { - var _t1545 int64 + var _t1561 int64 if p.matchLookaheadLiteral("primitive", 1) { - _t1545 = 10 + _t1561 = 10 } else { - var _t1546 int64 + var _t1562 int64 if p.matchLookaheadLiteral("pragma", 1) { - _t1546 = 9 + _t1562 = 9 } else { - var _t1547 int64 + var _t1563 int64 if p.matchLookaheadLiteral("or", 1) { - _t1547 = 5 + _t1563 = 5 } else { - var _t1548 int64 + var _t1564 int64 if p.matchLookaheadLiteral("not", 1) { - _t1548 = 6 + _t1564 = 6 } else { - var _t1549 int64 + var _t1565 int64 if p.matchLookaheadLiteral("ffi", 1) { - _t1549 = 7 + _t1565 = 7 } else { - var _t1550 int64 + var _t1566 int64 if p.matchLookaheadLiteral("false", 1) { - _t1550 = 1 + _t1566 = 1 } else { - var _t1551 int64 + var _t1567 int64 if p.matchLookaheadLiteral("exists", 1) { - _t1551 = 2 + _t1567 = 2 } else { - var _t1552 int64 + var _t1568 int64 if p.matchLookaheadLiteral("cast", 1) { - _t1552 = 12 + _t1568 = 12 } else { - var _t1553 int64 + var _t1569 int64 if p.matchLookaheadLiteral("atom", 1) { - _t1553 = 8 + _t1569 = 8 } else { - var _t1554 int64 + var _t1570 int64 if p.matchLookaheadLiteral("and", 1) { - _t1554 = 4 + _t1570 = 4 } else { - var _t1555 int64 + var _t1571 int64 if p.matchLookaheadLiteral(">=", 1) { - _t1555 = 10 + _t1571 = 10 } else { - var _t1556 int64 + var _t1572 int64 if p.matchLookaheadLiteral(">", 1) { - _t1556 = 10 + _t1572 = 10 } else { - var _t1557 int64 + var _t1573 int64 if p.matchLookaheadLiteral("=", 1) { - _t1557 = 10 + _t1573 = 10 } else { - var _t1558 int64 + var _t1574 int64 if p.matchLookaheadLiteral("<=", 1) { - _t1558 = 10 + _t1574 = 10 } else { - var _t1559 int64 + var _t1575 int64 if p.matchLookaheadLiteral("<", 1) { - _t1559 = 10 + _t1575 = 10 } else { - var _t1560 int64 + var _t1576 int64 if p.matchLookaheadLiteral("/", 1) { - _t1560 = 10 + _t1576 = 10 } else { - var _t1561 int64 + var _t1577 int64 if p.matchLookaheadLiteral("-", 1) { - _t1561 = 10 + _t1577 = 10 } else { - var _t1562 int64 + var _t1578 int64 if p.matchLookaheadLiteral("+", 1) { - _t1562 = 10 + _t1578 = 10 } else { - var _t1563 int64 + var _t1579 int64 if p.matchLookaheadLiteral("*", 1) { - _t1563 = 10 + _t1579 = 10 } else { - _t1563 = -1 + _t1579 = -1 } - _t1562 = _t1563 + _t1578 = _t1579 } - _t1561 = _t1562 + _t1577 = _t1578 } - _t1560 = _t1561 + _t1576 = _t1577 } - _t1559 = _t1560 + _t1575 = _t1576 } - _t1558 = _t1559 + _t1574 = _t1575 } - _t1557 = _t1558 + _t1573 = _t1574 } - _t1556 = _t1557 + _t1572 = _t1573 } - _t1555 = _t1556 + _t1571 = _t1572 } - _t1554 = _t1555 + _t1570 = _t1571 } - _t1553 = _t1554 + _t1569 = _t1570 } - _t1552 = _t1553 + _t1568 = _t1569 } - _t1551 = _t1552 + _t1567 = _t1568 } - _t1550 = _t1551 + _t1566 = _t1567 } - _t1549 = _t1550 + _t1565 = _t1566 } - _t1548 = _t1549 + _t1564 = _t1565 } - _t1547 = _t1548 + _t1563 = _t1564 } - _t1546 = _t1547 + _t1562 = _t1563 } - _t1545 = _t1546 + _t1561 = _t1562 } - _t1544 = _t1545 + _t1560 = _t1561 } - _t1543 = _t1544 + _t1559 = _t1560 } - _t1542 = _t1543 + _t1558 = _t1559 } - _t1541 = _t1542 + _t1557 = _t1558 } else { - _t1541 = -1 - } - prediction832 := _t1541 - var _t1564 *pb.Formula - if prediction832 == 12 { - _t1565 := p.parse_cast() - cast845 := _t1565 - _t1566 := &pb.Formula{} - _t1566.FormulaType = &pb.Formula_Cast{Cast: cast845} - _t1564 = _t1566 + _t1557 = -1 + } + prediction840 := _t1557 + var _t1580 *pb.Formula + if prediction840 == 12 { + _t1581 := p.parse_cast() + cast853 := _t1581 + _t1582 := &pb.Formula{} + _t1582.FormulaType = &pb.Formula_Cast{Cast: cast853} + _t1580 = _t1582 } else { - var _t1567 *pb.Formula - if prediction832 == 11 { - _t1568 := p.parse_rel_atom() - rel_atom844 := _t1568 - _t1569 := &pb.Formula{} - _t1569.FormulaType = &pb.Formula_RelAtom{RelAtom: rel_atom844} - _t1567 = _t1569 + var _t1583 *pb.Formula + if prediction840 == 11 { + _t1584 := p.parse_rel_atom() + rel_atom852 := _t1584 + _t1585 := &pb.Formula{} + _t1585.FormulaType = &pb.Formula_RelAtom{RelAtom: rel_atom852} + _t1583 = _t1585 } else { - var _t1570 *pb.Formula - if prediction832 == 10 { - _t1571 := p.parse_primitive() - primitive843 := _t1571 - _t1572 := &pb.Formula{} - _t1572.FormulaType = &pb.Formula_Primitive{Primitive: primitive843} - _t1570 = _t1572 + var _t1586 *pb.Formula + if prediction840 == 10 { + _t1587 := p.parse_primitive() + primitive851 := _t1587 + _t1588 := &pb.Formula{} + _t1588.FormulaType = &pb.Formula_Primitive{Primitive: primitive851} + _t1586 = _t1588 } else { - var _t1573 *pb.Formula - if prediction832 == 9 { - _t1574 := p.parse_pragma() - pragma842 := _t1574 - _t1575 := &pb.Formula{} - _t1575.FormulaType = &pb.Formula_Pragma{Pragma: pragma842} - _t1573 = _t1575 + var _t1589 *pb.Formula + if prediction840 == 9 { + _t1590 := p.parse_pragma() + pragma850 := _t1590 + _t1591 := &pb.Formula{} + _t1591.FormulaType = &pb.Formula_Pragma{Pragma: pragma850} + _t1589 = _t1591 } else { - var _t1576 *pb.Formula - if prediction832 == 8 { - _t1577 := p.parse_atom() - atom841 := _t1577 - _t1578 := &pb.Formula{} - _t1578.FormulaType = &pb.Formula_Atom{Atom: atom841} - _t1576 = _t1578 + var _t1592 *pb.Formula + if prediction840 == 8 { + _t1593 := p.parse_atom() + atom849 := _t1593 + _t1594 := &pb.Formula{} + _t1594.FormulaType = &pb.Formula_Atom{Atom: atom849} + _t1592 = _t1594 } else { - var _t1579 *pb.Formula - if prediction832 == 7 { - _t1580 := p.parse_ffi() - ffi840 := _t1580 - _t1581 := &pb.Formula{} - _t1581.FormulaType = &pb.Formula_Ffi{Ffi: ffi840} - _t1579 = _t1581 + var _t1595 *pb.Formula + if prediction840 == 7 { + _t1596 := p.parse_ffi() + ffi848 := _t1596 + _t1597 := &pb.Formula{} + _t1597.FormulaType = &pb.Formula_Ffi{Ffi: ffi848} + _t1595 = _t1597 } else { - var _t1582 *pb.Formula - if prediction832 == 6 { - _t1583 := p.parse_not() - not839 := _t1583 - _t1584 := &pb.Formula{} - _t1584.FormulaType = &pb.Formula_Not{Not: not839} - _t1582 = _t1584 + var _t1598 *pb.Formula + if prediction840 == 6 { + _t1599 := p.parse_not() + not847 := _t1599 + _t1600 := &pb.Formula{} + _t1600.FormulaType = &pb.Formula_Not{Not: not847} + _t1598 = _t1600 } else { - var _t1585 *pb.Formula - if prediction832 == 5 { - _t1586 := p.parse_disjunction() - disjunction838 := _t1586 - _t1587 := &pb.Formula{} - _t1587.FormulaType = &pb.Formula_Disjunction{Disjunction: disjunction838} - _t1585 = _t1587 + var _t1601 *pb.Formula + if prediction840 == 5 { + _t1602 := p.parse_disjunction() + disjunction846 := _t1602 + _t1603 := &pb.Formula{} + _t1603.FormulaType = &pb.Formula_Disjunction{Disjunction: disjunction846} + _t1601 = _t1603 } else { - var _t1588 *pb.Formula - if prediction832 == 4 { - _t1589 := p.parse_conjunction() - conjunction837 := _t1589 - _t1590 := &pb.Formula{} - _t1590.FormulaType = &pb.Formula_Conjunction{Conjunction: conjunction837} - _t1588 = _t1590 + var _t1604 *pb.Formula + if prediction840 == 4 { + _t1605 := p.parse_conjunction() + conjunction845 := _t1605 + _t1606 := &pb.Formula{} + _t1606.FormulaType = &pb.Formula_Conjunction{Conjunction: conjunction845} + _t1604 = _t1606 } else { - var _t1591 *pb.Formula - if prediction832 == 3 { - _t1592 := p.parse_reduce() - reduce836 := _t1592 - _t1593 := &pb.Formula{} - _t1593.FormulaType = &pb.Formula_Reduce{Reduce: reduce836} - _t1591 = _t1593 + var _t1607 *pb.Formula + if prediction840 == 3 { + _t1608 := p.parse_reduce() + reduce844 := _t1608 + _t1609 := &pb.Formula{} + _t1609.FormulaType = &pb.Formula_Reduce{Reduce: reduce844} + _t1607 = _t1609 } else { - var _t1594 *pb.Formula - if prediction832 == 2 { - _t1595 := p.parse_exists() - exists835 := _t1595 - _t1596 := &pb.Formula{} - _t1596.FormulaType = &pb.Formula_Exists{Exists: exists835} - _t1594 = _t1596 + var _t1610 *pb.Formula + if prediction840 == 2 { + _t1611 := p.parse_exists() + exists843 := _t1611 + _t1612 := &pb.Formula{} + _t1612.FormulaType = &pb.Formula_Exists{Exists: exists843} + _t1610 = _t1612 } else { - var _t1597 *pb.Formula - if prediction832 == 1 { - _t1598 := p.parse_false() - false834 := _t1598 - _t1599 := &pb.Formula{} - _t1599.FormulaType = &pb.Formula_Disjunction{Disjunction: false834} - _t1597 = _t1599 + var _t1613 *pb.Formula + if prediction840 == 1 { + _t1614 := p.parse_false() + false842 := _t1614 + _t1615 := &pb.Formula{} + _t1615.FormulaType = &pb.Formula_Disjunction{Disjunction: false842} + _t1613 = _t1615 } else { - var _t1600 *pb.Formula - if prediction832 == 0 { - _t1601 := p.parse_true() - true833 := _t1601 - _t1602 := &pb.Formula{} - _t1602.FormulaType = &pb.Formula_Conjunction{Conjunction: true833} - _t1600 = _t1602 + var _t1616 *pb.Formula + if prediction840 == 0 { + _t1617 := p.parse_true() + true841 := _t1617 + _t1618 := &pb.Formula{} + _t1618.FormulaType = &pb.Formula_Conjunction{Conjunction: true841} + _t1616 = _t1618 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in formula", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1597 = _t1600 + _t1613 = _t1616 } - _t1594 = _t1597 + _t1610 = _t1613 } - _t1591 = _t1594 + _t1607 = _t1610 } - _t1588 = _t1591 + _t1604 = _t1607 } - _t1585 = _t1588 + _t1601 = _t1604 } - _t1582 = _t1585 + _t1598 = _t1601 } - _t1579 = _t1582 + _t1595 = _t1598 } - _t1576 = _t1579 + _t1592 = _t1595 } - _t1573 = _t1576 + _t1589 = _t1592 } - _t1570 = _t1573 + _t1586 = _t1589 } - _t1567 = _t1570 + _t1583 = _t1586 } - _t1564 = _t1567 + _t1580 = _t1583 } - result847 := _t1564 - p.recordSpan(int(span_start846), "Formula") - return result847 + result855 := _t1580 + p.recordSpan(int(span_start854), "Formula") + return result855 } func (p *Parser) parse_true() *pb.Conjunction { - span_start848 := int64(p.spanStart()) + span_start856 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("true") p.consumeLiteral(")") - _t1603 := &pb.Conjunction{Args: []*pb.Formula{}} - result849 := _t1603 - p.recordSpan(int(span_start848), "Conjunction") - return result849 + _t1619 := &pb.Conjunction{Args: []*pb.Formula{}} + result857 := _t1619 + p.recordSpan(int(span_start856), "Conjunction") + return result857 } func (p *Parser) parse_false() *pb.Disjunction { - span_start850 := int64(p.spanStart()) + span_start858 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("false") p.consumeLiteral(")") - _t1604 := &pb.Disjunction{Args: []*pb.Formula{}} - result851 := _t1604 - p.recordSpan(int(span_start850), "Disjunction") - return result851 + _t1620 := &pb.Disjunction{Args: []*pb.Formula{}} + result859 := _t1620 + p.recordSpan(int(span_start858), "Disjunction") + return result859 } func (p *Parser) parse_exists() *pb.Exists { - span_start854 := int64(p.spanStart()) + span_start862 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("exists") - _t1605 := p.parse_bindings() - bindings852 := _t1605 - _t1606 := p.parse_formula() - formula853 := _t1606 + _t1621 := p.parse_bindings() + bindings860 := _t1621 + _t1622 := p.parse_formula() + formula861 := _t1622 p.consumeLiteral(")") - _t1607 := &pb.Abstraction{Vars: listConcat(bindings852[0].([]*pb.Binding), bindings852[1].([]*pb.Binding)), Value: formula853} - _t1608 := &pb.Exists{Body: _t1607} - result855 := _t1608 - p.recordSpan(int(span_start854), "Exists") - return result855 + _t1623 := &pb.Abstraction{Vars: listConcat(bindings860[0].([]*pb.Binding), bindings860[1].([]*pb.Binding)), Value: formula861} + _t1624 := &pb.Exists{Body: _t1623} + result863 := _t1624 + p.recordSpan(int(span_start862), "Exists") + return result863 } func (p *Parser) parse_reduce() *pb.Reduce { - span_start859 := int64(p.spanStart()) + span_start867 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("reduce") - _t1609 := p.parse_abstraction() - abstraction856 := _t1609 - _t1610 := p.parse_abstraction() - abstraction_3857 := _t1610 - _t1611 := p.parse_terms() - terms858 := _t1611 + _t1625 := p.parse_abstraction() + abstraction864 := _t1625 + _t1626 := p.parse_abstraction() + abstraction_3865 := _t1626 + _t1627 := p.parse_terms() + terms866 := _t1627 p.consumeLiteral(")") - _t1612 := &pb.Reduce{Op: abstraction856, Body: abstraction_3857, Terms: terms858} - result860 := _t1612 - p.recordSpan(int(span_start859), "Reduce") - return result860 + _t1628 := &pb.Reduce{Op: abstraction864, Body: abstraction_3865, Terms: terms866} + result868 := _t1628 + p.recordSpan(int(span_start867), "Reduce") + return result868 } func (p *Parser) parse_terms() []*pb.Term { p.consumeLiteral("(") p.consumeLiteral("terms") - xs861 := []*pb.Term{} - cond862 := (((((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("false", 0)) || p.matchLookaheadLiteral("missing", 0)) || p.matchLookaheadLiteral("true", 0)) || p.matchLookaheadTerminal("DECIMAL", 0)) || p.matchLookaheadTerminal("FLOAT", 0)) || p.matchLookaheadTerminal("FLOAT32", 0)) || p.matchLookaheadTerminal("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("INT32", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("UINT128", 0)) || p.matchLookaheadTerminal("UINT32", 0)) || p.matchLookaheadTerminal("SYMBOL", 0)) - for cond862 { - _t1613 := p.parse_term() - item863 := _t1613 - xs861 = append(xs861, item863) - cond862 = (((((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("false", 0)) || p.matchLookaheadLiteral("missing", 0)) || p.matchLookaheadLiteral("true", 0)) || p.matchLookaheadTerminal("DECIMAL", 0)) || p.matchLookaheadTerminal("FLOAT", 0)) || p.matchLookaheadTerminal("FLOAT32", 0)) || p.matchLookaheadTerminal("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("INT32", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("UINT128", 0)) || p.matchLookaheadTerminal("UINT32", 0)) || p.matchLookaheadTerminal("SYMBOL", 0)) - } - terms864 := xs861 + xs869 := []*pb.Term{} + cond870 := (((((((((((((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 cond870 { + _t1629 := p.parse_term() + item871 := _t1629 + xs869 = append(xs869, item871) + cond870 = (((((((((((((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)) + } + terms872 := xs869 p.consumeLiteral(")") - return terms864 + return terms872 } func (p *Parser) parse_term() *pb.Term { - span_start868 := int64(p.spanStart()) - var _t1614 int64 + span_start876 := int64(p.spanStart()) + var _t1630 int64 if p.matchLookaheadLiteral("true", 0) { - _t1614 = 1 + _t1630 = 1 } else { - var _t1615 int64 + var _t1631 int64 if p.matchLookaheadLiteral("missing", 0) { - _t1615 = 1 + _t1631 = 1 } else { - var _t1616 int64 + var _t1632 int64 if p.matchLookaheadLiteral("false", 0) { - _t1616 = 1 + _t1632 = 1 } else { - var _t1617 int64 + var _t1633 int64 if p.matchLookaheadLiteral("(", 0) { - _t1617 = 1 + _t1633 = 1 } else { - var _t1618 int64 + var _t1634 int64 if p.matchLookaheadTerminal("SYMBOL", 0) { - _t1618 = 0 + _t1634 = 0 } else { - var _t1619 int64 + var _t1635 int64 if p.matchLookaheadTerminal("UINT32", 0) { - _t1619 = 1 + _t1635 = 1 } else { - var _t1620 int64 + var _t1636 int64 if p.matchLookaheadTerminal("UINT128", 0) { - _t1620 = 1 + _t1636 = 1 } else { - var _t1621 int64 + var _t1637 int64 if p.matchLookaheadTerminal("STRING", 0) { - _t1621 = 1 + _t1637 = 1 } else { - var _t1622 int64 + var _t1638 int64 if p.matchLookaheadTerminal("INT32", 0) { - _t1622 = 1 + _t1638 = 1 } else { - var _t1623 int64 + var _t1639 int64 if p.matchLookaheadTerminal("INT128", 0) { - _t1623 = 1 + _t1639 = 1 } else { - var _t1624 int64 + var _t1640 int64 if p.matchLookaheadTerminal("INT", 0) { - _t1624 = 1 + _t1640 = 1 } else { - var _t1625 int64 + var _t1641 int64 if p.matchLookaheadTerminal("FLOAT32", 0) { - _t1625 = 1 + _t1641 = 1 } else { - var _t1626 int64 + var _t1642 int64 if p.matchLookaheadTerminal("FLOAT", 0) { - _t1626 = 1 + _t1642 = 1 } else { - var _t1627 int64 + var _t1643 int64 if p.matchLookaheadTerminal("DECIMAL", 0) { - _t1627 = 1 + _t1643 = 1 } else { - _t1627 = -1 + _t1643 = -1 } - _t1626 = _t1627 + _t1642 = _t1643 } - _t1625 = _t1626 + _t1641 = _t1642 } - _t1624 = _t1625 + _t1640 = _t1641 } - _t1623 = _t1624 + _t1639 = _t1640 } - _t1622 = _t1623 + _t1638 = _t1639 } - _t1621 = _t1622 + _t1637 = _t1638 } - _t1620 = _t1621 + _t1636 = _t1637 } - _t1619 = _t1620 + _t1635 = _t1636 } - _t1618 = _t1619 + _t1634 = _t1635 } - _t1617 = _t1618 + _t1633 = _t1634 } - _t1616 = _t1617 + _t1632 = _t1633 } - _t1615 = _t1616 + _t1631 = _t1632 } - _t1614 = _t1615 - } - prediction865 := _t1614 - var _t1628 *pb.Term - if prediction865 == 1 { - _t1629 := p.parse_value() - value867 := _t1629 - _t1630 := &pb.Term{} - _t1630.TermType = &pb.Term_Constant{Constant: value867} - _t1628 = _t1630 + _t1630 = _t1631 + } + prediction873 := _t1630 + var _t1644 *pb.Term + if prediction873 == 1 { + _t1645 := p.parse_value() + value875 := _t1645 + _t1646 := &pb.Term{} + _t1646.TermType = &pb.Term_Constant{Constant: value875} + _t1644 = _t1646 } else { - var _t1631 *pb.Term - if prediction865 == 0 { - _t1632 := p.parse_var() - var866 := _t1632 - _t1633 := &pb.Term{} - _t1633.TermType = &pb.Term_Var{Var: var866} - _t1631 = _t1633 + var _t1647 *pb.Term + if prediction873 == 0 { + _t1648 := p.parse_var() + var874 := _t1648 + _t1649 := &pb.Term{} + _t1649.TermType = &pb.Term_Var{Var: var874} + _t1647 = _t1649 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in term", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1628 = _t1631 + _t1644 = _t1647 } - result869 := _t1628 - p.recordSpan(int(span_start868), "Term") - return result869 + result877 := _t1644 + p.recordSpan(int(span_start876), "Term") + return result877 } func (p *Parser) parse_var() *pb.Var { - span_start871 := int64(p.spanStart()) - symbol870 := p.consumeTerminal("SYMBOL").Value.str - _t1634 := &pb.Var{Name: symbol870} - result872 := _t1634 - p.recordSpan(int(span_start871), "Var") - return result872 + span_start879 := int64(p.spanStart()) + symbol878 := p.consumeTerminal("SYMBOL").Value.str + _t1650 := &pb.Var{Name: symbol878} + result880 := _t1650 + p.recordSpan(int(span_start879), "Var") + return result880 } func (p *Parser) parse_value() *pb.Value { - span_start886 := int64(p.spanStart()) - var _t1635 int64 + span_start894 := int64(p.spanStart()) + var _t1651 int64 if p.matchLookaheadLiteral("true", 0) { - _t1635 = 12 + _t1651 = 12 } else { - var _t1636 int64 + var _t1652 int64 if p.matchLookaheadLiteral("missing", 0) { - _t1636 = 11 + _t1652 = 11 } else { - var _t1637 int64 + var _t1653 int64 if p.matchLookaheadLiteral("false", 0) { - _t1637 = 12 + _t1653 = 12 } else { - var _t1638 int64 + var _t1654 int64 if p.matchLookaheadLiteral("(", 0) { - var _t1639 int64 + var _t1655 int64 if p.matchLookaheadLiteral("datetime", 1) { - _t1639 = 1 + _t1655 = 1 } else { - var _t1640 int64 + var _t1656 int64 if p.matchLookaheadLiteral("date", 1) { - _t1640 = 0 + _t1656 = 0 } else { - _t1640 = -1 + _t1656 = -1 } - _t1639 = _t1640 + _t1655 = _t1656 } - _t1638 = _t1639 + _t1654 = _t1655 } else { - var _t1641 int64 + var _t1657 int64 if p.matchLookaheadTerminal("UINT32", 0) { - _t1641 = 7 + _t1657 = 7 } else { - var _t1642 int64 + var _t1658 int64 if p.matchLookaheadTerminal("UINT128", 0) { - _t1642 = 8 + _t1658 = 8 } else { - var _t1643 int64 + var _t1659 int64 if p.matchLookaheadTerminal("STRING", 0) { - _t1643 = 2 + _t1659 = 2 } else { - var _t1644 int64 + var _t1660 int64 if p.matchLookaheadTerminal("INT32", 0) { - _t1644 = 3 + _t1660 = 3 } else { - var _t1645 int64 + var _t1661 int64 if p.matchLookaheadTerminal("INT128", 0) { - _t1645 = 9 + _t1661 = 9 } else { - var _t1646 int64 + var _t1662 int64 if p.matchLookaheadTerminal("INT", 0) { - _t1646 = 4 + _t1662 = 4 } else { - var _t1647 int64 + var _t1663 int64 if p.matchLookaheadTerminal("FLOAT32", 0) { - _t1647 = 5 + _t1663 = 5 } else { - var _t1648 int64 + var _t1664 int64 if p.matchLookaheadTerminal("FLOAT", 0) { - _t1648 = 6 + _t1664 = 6 } else { - var _t1649 int64 + var _t1665 int64 if p.matchLookaheadTerminal("DECIMAL", 0) { - _t1649 = 10 + _t1665 = 10 } else { - _t1649 = -1 + _t1665 = -1 } - _t1648 = _t1649 + _t1664 = _t1665 } - _t1647 = _t1648 + _t1663 = _t1664 } - _t1646 = _t1647 + _t1662 = _t1663 } - _t1645 = _t1646 + _t1661 = _t1662 } - _t1644 = _t1645 + _t1660 = _t1661 } - _t1643 = _t1644 + _t1659 = _t1660 } - _t1642 = _t1643 + _t1658 = _t1659 } - _t1641 = _t1642 + _t1657 = _t1658 } - _t1638 = _t1641 + _t1654 = _t1657 } - _t1637 = _t1638 + _t1653 = _t1654 } - _t1636 = _t1637 + _t1652 = _t1653 } - _t1635 = _t1636 - } - prediction873 := _t1635 - var _t1650 *pb.Value - if prediction873 == 12 { - _t1651 := p.parse_boolean_value() - boolean_value885 := _t1651 - _t1652 := &pb.Value{} - _t1652.Value = &pb.Value_BooleanValue{BooleanValue: boolean_value885} - _t1650 = _t1652 + _t1651 = _t1652 + } + prediction881 := _t1651 + var _t1666 *pb.Value + if prediction881 == 12 { + _t1667 := p.parse_boolean_value() + boolean_value893 := _t1667 + _t1668 := &pb.Value{} + _t1668.Value = &pb.Value_BooleanValue{BooleanValue: boolean_value893} + _t1666 = _t1668 } else { - var _t1653 *pb.Value - if prediction873 == 11 { + var _t1669 *pb.Value + if prediction881 == 11 { p.consumeLiteral("missing") - _t1654 := &pb.MissingValue{} - _t1655 := &pb.Value{} - _t1655.Value = &pb.Value_MissingValue{MissingValue: _t1654} - _t1653 = _t1655 + _t1670 := &pb.MissingValue{} + _t1671 := &pb.Value{} + _t1671.Value = &pb.Value_MissingValue{MissingValue: _t1670} + _t1669 = _t1671 } else { - var _t1656 *pb.Value - if prediction873 == 10 { - formatted_decimal884 := p.consumeTerminal("DECIMAL").Value.decimal - _t1657 := &pb.Value{} - _t1657.Value = &pb.Value_DecimalValue{DecimalValue: formatted_decimal884} - _t1656 = _t1657 + var _t1672 *pb.Value + if prediction881 == 10 { + formatted_decimal892 := p.consumeTerminal("DECIMAL").Value.decimal + _t1673 := &pb.Value{} + _t1673.Value = &pb.Value_DecimalValue{DecimalValue: formatted_decimal892} + _t1672 = _t1673 } else { - var _t1658 *pb.Value - if prediction873 == 9 { - formatted_int128883 := p.consumeTerminal("INT128").Value.int128 - _t1659 := &pb.Value{} - _t1659.Value = &pb.Value_Int128Value{Int128Value: formatted_int128883} - _t1658 = _t1659 + var _t1674 *pb.Value + if prediction881 == 9 { + formatted_int128891 := p.consumeTerminal("INT128").Value.int128 + _t1675 := &pb.Value{} + _t1675.Value = &pb.Value_Int128Value{Int128Value: formatted_int128891} + _t1674 = _t1675 } else { - var _t1660 *pb.Value - if prediction873 == 8 { - formatted_uint128882 := p.consumeTerminal("UINT128").Value.uint128 - _t1661 := &pb.Value{} - _t1661.Value = &pb.Value_Uint128Value{Uint128Value: formatted_uint128882} - _t1660 = _t1661 + var _t1676 *pb.Value + if prediction881 == 8 { + formatted_uint128890 := p.consumeTerminal("UINT128").Value.uint128 + _t1677 := &pb.Value{} + _t1677.Value = &pb.Value_Uint128Value{Uint128Value: formatted_uint128890} + _t1676 = _t1677 } else { - var _t1662 *pb.Value - if prediction873 == 7 { - formatted_uint32881 := p.consumeTerminal("UINT32").Value.u32 - _t1663 := &pb.Value{} - _t1663.Value = &pb.Value_Uint32Value{Uint32Value: formatted_uint32881} - _t1662 = _t1663 + var _t1678 *pb.Value + if prediction881 == 7 { + formatted_uint32889 := p.consumeTerminal("UINT32").Value.u32 + _t1679 := &pb.Value{} + _t1679.Value = &pb.Value_Uint32Value{Uint32Value: formatted_uint32889} + _t1678 = _t1679 } else { - var _t1664 *pb.Value - if prediction873 == 6 { - formatted_float880 := p.consumeTerminal("FLOAT").Value.f64 - _t1665 := &pb.Value{} - _t1665.Value = &pb.Value_FloatValue{FloatValue: formatted_float880} - _t1664 = _t1665 + var _t1680 *pb.Value + if prediction881 == 6 { + formatted_float888 := p.consumeTerminal("FLOAT").Value.f64 + _t1681 := &pb.Value{} + _t1681.Value = &pb.Value_FloatValue{FloatValue: formatted_float888} + _t1680 = _t1681 } else { - var _t1666 *pb.Value - if prediction873 == 5 { - formatted_float32879 := p.consumeTerminal("FLOAT32").Value.f32 - _t1667 := &pb.Value{} - _t1667.Value = &pb.Value_Float32Value{Float32Value: formatted_float32879} - _t1666 = _t1667 + var _t1682 *pb.Value + if prediction881 == 5 { + formatted_float32887 := p.consumeTerminal("FLOAT32").Value.f32 + _t1683 := &pb.Value{} + _t1683.Value = &pb.Value_Float32Value{Float32Value: formatted_float32887} + _t1682 = _t1683 } else { - var _t1668 *pb.Value - if prediction873 == 4 { - formatted_int878 := p.consumeTerminal("INT").Value.i64 - _t1669 := &pb.Value{} - _t1669.Value = &pb.Value_IntValue{IntValue: formatted_int878} - _t1668 = _t1669 + var _t1684 *pb.Value + if prediction881 == 4 { + formatted_int886 := p.consumeTerminal("INT").Value.i64 + _t1685 := &pb.Value{} + _t1685.Value = &pb.Value_IntValue{IntValue: formatted_int886} + _t1684 = _t1685 } else { - var _t1670 *pb.Value - if prediction873 == 3 { - formatted_int32877 := p.consumeTerminal("INT32").Value.i32 - _t1671 := &pb.Value{} - _t1671.Value = &pb.Value_Int32Value{Int32Value: formatted_int32877} - _t1670 = _t1671 + var _t1686 *pb.Value + if prediction881 == 3 { + formatted_int32885 := p.consumeTerminal("INT32").Value.i32 + _t1687 := &pb.Value{} + _t1687.Value = &pb.Value_Int32Value{Int32Value: formatted_int32885} + _t1686 = _t1687 } else { - var _t1672 *pb.Value - if prediction873 == 2 { - formatted_string876 := p.consumeTerminal("STRING").Value.str - _t1673 := &pb.Value{} - _t1673.Value = &pb.Value_StringValue{StringValue: formatted_string876} - _t1672 = _t1673 + var _t1688 *pb.Value + if prediction881 == 2 { + formatted_string884 := p.consumeTerminal("STRING").Value.str + _t1689 := &pb.Value{} + _t1689.Value = &pb.Value_StringValue{StringValue: formatted_string884} + _t1688 = _t1689 } else { - var _t1674 *pb.Value - if prediction873 == 1 { - _t1675 := p.parse_datetime() - datetime875 := _t1675 - _t1676 := &pb.Value{} - _t1676.Value = &pb.Value_DatetimeValue{DatetimeValue: datetime875} - _t1674 = _t1676 + var _t1690 *pb.Value + if prediction881 == 1 { + _t1691 := p.parse_datetime() + datetime883 := _t1691 + _t1692 := &pb.Value{} + _t1692.Value = &pb.Value_DatetimeValue{DatetimeValue: datetime883} + _t1690 = _t1692 } else { - var _t1677 *pb.Value - if prediction873 == 0 { - _t1678 := p.parse_date() - date874 := _t1678 - _t1679 := &pb.Value{} - _t1679.Value = &pb.Value_DateValue{DateValue: date874} - _t1677 = _t1679 + var _t1693 *pb.Value + if prediction881 == 0 { + _t1694 := p.parse_date() + date882 := _t1694 + _t1695 := &pb.Value{} + _t1695.Value = &pb.Value_DateValue{DateValue: date882} + _t1693 = _t1695 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in value", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1674 = _t1677 + _t1690 = _t1693 } - _t1672 = _t1674 + _t1688 = _t1690 } - _t1670 = _t1672 + _t1686 = _t1688 } - _t1668 = _t1670 + _t1684 = _t1686 } - _t1666 = _t1668 + _t1682 = _t1684 } - _t1664 = _t1666 + _t1680 = _t1682 } - _t1662 = _t1664 + _t1678 = _t1680 } - _t1660 = _t1662 + _t1676 = _t1678 } - _t1658 = _t1660 + _t1674 = _t1676 } - _t1656 = _t1658 + _t1672 = _t1674 } - _t1653 = _t1656 + _t1669 = _t1672 } - _t1650 = _t1653 + _t1666 = _t1669 } - result887 := _t1650 - p.recordSpan(int(span_start886), "Value") - return result887 + result895 := _t1666 + p.recordSpan(int(span_start894), "Value") + return result895 } func (p *Parser) parse_date() *pb.DateValue { - span_start891 := int64(p.spanStart()) + span_start899 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("date") - formatted_int888 := p.consumeTerminal("INT").Value.i64 - formatted_int_3889 := p.consumeTerminal("INT").Value.i64 - formatted_int_4890 := p.consumeTerminal("INT").Value.i64 + formatted_int896 := p.consumeTerminal("INT").Value.i64 + formatted_int_3897 := p.consumeTerminal("INT").Value.i64 + formatted_int_4898 := p.consumeTerminal("INT").Value.i64 p.consumeLiteral(")") - _t1680 := &pb.DateValue{Year: int32(formatted_int888), Month: int32(formatted_int_3889), Day: int32(formatted_int_4890)} - result892 := _t1680 - p.recordSpan(int(span_start891), "DateValue") - return result892 + _t1696 := &pb.DateValue{Year: int32(formatted_int896), Month: int32(formatted_int_3897), Day: int32(formatted_int_4898)} + result900 := _t1696 + p.recordSpan(int(span_start899), "DateValue") + return result900 } func (p *Parser) parse_datetime() *pb.DateTimeValue { - span_start900 := int64(p.spanStart()) + span_start908 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("datetime") - formatted_int893 := p.consumeTerminal("INT").Value.i64 - formatted_int_3894 := p.consumeTerminal("INT").Value.i64 - formatted_int_4895 := p.consumeTerminal("INT").Value.i64 - formatted_int_5896 := p.consumeTerminal("INT").Value.i64 - formatted_int_6897 := p.consumeTerminal("INT").Value.i64 - formatted_int_7898 := p.consumeTerminal("INT").Value.i64 - var _t1681 *int64 + formatted_int901 := p.consumeTerminal("INT").Value.i64 + formatted_int_3902 := p.consumeTerminal("INT").Value.i64 + formatted_int_4903 := p.consumeTerminal("INT").Value.i64 + formatted_int_5904 := p.consumeTerminal("INT").Value.i64 + formatted_int_6905 := p.consumeTerminal("INT").Value.i64 + formatted_int_7906 := p.consumeTerminal("INT").Value.i64 + var _t1697 *int64 if p.matchLookaheadTerminal("INT", 0) { - _t1681 = ptr(p.consumeTerminal("INT").Value.i64) + _t1697 = ptr(p.consumeTerminal("INT").Value.i64) } - formatted_int_8899 := _t1681 + formatted_int_8907 := _t1697 p.consumeLiteral(")") - _t1682 := &pb.DateTimeValue{Year: int32(formatted_int893), Month: int32(formatted_int_3894), Day: int32(formatted_int_4895), Hour: int32(formatted_int_5896), Minute: int32(formatted_int_6897), Second: int32(formatted_int_7898), Microsecond: int32(deref(formatted_int_8899, 0))} - result901 := _t1682 - p.recordSpan(int(span_start900), "DateTimeValue") - return result901 + _t1698 := &pb.DateTimeValue{Year: int32(formatted_int901), Month: int32(formatted_int_3902), Day: int32(formatted_int_4903), Hour: int32(formatted_int_5904), Minute: int32(formatted_int_6905), Second: int32(formatted_int_7906), Microsecond: int32(deref(formatted_int_8907, 0))} + result909 := _t1698 + p.recordSpan(int(span_start908), "DateTimeValue") + return result909 } func (p *Parser) parse_conjunction() *pb.Conjunction { - span_start906 := int64(p.spanStart()) + span_start914 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("and") - xs902 := []*pb.Formula{} - cond903 := p.matchLookaheadLiteral("(", 0) - for cond903 { - _t1683 := p.parse_formula() - item904 := _t1683 - xs902 = append(xs902, item904) - cond903 = p.matchLookaheadLiteral("(", 0) - } - formulas905 := xs902 + xs910 := []*pb.Formula{} + cond911 := p.matchLookaheadLiteral("(", 0) + for cond911 { + _t1699 := p.parse_formula() + item912 := _t1699 + xs910 = append(xs910, item912) + cond911 = p.matchLookaheadLiteral("(", 0) + } + formulas913 := xs910 p.consumeLiteral(")") - _t1684 := &pb.Conjunction{Args: formulas905} - result907 := _t1684 - p.recordSpan(int(span_start906), "Conjunction") - return result907 + _t1700 := &pb.Conjunction{Args: formulas913} + result915 := _t1700 + p.recordSpan(int(span_start914), "Conjunction") + return result915 } func (p *Parser) parse_disjunction() *pb.Disjunction { - span_start912 := int64(p.spanStart()) + span_start920 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("or") - xs908 := []*pb.Formula{} - cond909 := p.matchLookaheadLiteral("(", 0) - for cond909 { - _t1685 := p.parse_formula() - item910 := _t1685 - xs908 = append(xs908, item910) - cond909 = p.matchLookaheadLiteral("(", 0) - } - formulas911 := xs908 + xs916 := []*pb.Formula{} + cond917 := p.matchLookaheadLiteral("(", 0) + for cond917 { + _t1701 := p.parse_formula() + item918 := _t1701 + xs916 = append(xs916, item918) + cond917 = p.matchLookaheadLiteral("(", 0) + } + formulas919 := xs916 p.consumeLiteral(")") - _t1686 := &pb.Disjunction{Args: formulas911} - result913 := _t1686 - p.recordSpan(int(span_start912), "Disjunction") - return result913 + _t1702 := &pb.Disjunction{Args: formulas919} + result921 := _t1702 + p.recordSpan(int(span_start920), "Disjunction") + return result921 } func (p *Parser) parse_not() *pb.Not { - span_start915 := int64(p.spanStart()) + span_start923 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("not") - _t1687 := p.parse_formula() - formula914 := _t1687 + _t1703 := p.parse_formula() + formula922 := _t1703 p.consumeLiteral(")") - _t1688 := &pb.Not{Arg: formula914} - result916 := _t1688 - p.recordSpan(int(span_start915), "Not") - return result916 + _t1704 := &pb.Not{Arg: formula922} + result924 := _t1704 + p.recordSpan(int(span_start923), "Not") + return result924 } func (p *Parser) parse_ffi() *pb.FFI { - span_start920 := int64(p.spanStart()) + span_start928 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("ffi") - _t1689 := p.parse_name() - name917 := _t1689 - _t1690 := p.parse_ffi_args() - ffi_args918 := _t1690 - _t1691 := p.parse_terms() - terms919 := _t1691 + _t1705 := p.parse_name() + name925 := _t1705 + _t1706 := p.parse_ffi_args() + ffi_args926 := _t1706 + _t1707 := p.parse_terms() + terms927 := _t1707 p.consumeLiteral(")") - _t1692 := &pb.FFI{Name: name917, Args: ffi_args918, Terms: terms919} - result921 := _t1692 - p.recordSpan(int(span_start920), "FFI") - return result921 + _t1708 := &pb.FFI{Name: name925, Args: ffi_args926, Terms: terms927} + result929 := _t1708 + p.recordSpan(int(span_start928), "FFI") + return result929 } func (p *Parser) parse_name() string { p.consumeLiteral(":") - symbol922 := p.consumeTerminal("SYMBOL").Value.str - return symbol922 + symbol930 := p.consumeTerminal("SYMBOL").Value.str + return symbol930 } func (p *Parser) parse_ffi_args() []*pb.Abstraction { p.consumeLiteral("(") p.consumeLiteral("args") - xs923 := []*pb.Abstraction{} - cond924 := p.matchLookaheadLiteral("(", 0) - for cond924 { - _t1693 := p.parse_abstraction() - item925 := _t1693 - xs923 = append(xs923, item925) - cond924 = p.matchLookaheadLiteral("(", 0) - } - abstractions926 := xs923 + xs931 := []*pb.Abstraction{} + cond932 := p.matchLookaheadLiteral("(", 0) + for cond932 { + _t1709 := p.parse_abstraction() + item933 := _t1709 + xs931 = append(xs931, item933) + cond932 = p.matchLookaheadLiteral("(", 0) + } + abstractions934 := xs931 p.consumeLiteral(")") - return abstractions926 + return abstractions934 } func (p *Parser) parse_atom() *pb.Atom { - span_start932 := int64(p.spanStart()) + span_start940 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("atom") - _t1694 := p.parse_relation_id() - relation_id927 := _t1694 - xs928 := []*pb.Term{} - cond929 := (((((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("false", 0)) || p.matchLookaheadLiteral("missing", 0)) || p.matchLookaheadLiteral("true", 0)) || p.matchLookaheadTerminal("DECIMAL", 0)) || p.matchLookaheadTerminal("FLOAT", 0)) || p.matchLookaheadTerminal("FLOAT32", 0)) || p.matchLookaheadTerminal("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("INT32", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("UINT128", 0)) || p.matchLookaheadTerminal("UINT32", 0)) || p.matchLookaheadTerminal("SYMBOL", 0)) - for cond929 { - _t1695 := p.parse_term() - item930 := _t1695 - xs928 = append(xs928, item930) - cond929 = (((((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("false", 0)) || p.matchLookaheadLiteral("missing", 0)) || p.matchLookaheadLiteral("true", 0)) || p.matchLookaheadTerminal("DECIMAL", 0)) || p.matchLookaheadTerminal("FLOAT", 0)) || p.matchLookaheadTerminal("FLOAT32", 0)) || p.matchLookaheadTerminal("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("INT32", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("UINT128", 0)) || p.matchLookaheadTerminal("UINT32", 0)) || p.matchLookaheadTerminal("SYMBOL", 0)) - } - terms931 := xs928 + _t1710 := p.parse_relation_id() + relation_id935 := _t1710 + xs936 := []*pb.Term{} + cond937 := (((((((((((((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 cond937 { + _t1711 := p.parse_term() + item938 := _t1711 + xs936 = append(xs936, item938) + cond937 = (((((((((((((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)) + } + terms939 := xs936 p.consumeLiteral(")") - _t1696 := &pb.Atom{Name: relation_id927, Terms: terms931} - result933 := _t1696 - p.recordSpan(int(span_start932), "Atom") - return result933 + _t1712 := &pb.Atom{Name: relation_id935, Terms: terms939} + result941 := _t1712 + p.recordSpan(int(span_start940), "Atom") + return result941 } func (p *Parser) parse_pragma() *pb.Pragma { - span_start939 := int64(p.spanStart()) + span_start947 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("pragma") - _t1697 := p.parse_name() - name934 := _t1697 - xs935 := []*pb.Term{} - cond936 := (((((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("false", 0)) || p.matchLookaheadLiteral("missing", 0)) || p.matchLookaheadLiteral("true", 0)) || p.matchLookaheadTerminal("DECIMAL", 0)) || p.matchLookaheadTerminal("FLOAT", 0)) || p.matchLookaheadTerminal("FLOAT32", 0)) || p.matchLookaheadTerminal("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("INT32", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("UINT128", 0)) || p.matchLookaheadTerminal("UINT32", 0)) || p.matchLookaheadTerminal("SYMBOL", 0)) - for cond936 { - _t1698 := p.parse_term() - item937 := _t1698 - xs935 = append(xs935, item937) - cond936 = (((((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("false", 0)) || p.matchLookaheadLiteral("missing", 0)) || p.matchLookaheadLiteral("true", 0)) || p.matchLookaheadTerminal("DECIMAL", 0)) || p.matchLookaheadTerminal("FLOAT", 0)) || p.matchLookaheadTerminal("FLOAT32", 0)) || p.matchLookaheadTerminal("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("INT32", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("UINT128", 0)) || p.matchLookaheadTerminal("UINT32", 0)) || p.matchLookaheadTerminal("SYMBOL", 0)) - } - terms938 := xs935 + _t1713 := p.parse_name() + name942 := _t1713 + xs943 := []*pb.Term{} + cond944 := (((((((((((((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 cond944 { + _t1714 := p.parse_term() + item945 := _t1714 + xs943 = append(xs943, item945) + cond944 = (((((((((((((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)) + } + terms946 := xs943 p.consumeLiteral(")") - _t1699 := &pb.Pragma{Name: name934, Terms: terms938} - result940 := _t1699 - p.recordSpan(int(span_start939), "Pragma") - return result940 + _t1715 := &pb.Pragma{Name: name942, Terms: terms946} + result948 := _t1715 + p.recordSpan(int(span_start947), "Pragma") + return result948 } func (p *Parser) parse_primitive() *pb.Primitive { - span_start956 := int64(p.spanStart()) - var _t1700 int64 + span_start964 := int64(p.spanStart()) + var _t1716 int64 if p.matchLookaheadLiteral("(", 0) { - var _t1701 int64 + var _t1717 int64 if p.matchLookaheadLiteral("primitive", 1) { - _t1701 = 9 + _t1717 = 9 } else { - var _t1702 int64 + var _t1718 int64 if p.matchLookaheadLiteral(">=", 1) { - _t1702 = 4 + _t1718 = 4 } else { - var _t1703 int64 + var _t1719 int64 if p.matchLookaheadLiteral(">", 1) { - _t1703 = 3 + _t1719 = 3 } else { - var _t1704 int64 + var _t1720 int64 if p.matchLookaheadLiteral("=", 1) { - _t1704 = 0 + _t1720 = 0 } else { - var _t1705 int64 + var _t1721 int64 if p.matchLookaheadLiteral("<=", 1) { - _t1705 = 2 + _t1721 = 2 } else { - var _t1706 int64 + var _t1722 int64 if p.matchLookaheadLiteral("<", 1) { - _t1706 = 1 + _t1722 = 1 } else { - var _t1707 int64 + var _t1723 int64 if p.matchLookaheadLiteral("/", 1) { - _t1707 = 8 + _t1723 = 8 } else { - var _t1708 int64 + var _t1724 int64 if p.matchLookaheadLiteral("-", 1) { - _t1708 = 6 + _t1724 = 6 } else { - var _t1709 int64 + var _t1725 int64 if p.matchLookaheadLiteral("+", 1) { - _t1709 = 5 + _t1725 = 5 } else { - var _t1710 int64 + var _t1726 int64 if p.matchLookaheadLiteral("*", 1) { - _t1710 = 7 + _t1726 = 7 } else { - _t1710 = -1 + _t1726 = -1 } - _t1709 = _t1710 + _t1725 = _t1726 } - _t1708 = _t1709 + _t1724 = _t1725 } - _t1707 = _t1708 + _t1723 = _t1724 } - _t1706 = _t1707 + _t1722 = _t1723 } - _t1705 = _t1706 + _t1721 = _t1722 } - _t1704 = _t1705 + _t1720 = _t1721 } - _t1703 = _t1704 + _t1719 = _t1720 } - _t1702 = _t1703 + _t1718 = _t1719 } - _t1701 = _t1702 + _t1717 = _t1718 } - _t1700 = _t1701 + _t1716 = _t1717 } else { - _t1700 = -1 + _t1716 = -1 } - prediction941 := _t1700 - var _t1711 *pb.Primitive - if prediction941 == 9 { + prediction949 := _t1716 + var _t1727 *pb.Primitive + if prediction949 == 9 { p.consumeLiteral("(") p.consumeLiteral("primitive") - _t1712 := p.parse_name() - name951 := _t1712 - xs952 := []*pb.RelTerm{} - cond953 := ((((((((((((((p.matchLookaheadLiteral("#", 0) || p.matchLookaheadLiteral("(", 0)) || p.matchLookaheadLiteral("false", 0)) || p.matchLookaheadLiteral("missing", 0)) || p.matchLookaheadLiteral("true", 0)) || p.matchLookaheadTerminal("DECIMAL", 0)) || p.matchLookaheadTerminal("FLOAT", 0)) || p.matchLookaheadTerminal("FLOAT32", 0)) || p.matchLookaheadTerminal("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("INT32", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("UINT128", 0)) || p.matchLookaheadTerminal("UINT32", 0)) || p.matchLookaheadTerminal("SYMBOL", 0)) - for cond953 { - _t1713 := p.parse_rel_term() - item954 := _t1713 - xs952 = append(xs952, item954) - cond953 = ((((((((((((((p.matchLookaheadLiteral("#", 0) || p.matchLookaheadLiteral("(", 0)) || p.matchLookaheadLiteral("false", 0)) || p.matchLookaheadLiteral("missing", 0)) || p.matchLookaheadLiteral("true", 0)) || p.matchLookaheadTerminal("DECIMAL", 0)) || p.matchLookaheadTerminal("FLOAT", 0)) || p.matchLookaheadTerminal("FLOAT32", 0)) || p.matchLookaheadTerminal("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("INT32", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("UINT128", 0)) || p.matchLookaheadTerminal("UINT32", 0)) || p.matchLookaheadTerminal("SYMBOL", 0)) + _t1728 := p.parse_name() + name959 := _t1728 + xs960 := []*pb.RelTerm{} + cond961 := ((((((((((((((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 cond961 { + _t1729 := p.parse_rel_term() + item962 := _t1729 + xs960 = append(xs960, item962) + cond961 = ((((((((((((((p.matchLookaheadLiteral("#", 0) || p.matchLookaheadLiteral("(", 0)) || p.matchLookaheadLiteral("false", 0)) || p.matchLookaheadLiteral("missing", 0)) || p.matchLookaheadLiteral("true", 0)) || p.matchLookaheadTerminal("DECIMAL", 0)) || p.matchLookaheadTerminal("FLOAT", 0)) || p.matchLookaheadTerminal("FLOAT32", 0)) || p.matchLookaheadTerminal("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("INT32", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("UINT128", 0)) || p.matchLookaheadTerminal("UINT32", 0)) || p.matchLookaheadTerminal("SYMBOL", 0)) } - rel_terms955 := xs952 + rel_terms963 := xs960 p.consumeLiteral(")") - _t1714 := &pb.Primitive{Name: name951, Terms: rel_terms955} - _t1711 = _t1714 + _t1730 := &pb.Primitive{Name: name959, Terms: rel_terms963} + _t1727 = _t1730 } else { - var _t1715 *pb.Primitive - if prediction941 == 8 { - _t1716 := p.parse_divide() - divide950 := _t1716 - _t1715 = divide950 + var _t1731 *pb.Primitive + if prediction949 == 8 { + _t1732 := p.parse_divide() + divide958 := _t1732 + _t1731 = divide958 } else { - var _t1717 *pb.Primitive - if prediction941 == 7 { - _t1718 := p.parse_multiply() - multiply949 := _t1718 - _t1717 = multiply949 + var _t1733 *pb.Primitive + if prediction949 == 7 { + _t1734 := p.parse_multiply() + multiply957 := _t1734 + _t1733 = multiply957 } else { - var _t1719 *pb.Primitive - if prediction941 == 6 { - _t1720 := p.parse_minus() - minus948 := _t1720 - _t1719 = minus948 + var _t1735 *pb.Primitive + if prediction949 == 6 { + _t1736 := p.parse_minus() + minus956 := _t1736 + _t1735 = minus956 } else { - var _t1721 *pb.Primitive - if prediction941 == 5 { - _t1722 := p.parse_add() - add947 := _t1722 - _t1721 = add947 + var _t1737 *pb.Primitive + if prediction949 == 5 { + _t1738 := p.parse_add() + add955 := _t1738 + _t1737 = add955 } else { - var _t1723 *pb.Primitive - if prediction941 == 4 { - _t1724 := p.parse_gt_eq() - gt_eq946 := _t1724 - _t1723 = gt_eq946 + var _t1739 *pb.Primitive + if prediction949 == 4 { + _t1740 := p.parse_gt_eq() + gt_eq954 := _t1740 + _t1739 = gt_eq954 } else { - var _t1725 *pb.Primitive - if prediction941 == 3 { - _t1726 := p.parse_gt() - gt945 := _t1726 - _t1725 = gt945 + var _t1741 *pb.Primitive + if prediction949 == 3 { + _t1742 := p.parse_gt() + gt953 := _t1742 + _t1741 = gt953 } else { - var _t1727 *pb.Primitive - if prediction941 == 2 { - _t1728 := p.parse_lt_eq() - lt_eq944 := _t1728 - _t1727 = lt_eq944 + var _t1743 *pb.Primitive + if prediction949 == 2 { + _t1744 := p.parse_lt_eq() + lt_eq952 := _t1744 + _t1743 = lt_eq952 } else { - var _t1729 *pb.Primitive - if prediction941 == 1 { - _t1730 := p.parse_lt() - lt943 := _t1730 - _t1729 = lt943 + var _t1745 *pb.Primitive + if prediction949 == 1 { + _t1746 := p.parse_lt() + lt951 := _t1746 + _t1745 = lt951 } else { - var _t1731 *pb.Primitive - if prediction941 == 0 { - _t1732 := p.parse_eq() - eq942 := _t1732 - _t1731 = eq942 + var _t1747 *pb.Primitive + if prediction949 == 0 { + _t1748 := p.parse_eq() + eq950 := _t1748 + _t1747 = eq950 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in primitive", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1729 = _t1731 + _t1745 = _t1747 } - _t1727 = _t1729 + _t1743 = _t1745 } - _t1725 = _t1727 + _t1741 = _t1743 } - _t1723 = _t1725 + _t1739 = _t1741 } - _t1721 = _t1723 + _t1737 = _t1739 } - _t1719 = _t1721 + _t1735 = _t1737 } - _t1717 = _t1719 + _t1733 = _t1735 } - _t1715 = _t1717 + _t1731 = _t1733 } - _t1711 = _t1715 + _t1727 = _t1731 } - result957 := _t1711 - p.recordSpan(int(span_start956), "Primitive") - return result957 + result965 := _t1727 + p.recordSpan(int(span_start964), "Primitive") + return result965 } func (p *Parser) parse_eq() *pb.Primitive { - span_start960 := int64(p.spanStart()) + span_start968 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("=") - _t1733 := p.parse_term() - term958 := _t1733 - _t1734 := p.parse_term() - term_3959 := _t1734 + _t1749 := p.parse_term() + term966 := _t1749 + _t1750 := p.parse_term() + term_3967 := _t1750 p.consumeLiteral(")") - _t1735 := &pb.RelTerm{} - _t1735.RelTermType = &pb.RelTerm_Term{Term: term958} - _t1736 := &pb.RelTerm{} - _t1736.RelTermType = &pb.RelTerm_Term{Term: term_3959} - _t1737 := &pb.Primitive{Name: "rel_primitive_eq", Terms: []*pb.RelTerm{_t1735, _t1736}} - result961 := _t1737 - p.recordSpan(int(span_start960), "Primitive") - return result961 + _t1751 := &pb.RelTerm{} + _t1751.RelTermType = &pb.RelTerm_Term{Term: term966} + _t1752 := &pb.RelTerm{} + _t1752.RelTermType = &pb.RelTerm_Term{Term: term_3967} + _t1753 := &pb.Primitive{Name: "rel_primitive_eq", Terms: []*pb.RelTerm{_t1751, _t1752}} + result969 := _t1753 + p.recordSpan(int(span_start968), "Primitive") + return result969 } func (p *Parser) parse_lt() *pb.Primitive { - span_start964 := int64(p.spanStart()) + span_start972 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("<") - _t1738 := p.parse_term() - term962 := _t1738 - _t1739 := p.parse_term() - term_3963 := _t1739 + _t1754 := p.parse_term() + term970 := _t1754 + _t1755 := p.parse_term() + term_3971 := _t1755 p.consumeLiteral(")") - _t1740 := &pb.RelTerm{} - _t1740.RelTermType = &pb.RelTerm_Term{Term: term962} - _t1741 := &pb.RelTerm{} - _t1741.RelTermType = &pb.RelTerm_Term{Term: term_3963} - _t1742 := &pb.Primitive{Name: "rel_primitive_lt_monotype", Terms: []*pb.RelTerm{_t1740, _t1741}} - result965 := _t1742 - p.recordSpan(int(span_start964), "Primitive") - return result965 + _t1756 := &pb.RelTerm{} + _t1756.RelTermType = &pb.RelTerm_Term{Term: term970} + _t1757 := &pb.RelTerm{} + _t1757.RelTermType = &pb.RelTerm_Term{Term: term_3971} + _t1758 := &pb.Primitive{Name: "rel_primitive_lt_monotype", Terms: []*pb.RelTerm{_t1756, _t1757}} + result973 := _t1758 + p.recordSpan(int(span_start972), "Primitive") + return result973 } func (p *Parser) parse_lt_eq() *pb.Primitive { - span_start968 := int64(p.spanStart()) + span_start976 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("<=") - _t1743 := p.parse_term() - term966 := _t1743 - _t1744 := p.parse_term() - term_3967 := _t1744 + _t1759 := p.parse_term() + term974 := _t1759 + _t1760 := p.parse_term() + term_3975 := _t1760 p.consumeLiteral(")") - _t1745 := &pb.RelTerm{} - _t1745.RelTermType = &pb.RelTerm_Term{Term: term966} - _t1746 := &pb.RelTerm{} - _t1746.RelTermType = &pb.RelTerm_Term{Term: term_3967} - _t1747 := &pb.Primitive{Name: "rel_primitive_lt_eq_monotype", Terms: []*pb.RelTerm{_t1745, _t1746}} - result969 := _t1747 - p.recordSpan(int(span_start968), "Primitive") - return result969 + _t1761 := &pb.RelTerm{} + _t1761.RelTermType = &pb.RelTerm_Term{Term: term974} + _t1762 := &pb.RelTerm{} + _t1762.RelTermType = &pb.RelTerm_Term{Term: term_3975} + _t1763 := &pb.Primitive{Name: "rel_primitive_lt_eq_monotype", Terms: []*pb.RelTerm{_t1761, _t1762}} + result977 := _t1763 + p.recordSpan(int(span_start976), "Primitive") + return result977 } func (p *Parser) parse_gt() *pb.Primitive { - span_start972 := int64(p.spanStart()) + span_start980 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral(">") - _t1748 := p.parse_term() - term970 := _t1748 - _t1749 := p.parse_term() - term_3971 := _t1749 + _t1764 := p.parse_term() + term978 := _t1764 + _t1765 := p.parse_term() + term_3979 := _t1765 p.consumeLiteral(")") - _t1750 := &pb.RelTerm{} - _t1750.RelTermType = &pb.RelTerm_Term{Term: term970} - _t1751 := &pb.RelTerm{} - _t1751.RelTermType = &pb.RelTerm_Term{Term: term_3971} - _t1752 := &pb.Primitive{Name: "rel_primitive_gt_monotype", Terms: []*pb.RelTerm{_t1750, _t1751}} - result973 := _t1752 - p.recordSpan(int(span_start972), "Primitive") - return result973 + _t1766 := &pb.RelTerm{} + _t1766.RelTermType = &pb.RelTerm_Term{Term: term978} + _t1767 := &pb.RelTerm{} + _t1767.RelTermType = &pb.RelTerm_Term{Term: term_3979} + _t1768 := &pb.Primitive{Name: "rel_primitive_gt_monotype", Terms: []*pb.RelTerm{_t1766, _t1767}} + result981 := _t1768 + p.recordSpan(int(span_start980), "Primitive") + return result981 } func (p *Parser) parse_gt_eq() *pb.Primitive { - span_start976 := int64(p.spanStart()) + span_start984 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral(">=") - _t1753 := p.parse_term() - term974 := _t1753 - _t1754 := p.parse_term() - term_3975 := _t1754 + _t1769 := p.parse_term() + term982 := _t1769 + _t1770 := p.parse_term() + term_3983 := _t1770 p.consumeLiteral(")") - _t1755 := &pb.RelTerm{} - _t1755.RelTermType = &pb.RelTerm_Term{Term: term974} - _t1756 := &pb.RelTerm{} - _t1756.RelTermType = &pb.RelTerm_Term{Term: term_3975} - _t1757 := &pb.Primitive{Name: "rel_primitive_gt_eq_monotype", Terms: []*pb.RelTerm{_t1755, _t1756}} - result977 := _t1757 - p.recordSpan(int(span_start976), "Primitive") - return result977 + _t1771 := &pb.RelTerm{} + _t1771.RelTermType = &pb.RelTerm_Term{Term: term982} + _t1772 := &pb.RelTerm{} + _t1772.RelTermType = &pb.RelTerm_Term{Term: term_3983} + _t1773 := &pb.Primitive{Name: "rel_primitive_gt_eq_monotype", Terms: []*pb.RelTerm{_t1771, _t1772}} + result985 := _t1773 + p.recordSpan(int(span_start984), "Primitive") + return result985 } func (p *Parser) parse_add() *pb.Primitive { - span_start981 := int64(p.spanStart()) + span_start989 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("+") - _t1758 := p.parse_term() - term978 := _t1758 - _t1759 := p.parse_term() - term_3979 := _t1759 - _t1760 := p.parse_term() - term_4980 := _t1760 + _t1774 := p.parse_term() + term986 := _t1774 + _t1775 := p.parse_term() + term_3987 := _t1775 + _t1776 := p.parse_term() + term_4988 := _t1776 p.consumeLiteral(")") - _t1761 := &pb.RelTerm{} - _t1761.RelTermType = &pb.RelTerm_Term{Term: term978} - _t1762 := &pb.RelTerm{} - _t1762.RelTermType = &pb.RelTerm_Term{Term: term_3979} - _t1763 := &pb.RelTerm{} - _t1763.RelTermType = &pb.RelTerm_Term{Term: term_4980} - _t1764 := &pb.Primitive{Name: "rel_primitive_add_monotype", Terms: []*pb.RelTerm{_t1761, _t1762, _t1763}} - result982 := _t1764 - p.recordSpan(int(span_start981), "Primitive") - return result982 + _t1777 := &pb.RelTerm{} + _t1777.RelTermType = &pb.RelTerm_Term{Term: term986} + _t1778 := &pb.RelTerm{} + _t1778.RelTermType = &pb.RelTerm_Term{Term: term_3987} + _t1779 := &pb.RelTerm{} + _t1779.RelTermType = &pb.RelTerm_Term{Term: term_4988} + _t1780 := &pb.Primitive{Name: "rel_primitive_add_monotype", Terms: []*pb.RelTerm{_t1777, _t1778, _t1779}} + result990 := _t1780 + p.recordSpan(int(span_start989), "Primitive") + return result990 } func (p *Parser) parse_minus() *pb.Primitive { - span_start986 := int64(p.spanStart()) + span_start994 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("-") - _t1765 := p.parse_term() - term983 := _t1765 - _t1766 := p.parse_term() - term_3984 := _t1766 - _t1767 := p.parse_term() - term_4985 := _t1767 + _t1781 := p.parse_term() + term991 := _t1781 + _t1782 := p.parse_term() + term_3992 := _t1782 + _t1783 := p.parse_term() + term_4993 := _t1783 p.consumeLiteral(")") - _t1768 := &pb.RelTerm{} - _t1768.RelTermType = &pb.RelTerm_Term{Term: term983} - _t1769 := &pb.RelTerm{} - _t1769.RelTermType = &pb.RelTerm_Term{Term: term_3984} - _t1770 := &pb.RelTerm{} - _t1770.RelTermType = &pb.RelTerm_Term{Term: term_4985} - _t1771 := &pb.Primitive{Name: "rel_primitive_subtract_monotype", Terms: []*pb.RelTerm{_t1768, _t1769, _t1770}} - result987 := _t1771 - p.recordSpan(int(span_start986), "Primitive") - return result987 + _t1784 := &pb.RelTerm{} + _t1784.RelTermType = &pb.RelTerm_Term{Term: term991} + _t1785 := &pb.RelTerm{} + _t1785.RelTermType = &pb.RelTerm_Term{Term: term_3992} + _t1786 := &pb.RelTerm{} + _t1786.RelTermType = &pb.RelTerm_Term{Term: term_4993} + _t1787 := &pb.Primitive{Name: "rel_primitive_subtract_monotype", Terms: []*pb.RelTerm{_t1784, _t1785, _t1786}} + result995 := _t1787 + p.recordSpan(int(span_start994), "Primitive") + return result995 } func (p *Parser) parse_multiply() *pb.Primitive { - span_start991 := int64(p.spanStart()) + span_start999 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("*") - _t1772 := p.parse_term() - term988 := _t1772 - _t1773 := p.parse_term() - term_3989 := _t1773 - _t1774 := p.parse_term() - term_4990 := _t1774 + _t1788 := p.parse_term() + term996 := _t1788 + _t1789 := p.parse_term() + term_3997 := _t1789 + _t1790 := p.parse_term() + term_4998 := _t1790 p.consumeLiteral(")") - _t1775 := &pb.RelTerm{} - _t1775.RelTermType = &pb.RelTerm_Term{Term: term988} - _t1776 := &pb.RelTerm{} - _t1776.RelTermType = &pb.RelTerm_Term{Term: term_3989} - _t1777 := &pb.RelTerm{} - _t1777.RelTermType = &pb.RelTerm_Term{Term: term_4990} - _t1778 := &pb.Primitive{Name: "rel_primitive_multiply_monotype", Terms: []*pb.RelTerm{_t1775, _t1776, _t1777}} - result992 := _t1778 - p.recordSpan(int(span_start991), "Primitive") - return result992 + _t1791 := &pb.RelTerm{} + _t1791.RelTermType = &pb.RelTerm_Term{Term: term996} + _t1792 := &pb.RelTerm{} + _t1792.RelTermType = &pb.RelTerm_Term{Term: term_3997} + _t1793 := &pb.RelTerm{} + _t1793.RelTermType = &pb.RelTerm_Term{Term: term_4998} + _t1794 := &pb.Primitive{Name: "rel_primitive_multiply_monotype", Terms: []*pb.RelTerm{_t1791, _t1792, _t1793}} + result1000 := _t1794 + p.recordSpan(int(span_start999), "Primitive") + return result1000 } func (p *Parser) parse_divide() *pb.Primitive { - span_start996 := int64(p.spanStart()) + span_start1004 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("/") - _t1779 := p.parse_term() - term993 := _t1779 - _t1780 := p.parse_term() - term_3994 := _t1780 - _t1781 := p.parse_term() - term_4995 := _t1781 + _t1795 := p.parse_term() + term1001 := _t1795 + _t1796 := p.parse_term() + term_31002 := _t1796 + _t1797 := p.parse_term() + term_41003 := _t1797 p.consumeLiteral(")") - _t1782 := &pb.RelTerm{} - _t1782.RelTermType = &pb.RelTerm_Term{Term: term993} - _t1783 := &pb.RelTerm{} - _t1783.RelTermType = &pb.RelTerm_Term{Term: term_3994} - _t1784 := &pb.RelTerm{} - _t1784.RelTermType = &pb.RelTerm_Term{Term: term_4995} - _t1785 := &pb.Primitive{Name: "rel_primitive_divide_monotype", Terms: []*pb.RelTerm{_t1782, _t1783, _t1784}} - result997 := _t1785 - p.recordSpan(int(span_start996), "Primitive") - return result997 + _t1798 := &pb.RelTerm{} + _t1798.RelTermType = &pb.RelTerm_Term{Term: term1001} + _t1799 := &pb.RelTerm{} + _t1799.RelTermType = &pb.RelTerm_Term{Term: term_31002} + _t1800 := &pb.RelTerm{} + _t1800.RelTermType = &pb.RelTerm_Term{Term: term_41003} + _t1801 := &pb.Primitive{Name: "rel_primitive_divide_monotype", Terms: []*pb.RelTerm{_t1798, _t1799, _t1800}} + result1005 := _t1801 + p.recordSpan(int(span_start1004), "Primitive") + return result1005 } func (p *Parser) parse_rel_term() *pb.RelTerm { - span_start1001 := int64(p.spanStart()) - var _t1786 int64 + span_start1009 := int64(p.spanStart()) + var _t1802 int64 if p.matchLookaheadLiteral("true", 0) { - _t1786 = 1 + _t1802 = 1 } else { - var _t1787 int64 + var _t1803 int64 if p.matchLookaheadLiteral("missing", 0) { - _t1787 = 1 + _t1803 = 1 } else { - var _t1788 int64 + var _t1804 int64 if p.matchLookaheadLiteral("false", 0) { - _t1788 = 1 + _t1804 = 1 } else { - var _t1789 int64 + var _t1805 int64 if p.matchLookaheadLiteral("(", 0) { - _t1789 = 1 + _t1805 = 1 } else { - var _t1790 int64 + var _t1806 int64 if p.matchLookaheadLiteral("#", 0) { - _t1790 = 0 + _t1806 = 0 } else { - var _t1791 int64 + var _t1807 int64 if p.matchLookaheadTerminal("SYMBOL", 0) { - _t1791 = 1 + _t1807 = 1 } else { - var _t1792 int64 + var _t1808 int64 if p.matchLookaheadTerminal("UINT32", 0) { - _t1792 = 1 + _t1808 = 1 } else { - var _t1793 int64 + var _t1809 int64 if p.matchLookaheadTerminal("UINT128", 0) { - _t1793 = 1 + _t1809 = 1 } else { - var _t1794 int64 + var _t1810 int64 if p.matchLookaheadTerminal("STRING", 0) { - _t1794 = 1 + _t1810 = 1 } else { - var _t1795 int64 + var _t1811 int64 if p.matchLookaheadTerminal("INT32", 0) { - _t1795 = 1 + _t1811 = 1 } else { - var _t1796 int64 + var _t1812 int64 if p.matchLookaheadTerminal("INT128", 0) { - _t1796 = 1 + _t1812 = 1 } else { - var _t1797 int64 + var _t1813 int64 if p.matchLookaheadTerminal("INT", 0) { - _t1797 = 1 + _t1813 = 1 } else { - var _t1798 int64 + var _t1814 int64 if p.matchLookaheadTerminal("FLOAT32", 0) { - _t1798 = 1 + _t1814 = 1 } else { - var _t1799 int64 + var _t1815 int64 if p.matchLookaheadTerminal("FLOAT", 0) { - _t1799 = 1 + _t1815 = 1 } else { - var _t1800 int64 + var _t1816 int64 if p.matchLookaheadTerminal("DECIMAL", 0) { - _t1800 = 1 + _t1816 = 1 } else { - _t1800 = -1 + _t1816 = -1 } - _t1799 = _t1800 + _t1815 = _t1816 } - _t1798 = _t1799 + _t1814 = _t1815 } - _t1797 = _t1798 + _t1813 = _t1814 } - _t1796 = _t1797 + _t1812 = _t1813 } - _t1795 = _t1796 + _t1811 = _t1812 } - _t1794 = _t1795 + _t1810 = _t1811 } - _t1793 = _t1794 + _t1809 = _t1810 } - _t1792 = _t1793 + _t1808 = _t1809 } - _t1791 = _t1792 + _t1807 = _t1808 } - _t1790 = _t1791 + _t1806 = _t1807 } - _t1789 = _t1790 + _t1805 = _t1806 } - _t1788 = _t1789 + _t1804 = _t1805 } - _t1787 = _t1788 + _t1803 = _t1804 } - _t1786 = _t1787 - } - prediction998 := _t1786 - var _t1801 *pb.RelTerm - if prediction998 == 1 { - _t1802 := p.parse_term() - term1000 := _t1802 - _t1803 := &pb.RelTerm{} - _t1803.RelTermType = &pb.RelTerm_Term{Term: term1000} - _t1801 = _t1803 + _t1802 = _t1803 + } + prediction1006 := _t1802 + var _t1817 *pb.RelTerm + if prediction1006 == 1 { + _t1818 := p.parse_term() + term1008 := _t1818 + _t1819 := &pb.RelTerm{} + _t1819.RelTermType = &pb.RelTerm_Term{Term: term1008} + _t1817 = _t1819 } else { - var _t1804 *pb.RelTerm - if prediction998 == 0 { - _t1805 := p.parse_specialized_value() - specialized_value999 := _t1805 - _t1806 := &pb.RelTerm{} - _t1806.RelTermType = &pb.RelTerm_SpecializedValue{SpecializedValue: specialized_value999} - _t1804 = _t1806 + var _t1820 *pb.RelTerm + if prediction1006 == 0 { + _t1821 := p.parse_specialized_value() + specialized_value1007 := _t1821 + _t1822 := &pb.RelTerm{} + _t1822.RelTermType = &pb.RelTerm_SpecializedValue{SpecializedValue: specialized_value1007} + _t1820 = _t1822 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in rel_term", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1801 = _t1804 + _t1817 = _t1820 } - result1002 := _t1801 - p.recordSpan(int(span_start1001), "RelTerm") - return result1002 + result1010 := _t1817 + p.recordSpan(int(span_start1009), "RelTerm") + return result1010 } func (p *Parser) parse_specialized_value() *pb.Value { - span_start1004 := int64(p.spanStart()) + span_start1012 := int64(p.spanStart()) p.consumeLiteral("#") - _t1807 := p.parse_raw_value() - raw_value1003 := _t1807 - result1005 := raw_value1003 - p.recordSpan(int(span_start1004), "Value") - return result1005 + _t1823 := p.parse_raw_value() + raw_value1011 := _t1823 + result1013 := raw_value1011 + p.recordSpan(int(span_start1012), "Value") + return result1013 } func (p *Parser) parse_rel_atom() *pb.RelAtom { - span_start1011 := int64(p.spanStart()) + span_start1019 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("relatom") - _t1808 := p.parse_name() - name1006 := _t1808 - xs1007 := []*pb.RelTerm{} - cond1008 := ((((((((((((((p.matchLookaheadLiteral("#", 0) || p.matchLookaheadLiteral("(", 0)) || p.matchLookaheadLiteral("false", 0)) || p.matchLookaheadLiteral("missing", 0)) || p.matchLookaheadLiteral("true", 0)) || p.matchLookaheadTerminal("DECIMAL", 0)) || p.matchLookaheadTerminal("FLOAT", 0)) || p.matchLookaheadTerminal("FLOAT32", 0)) || p.matchLookaheadTerminal("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("INT32", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("UINT128", 0)) || p.matchLookaheadTerminal("UINT32", 0)) || p.matchLookaheadTerminal("SYMBOL", 0)) - for cond1008 { - _t1809 := p.parse_rel_term() - item1009 := _t1809 - xs1007 = append(xs1007, item1009) - cond1008 = ((((((((((((((p.matchLookaheadLiteral("#", 0) || p.matchLookaheadLiteral("(", 0)) || p.matchLookaheadLiteral("false", 0)) || p.matchLookaheadLiteral("missing", 0)) || p.matchLookaheadLiteral("true", 0)) || p.matchLookaheadTerminal("DECIMAL", 0)) || p.matchLookaheadTerminal("FLOAT", 0)) || p.matchLookaheadTerminal("FLOAT32", 0)) || p.matchLookaheadTerminal("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("INT32", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("UINT128", 0)) || p.matchLookaheadTerminal("UINT32", 0)) || p.matchLookaheadTerminal("SYMBOL", 0)) - } - rel_terms1010 := xs1007 + _t1824 := p.parse_name() + name1014 := _t1824 + xs1015 := []*pb.RelTerm{} + cond1016 := ((((((((((((((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 cond1016 { + _t1825 := p.parse_rel_term() + item1017 := _t1825 + xs1015 = append(xs1015, item1017) + cond1016 = ((((((((((((((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_terms1018 := xs1015 p.consumeLiteral(")") - _t1810 := &pb.RelAtom{Name: name1006, Terms: rel_terms1010} - result1012 := _t1810 - p.recordSpan(int(span_start1011), "RelAtom") - return result1012 + _t1826 := &pb.RelAtom{Name: name1014, Terms: rel_terms1018} + result1020 := _t1826 + p.recordSpan(int(span_start1019), "RelAtom") + return result1020 } func (p *Parser) parse_cast() *pb.Cast { - span_start1015 := int64(p.spanStart()) + span_start1023 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("cast") - _t1811 := p.parse_term() - term1013 := _t1811 - _t1812 := p.parse_term() - term_31014 := _t1812 + _t1827 := p.parse_term() + term1021 := _t1827 + _t1828 := p.parse_term() + term_31022 := _t1828 p.consumeLiteral(")") - _t1813 := &pb.Cast{Input: term1013, Result: term_31014} - result1016 := _t1813 - p.recordSpan(int(span_start1015), "Cast") - return result1016 + _t1829 := &pb.Cast{Input: term1021, Result: term_31022} + result1024 := _t1829 + p.recordSpan(int(span_start1023), "Cast") + return result1024 } func (p *Parser) parse_attrs() []*pb.Attribute { p.consumeLiteral("(") p.consumeLiteral("attrs") - xs1017 := []*pb.Attribute{} - cond1018 := p.matchLookaheadLiteral("(", 0) - for cond1018 { - _t1814 := p.parse_attribute() - item1019 := _t1814 - xs1017 = append(xs1017, item1019) - cond1018 = p.matchLookaheadLiteral("(", 0) - } - attributes1020 := xs1017 + xs1025 := []*pb.Attribute{} + cond1026 := p.matchLookaheadLiteral("(", 0) + for cond1026 { + _t1830 := p.parse_attribute() + item1027 := _t1830 + xs1025 = append(xs1025, item1027) + cond1026 = p.matchLookaheadLiteral("(", 0) + } + attributes1028 := xs1025 p.consumeLiteral(")") - return attributes1020 + return attributes1028 } func (p *Parser) parse_attribute() *pb.Attribute { - span_start1026 := int64(p.spanStart()) + span_start1034 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("attribute") - _t1815 := p.parse_name() - name1021 := _t1815 - xs1022 := []*pb.Value{} - cond1023 := ((((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("false", 0)) || p.matchLookaheadLiteral("missing", 0)) || p.matchLookaheadLiteral("true", 0)) || p.matchLookaheadTerminal("DECIMAL", 0)) || p.matchLookaheadTerminal("FLOAT", 0)) || p.matchLookaheadTerminal("FLOAT32", 0)) || p.matchLookaheadTerminal("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("INT32", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("UINT128", 0)) || p.matchLookaheadTerminal("UINT32", 0)) - for cond1023 { - _t1816 := p.parse_raw_value() - item1024 := _t1816 - xs1022 = append(xs1022, item1024) - cond1023 = ((((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("false", 0)) || p.matchLookaheadLiteral("missing", 0)) || p.matchLookaheadLiteral("true", 0)) || p.matchLookaheadTerminal("DECIMAL", 0)) || p.matchLookaheadTerminal("FLOAT", 0)) || p.matchLookaheadTerminal("FLOAT32", 0)) || p.matchLookaheadTerminal("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("INT32", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("UINT128", 0)) || p.matchLookaheadTerminal("UINT32", 0)) - } - raw_values1025 := xs1022 + _t1831 := p.parse_name() + name1029 := _t1831 + xs1030 := []*pb.Value{} + cond1031 := ((((((((((((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 cond1031 { + _t1832 := p.parse_raw_value() + item1032 := _t1832 + xs1030 = append(xs1030, item1032) + cond1031 = ((((((((((((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_values1033 := xs1030 p.consumeLiteral(")") - _t1817 := &pb.Attribute{Name: name1021, Args: raw_values1025} - result1027 := _t1817 - p.recordSpan(int(span_start1026), "Attribute") - return result1027 + _t1833 := &pb.Attribute{Name: name1029, Args: raw_values1033} + result1035 := _t1833 + p.recordSpan(int(span_start1034), "Attribute") + return result1035 } func (p *Parser) parse_algorithm() *pb.Algorithm { - span_start1034 := int64(p.spanStart()) + span_start1042 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("algorithm") - xs1028 := []*pb.RelationId{} - cond1029 := (p.matchLookaheadLiteral(":", 0) || p.matchLookaheadTerminal("UINT128", 0)) - for cond1029 { - _t1818 := p.parse_relation_id() - item1030 := _t1818 - xs1028 = append(xs1028, item1030) - cond1029 = (p.matchLookaheadLiteral(":", 0) || p.matchLookaheadTerminal("UINT128", 0)) - } - relation_ids1031 := xs1028 - _t1819 := p.parse_script() - script1032 := _t1819 - var _t1820 []*pb.Attribute + xs1036 := []*pb.RelationId{} + cond1037 := (p.matchLookaheadLiteral(":", 0) || p.matchLookaheadTerminal("UINT128", 0)) + for cond1037 { + _t1834 := p.parse_relation_id() + item1038 := _t1834 + xs1036 = append(xs1036, item1038) + cond1037 = (p.matchLookaheadLiteral(":", 0) || p.matchLookaheadTerminal("UINT128", 0)) + } + relation_ids1039 := xs1036 + _t1835 := p.parse_script() + script1040 := _t1835 + var _t1836 []*pb.Attribute if p.matchLookaheadLiteral("(", 0) { - _t1821 := p.parse_attrs() - _t1820 = _t1821 + _t1837 := p.parse_attrs() + _t1836 = _t1837 } - attrs1033 := _t1820 + attrs1041 := _t1836 p.consumeLiteral(")") - _t1822 := attrs1033 - if attrs1033 == nil { - _t1822 = []*pb.Attribute{} + _t1838 := attrs1041 + if attrs1041 == nil { + _t1838 = []*pb.Attribute{} } - _t1823 := &pb.Algorithm{Global: relation_ids1031, Body: script1032, Attrs: _t1822} - result1035 := _t1823 - p.recordSpan(int(span_start1034), "Algorithm") - return result1035 + _t1839 := &pb.Algorithm{Global: relation_ids1039, Body: script1040, Attrs: _t1838} + result1043 := _t1839 + p.recordSpan(int(span_start1042), "Algorithm") + return result1043 } func (p *Parser) parse_script() *pb.Script { - span_start1040 := int64(p.spanStart()) + span_start1048 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("script") - xs1036 := []*pb.Construct{} - cond1037 := p.matchLookaheadLiteral("(", 0) - for cond1037 { - _t1824 := p.parse_construct() - item1038 := _t1824 - xs1036 = append(xs1036, item1038) - cond1037 = p.matchLookaheadLiteral("(", 0) - } - constructs1039 := xs1036 + xs1044 := []*pb.Construct{} + cond1045 := p.matchLookaheadLiteral("(", 0) + for cond1045 { + _t1840 := p.parse_construct() + item1046 := _t1840 + xs1044 = append(xs1044, item1046) + cond1045 = p.matchLookaheadLiteral("(", 0) + } + constructs1047 := xs1044 p.consumeLiteral(")") - _t1825 := &pb.Script{Constructs: constructs1039} - result1041 := _t1825 - p.recordSpan(int(span_start1040), "Script") - return result1041 + _t1841 := &pb.Script{Constructs: constructs1047} + result1049 := _t1841 + p.recordSpan(int(span_start1048), "Script") + return result1049 } func (p *Parser) parse_construct() *pb.Construct { - span_start1045 := int64(p.spanStart()) - var _t1826 int64 + span_start1053 := int64(p.spanStart()) + var _t1842 int64 if p.matchLookaheadLiteral("(", 0) { - var _t1827 int64 + var _t1843 int64 if p.matchLookaheadLiteral("upsert", 1) { - _t1827 = 1 + _t1843 = 1 } else { - var _t1828 int64 + var _t1844 int64 if p.matchLookaheadLiteral("monus", 1) { - _t1828 = 1 + _t1844 = 1 } else { - var _t1829 int64 + var _t1845 int64 if p.matchLookaheadLiteral("monoid", 1) { - _t1829 = 1 + _t1845 = 1 } else { - var _t1830 int64 + var _t1846 int64 if p.matchLookaheadLiteral("loop", 1) { - _t1830 = 0 + _t1846 = 0 } else { - var _t1831 int64 + var _t1847 int64 if p.matchLookaheadLiteral("break", 1) { - _t1831 = 1 + _t1847 = 1 } else { - var _t1832 int64 + var _t1848 int64 if p.matchLookaheadLiteral("assign", 1) { - _t1832 = 1 + _t1848 = 1 } else { - _t1832 = -1 + _t1848 = -1 } - _t1831 = _t1832 + _t1847 = _t1848 } - _t1830 = _t1831 + _t1846 = _t1847 } - _t1829 = _t1830 + _t1845 = _t1846 } - _t1828 = _t1829 + _t1844 = _t1845 } - _t1827 = _t1828 + _t1843 = _t1844 } - _t1826 = _t1827 + _t1842 = _t1843 } else { - _t1826 = -1 - } - prediction1042 := _t1826 - var _t1833 *pb.Construct - if prediction1042 == 1 { - _t1834 := p.parse_instruction() - instruction1044 := _t1834 - _t1835 := &pb.Construct{} - _t1835.ConstructType = &pb.Construct_Instruction{Instruction: instruction1044} - _t1833 = _t1835 + _t1842 = -1 + } + prediction1050 := _t1842 + var _t1849 *pb.Construct + if prediction1050 == 1 { + _t1850 := p.parse_instruction() + instruction1052 := _t1850 + _t1851 := &pb.Construct{} + _t1851.ConstructType = &pb.Construct_Instruction{Instruction: instruction1052} + _t1849 = _t1851 } else { - var _t1836 *pb.Construct - if prediction1042 == 0 { - _t1837 := p.parse_loop() - loop1043 := _t1837 - _t1838 := &pb.Construct{} - _t1838.ConstructType = &pb.Construct_Loop{Loop: loop1043} - _t1836 = _t1838 + var _t1852 *pb.Construct + if prediction1050 == 0 { + _t1853 := p.parse_loop() + loop1051 := _t1853 + _t1854 := &pb.Construct{} + _t1854.ConstructType = &pb.Construct_Loop{Loop: loop1051} + _t1852 = _t1854 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in construct", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1833 = _t1836 + _t1849 = _t1852 } - result1046 := _t1833 - p.recordSpan(int(span_start1045), "Construct") - return result1046 + result1054 := _t1849 + p.recordSpan(int(span_start1053), "Construct") + return result1054 } func (p *Parser) parse_loop() *pb.Loop { - span_start1050 := int64(p.spanStart()) + span_start1058 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("loop") - _t1839 := p.parse_init() - init1047 := _t1839 - _t1840 := p.parse_script() - script1048 := _t1840 - var _t1841 []*pb.Attribute + _t1855 := p.parse_init() + init1055 := _t1855 + _t1856 := p.parse_script() + script1056 := _t1856 + var _t1857 []*pb.Attribute if p.matchLookaheadLiteral("(", 0) { - _t1842 := p.parse_attrs() - _t1841 = _t1842 + _t1858 := p.parse_attrs() + _t1857 = _t1858 } - attrs1049 := _t1841 + attrs1057 := _t1857 p.consumeLiteral(")") - _t1843 := attrs1049 - if attrs1049 == nil { - _t1843 = []*pb.Attribute{} + _t1859 := attrs1057 + if attrs1057 == nil { + _t1859 = []*pb.Attribute{} } - _t1844 := &pb.Loop{Init: init1047, Body: script1048, Attrs: _t1843} - result1051 := _t1844 - p.recordSpan(int(span_start1050), "Loop") - return result1051 + _t1860 := &pb.Loop{Init: init1055, Body: script1056, Attrs: _t1859} + result1059 := _t1860 + p.recordSpan(int(span_start1058), "Loop") + return result1059 } func (p *Parser) parse_init() []*pb.Instruction { p.consumeLiteral("(") p.consumeLiteral("init") - xs1052 := []*pb.Instruction{} - cond1053 := p.matchLookaheadLiteral("(", 0) - for cond1053 { - _t1845 := p.parse_instruction() - item1054 := _t1845 - xs1052 = append(xs1052, item1054) - cond1053 = p.matchLookaheadLiteral("(", 0) - } - instructions1055 := xs1052 + xs1060 := []*pb.Instruction{} + cond1061 := p.matchLookaheadLiteral("(", 0) + for cond1061 { + _t1861 := p.parse_instruction() + item1062 := _t1861 + xs1060 = append(xs1060, item1062) + cond1061 = p.matchLookaheadLiteral("(", 0) + } + instructions1063 := xs1060 p.consumeLiteral(")") - return instructions1055 + return instructions1063 } func (p *Parser) parse_instruction() *pb.Instruction { - span_start1062 := int64(p.spanStart()) - var _t1846 int64 + span_start1070 := int64(p.spanStart()) + var _t1862 int64 if p.matchLookaheadLiteral("(", 0) { - var _t1847 int64 + var _t1863 int64 if p.matchLookaheadLiteral("upsert", 1) { - _t1847 = 1 + _t1863 = 1 } else { - var _t1848 int64 + var _t1864 int64 if p.matchLookaheadLiteral("monus", 1) { - _t1848 = 4 + _t1864 = 4 } else { - var _t1849 int64 + var _t1865 int64 if p.matchLookaheadLiteral("monoid", 1) { - _t1849 = 3 + _t1865 = 3 } else { - var _t1850 int64 + var _t1866 int64 if p.matchLookaheadLiteral("break", 1) { - _t1850 = 2 + _t1866 = 2 } else { - var _t1851 int64 + var _t1867 int64 if p.matchLookaheadLiteral("assign", 1) { - _t1851 = 0 + _t1867 = 0 } else { - _t1851 = -1 + _t1867 = -1 } - _t1850 = _t1851 + _t1866 = _t1867 } - _t1849 = _t1850 + _t1865 = _t1866 } - _t1848 = _t1849 + _t1864 = _t1865 } - _t1847 = _t1848 + _t1863 = _t1864 } - _t1846 = _t1847 + _t1862 = _t1863 } else { - _t1846 = -1 - } - prediction1056 := _t1846 - var _t1852 *pb.Instruction - if prediction1056 == 4 { - _t1853 := p.parse_monus_def() - monus_def1061 := _t1853 - _t1854 := &pb.Instruction{} - _t1854.InstrType = &pb.Instruction_MonusDef{MonusDef: monus_def1061} - _t1852 = _t1854 + _t1862 = -1 + } + prediction1064 := _t1862 + var _t1868 *pb.Instruction + if prediction1064 == 4 { + _t1869 := p.parse_monus_def() + monus_def1069 := _t1869 + _t1870 := &pb.Instruction{} + _t1870.InstrType = &pb.Instruction_MonusDef{MonusDef: monus_def1069} + _t1868 = _t1870 } else { - var _t1855 *pb.Instruction - if prediction1056 == 3 { - _t1856 := p.parse_monoid_def() - monoid_def1060 := _t1856 - _t1857 := &pb.Instruction{} - _t1857.InstrType = &pb.Instruction_MonoidDef{MonoidDef: monoid_def1060} - _t1855 = _t1857 + var _t1871 *pb.Instruction + if prediction1064 == 3 { + _t1872 := p.parse_monoid_def() + monoid_def1068 := _t1872 + _t1873 := &pb.Instruction{} + _t1873.InstrType = &pb.Instruction_MonoidDef{MonoidDef: monoid_def1068} + _t1871 = _t1873 } else { - var _t1858 *pb.Instruction - if prediction1056 == 2 { - _t1859 := p.parse_break() - break1059 := _t1859 - _t1860 := &pb.Instruction{} - _t1860.InstrType = &pb.Instruction_Break{Break: break1059} - _t1858 = _t1860 + var _t1874 *pb.Instruction + if prediction1064 == 2 { + _t1875 := p.parse_break() + break1067 := _t1875 + _t1876 := &pb.Instruction{} + _t1876.InstrType = &pb.Instruction_Break{Break: break1067} + _t1874 = _t1876 } else { - var _t1861 *pb.Instruction - if prediction1056 == 1 { - _t1862 := p.parse_upsert() - upsert1058 := _t1862 - _t1863 := &pb.Instruction{} - _t1863.InstrType = &pb.Instruction_Upsert{Upsert: upsert1058} - _t1861 = _t1863 + var _t1877 *pb.Instruction + if prediction1064 == 1 { + _t1878 := p.parse_upsert() + upsert1066 := _t1878 + _t1879 := &pb.Instruction{} + _t1879.InstrType = &pb.Instruction_Upsert{Upsert: upsert1066} + _t1877 = _t1879 } else { - var _t1864 *pb.Instruction - if prediction1056 == 0 { - _t1865 := p.parse_assign() - assign1057 := _t1865 - _t1866 := &pb.Instruction{} - _t1866.InstrType = &pb.Instruction_Assign{Assign: assign1057} - _t1864 = _t1866 + var _t1880 *pb.Instruction + if prediction1064 == 0 { + _t1881 := p.parse_assign() + assign1065 := _t1881 + _t1882 := &pb.Instruction{} + _t1882.InstrType = &pb.Instruction_Assign{Assign: assign1065} + _t1880 = _t1882 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in instruction", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1861 = _t1864 + _t1877 = _t1880 } - _t1858 = _t1861 + _t1874 = _t1877 } - _t1855 = _t1858 + _t1871 = _t1874 } - _t1852 = _t1855 + _t1868 = _t1871 } - result1063 := _t1852 - p.recordSpan(int(span_start1062), "Instruction") - return result1063 + result1071 := _t1868 + p.recordSpan(int(span_start1070), "Instruction") + return result1071 } func (p *Parser) parse_assign() *pb.Assign { - span_start1067 := int64(p.spanStart()) + span_start1075 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("assign") - _t1867 := p.parse_relation_id() - relation_id1064 := _t1867 - _t1868 := p.parse_abstraction() - abstraction1065 := _t1868 - var _t1869 []*pb.Attribute + _t1883 := p.parse_relation_id() + relation_id1072 := _t1883 + _t1884 := p.parse_abstraction() + abstraction1073 := _t1884 + var _t1885 []*pb.Attribute if p.matchLookaheadLiteral("(", 0) { - _t1870 := p.parse_attrs() - _t1869 = _t1870 + _t1886 := p.parse_attrs() + _t1885 = _t1886 } - attrs1066 := _t1869 + attrs1074 := _t1885 p.consumeLiteral(")") - _t1871 := attrs1066 - if attrs1066 == nil { - _t1871 = []*pb.Attribute{} + _t1887 := attrs1074 + if attrs1074 == nil { + _t1887 = []*pb.Attribute{} } - _t1872 := &pb.Assign{Name: relation_id1064, Body: abstraction1065, Attrs: _t1871} - result1068 := _t1872 - p.recordSpan(int(span_start1067), "Assign") - return result1068 + _t1888 := &pb.Assign{Name: relation_id1072, Body: abstraction1073, Attrs: _t1887} + result1076 := _t1888 + p.recordSpan(int(span_start1075), "Assign") + return result1076 } func (p *Parser) parse_upsert() *pb.Upsert { - span_start1072 := int64(p.spanStart()) + span_start1080 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("upsert") - _t1873 := p.parse_relation_id() - relation_id1069 := _t1873 - _t1874 := p.parse_abstraction_with_arity() - abstraction_with_arity1070 := _t1874 - var _t1875 []*pb.Attribute + _t1889 := p.parse_relation_id() + relation_id1077 := _t1889 + _t1890 := p.parse_abstraction_with_arity() + abstraction_with_arity1078 := _t1890 + var _t1891 []*pb.Attribute if p.matchLookaheadLiteral("(", 0) { - _t1876 := p.parse_attrs() - _t1875 = _t1876 + _t1892 := p.parse_attrs() + _t1891 = _t1892 } - attrs1071 := _t1875 + attrs1079 := _t1891 p.consumeLiteral(")") - _t1877 := attrs1071 - if attrs1071 == nil { - _t1877 = []*pb.Attribute{} + _t1893 := attrs1079 + if attrs1079 == nil { + _t1893 = []*pb.Attribute{} } - _t1878 := &pb.Upsert{Name: relation_id1069, Body: abstraction_with_arity1070[0].(*pb.Abstraction), Attrs: _t1877, ValueArity: abstraction_with_arity1070[1].(int64)} - result1073 := _t1878 - p.recordSpan(int(span_start1072), "Upsert") - return result1073 + _t1894 := &pb.Upsert{Name: relation_id1077, Body: abstraction_with_arity1078[0].(*pb.Abstraction), Attrs: _t1893, ValueArity: abstraction_with_arity1078[1].(int64)} + result1081 := _t1894 + p.recordSpan(int(span_start1080), "Upsert") + return result1081 } func (p *Parser) parse_abstraction_with_arity() []interface{} { p.consumeLiteral("(") - _t1879 := p.parse_bindings() - bindings1074 := _t1879 - _t1880 := p.parse_formula() - formula1075 := _t1880 + _t1895 := p.parse_bindings() + bindings1082 := _t1895 + _t1896 := p.parse_formula() + formula1083 := _t1896 p.consumeLiteral(")") - _t1881 := &pb.Abstraction{Vars: listConcat(bindings1074[0].([]*pb.Binding), bindings1074[1].([]*pb.Binding)), Value: formula1075} - return []interface{}{_t1881, int64(len(bindings1074[1].([]*pb.Binding)))} + _t1897 := &pb.Abstraction{Vars: listConcat(bindings1082[0].([]*pb.Binding), bindings1082[1].([]*pb.Binding)), Value: formula1083} + return []interface{}{_t1897, int64(len(bindings1082[1].([]*pb.Binding)))} } func (p *Parser) parse_break() *pb.Break { - span_start1079 := int64(p.spanStart()) + span_start1087 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("break") - _t1882 := p.parse_relation_id() - relation_id1076 := _t1882 - _t1883 := p.parse_abstraction() - abstraction1077 := _t1883 - var _t1884 []*pb.Attribute + _t1898 := p.parse_relation_id() + relation_id1084 := _t1898 + _t1899 := p.parse_abstraction() + abstraction1085 := _t1899 + var _t1900 []*pb.Attribute if p.matchLookaheadLiteral("(", 0) { - _t1885 := p.parse_attrs() - _t1884 = _t1885 + _t1901 := p.parse_attrs() + _t1900 = _t1901 } - attrs1078 := _t1884 + attrs1086 := _t1900 p.consumeLiteral(")") - _t1886 := attrs1078 - if attrs1078 == nil { - _t1886 = []*pb.Attribute{} + _t1902 := attrs1086 + if attrs1086 == nil { + _t1902 = []*pb.Attribute{} } - _t1887 := &pb.Break{Name: relation_id1076, Body: abstraction1077, Attrs: _t1886} - result1080 := _t1887 - p.recordSpan(int(span_start1079), "Break") - return result1080 + _t1903 := &pb.Break{Name: relation_id1084, Body: abstraction1085, Attrs: _t1902} + result1088 := _t1903 + p.recordSpan(int(span_start1087), "Break") + return result1088 } func (p *Parser) parse_monoid_def() *pb.MonoidDef { - span_start1085 := int64(p.spanStart()) + span_start1093 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("monoid") - _t1888 := p.parse_monoid() - monoid1081 := _t1888 - _t1889 := p.parse_relation_id() - relation_id1082 := _t1889 - _t1890 := p.parse_abstraction_with_arity() - abstraction_with_arity1083 := _t1890 - var _t1891 []*pb.Attribute + _t1904 := p.parse_monoid() + monoid1089 := _t1904 + _t1905 := p.parse_relation_id() + relation_id1090 := _t1905 + _t1906 := p.parse_abstraction_with_arity() + abstraction_with_arity1091 := _t1906 + var _t1907 []*pb.Attribute if p.matchLookaheadLiteral("(", 0) { - _t1892 := p.parse_attrs() - _t1891 = _t1892 + _t1908 := p.parse_attrs() + _t1907 = _t1908 } - attrs1084 := _t1891 + attrs1092 := _t1907 p.consumeLiteral(")") - _t1893 := attrs1084 - if attrs1084 == nil { - _t1893 = []*pb.Attribute{} + _t1909 := attrs1092 + if attrs1092 == nil { + _t1909 = []*pb.Attribute{} } - _t1894 := &pb.MonoidDef{Monoid: monoid1081, Name: relation_id1082, Body: abstraction_with_arity1083[0].(*pb.Abstraction), Attrs: _t1893, ValueArity: abstraction_with_arity1083[1].(int64)} - result1086 := _t1894 - p.recordSpan(int(span_start1085), "MonoidDef") - return result1086 + _t1910 := &pb.MonoidDef{Monoid: monoid1089, Name: relation_id1090, Body: abstraction_with_arity1091[0].(*pb.Abstraction), Attrs: _t1909, ValueArity: abstraction_with_arity1091[1].(int64)} + result1094 := _t1910 + p.recordSpan(int(span_start1093), "MonoidDef") + return result1094 } func (p *Parser) parse_monoid() *pb.Monoid { - span_start1092 := int64(p.spanStart()) - var _t1895 int64 + span_start1100 := int64(p.spanStart()) + var _t1911 int64 if p.matchLookaheadLiteral("(", 0) { - var _t1896 int64 + var _t1912 int64 if p.matchLookaheadLiteral("sum", 1) { - _t1896 = 3 + _t1912 = 3 } else { - var _t1897 int64 + var _t1913 int64 if p.matchLookaheadLiteral("or", 1) { - _t1897 = 0 + _t1913 = 0 } else { - var _t1898 int64 + var _t1914 int64 if p.matchLookaheadLiteral("min", 1) { - _t1898 = 1 + _t1914 = 1 } else { - var _t1899 int64 + var _t1915 int64 if p.matchLookaheadLiteral("max", 1) { - _t1899 = 2 + _t1915 = 2 } else { - _t1899 = -1 + _t1915 = -1 } - _t1898 = _t1899 + _t1914 = _t1915 } - _t1897 = _t1898 + _t1913 = _t1914 } - _t1896 = _t1897 + _t1912 = _t1913 } - _t1895 = _t1896 + _t1911 = _t1912 } else { - _t1895 = -1 - } - prediction1087 := _t1895 - var _t1900 *pb.Monoid - if prediction1087 == 3 { - _t1901 := p.parse_sum_monoid() - sum_monoid1091 := _t1901 - _t1902 := &pb.Monoid{} - _t1902.Value = &pb.Monoid_SumMonoid{SumMonoid: sum_monoid1091} - _t1900 = _t1902 + _t1911 = -1 + } + prediction1095 := _t1911 + var _t1916 *pb.Monoid + if prediction1095 == 3 { + _t1917 := p.parse_sum_monoid() + sum_monoid1099 := _t1917 + _t1918 := &pb.Monoid{} + _t1918.Value = &pb.Monoid_SumMonoid{SumMonoid: sum_monoid1099} + _t1916 = _t1918 } else { - var _t1903 *pb.Monoid - if prediction1087 == 2 { - _t1904 := p.parse_max_monoid() - max_monoid1090 := _t1904 - _t1905 := &pb.Monoid{} - _t1905.Value = &pb.Monoid_MaxMonoid{MaxMonoid: max_monoid1090} - _t1903 = _t1905 + var _t1919 *pb.Monoid + if prediction1095 == 2 { + _t1920 := p.parse_max_monoid() + max_monoid1098 := _t1920 + _t1921 := &pb.Monoid{} + _t1921.Value = &pb.Monoid_MaxMonoid{MaxMonoid: max_monoid1098} + _t1919 = _t1921 } else { - var _t1906 *pb.Monoid - if prediction1087 == 1 { - _t1907 := p.parse_min_monoid() - min_monoid1089 := _t1907 - _t1908 := &pb.Monoid{} - _t1908.Value = &pb.Monoid_MinMonoid{MinMonoid: min_monoid1089} - _t1906 = _t1908 + var _t1922 *pb.Monoid + if prediction1095 == 1 { + _t1923 := p.parse_min_monoid() + min_monoid1097 := _t1923 + _t1924 := &pb.Monoid{} + _t1924.Value = &pb.Monoid_MinMonoid{MinMonoid: min_monoid1097} + _t1922 = _t1924 } else { - var _t1909 *pb.Monoid - if prediction1087 == 0 { - _t1910 := p.parse_or_monoid() - or_monoid1088 := _t1910 - _t1911 := &pb.Monoid{} - _t1911.Value = &pb.Monoid_OrMonoid{OrMonoid: or_monoid1088} - _t1909 = _t1911 + var _t1925 *pb.Monoid + if prediction1095 == 0 { + _t1926 := p.parse_or_monoid() + or_monoid1096 := _t1926 + _t1927 := &pb.Monoid{} + _t1927.Value = &pb.Monoid_OrMonoid{OrMonoid: or_monoid1096} + _t1925 = _t1927 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in monoid", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1906 = _t1909 + _t1922 = _t1925 } - _t1903 = _t1906 + _t1919 = _t1922 } - _t1900 = _t1903 + _t1916 = _t1919 } - result1093 := _t1900 - p.recordSpan(int(span_start1092), "Monoid") - return result1093 + result1101 := _t1916 + p.recordSpan(int(span_start1100), "Monoid") + return result1101 } func (p *Parser) parse_or_monoid() *pb.OrMonoid { - span_start1094 := int64(p.spanStart()) + span_start1102 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("or") p.consumeLiteral(")") - _t1912 := &pb.OrMonoid{} - result1095 := _t1912 - p.recordSpan(int(span_start1094), "OrMonoid") - return result1095 + _t1928 := &pb.OrMonoid{} + result1103 := _t1928 + p.recordSpan(int(span_start1102), "OrMonoid") + return result1103 } func (p *Parser) parse_min_monoid() *pb.MinMonoid { - span_start1097 := int64(p.spanStart()) + span_start1105 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("min") - _t1913 := p.parse_type() - type1096 := _t1913 + _t1929 := p.parse_type() + type1104 := _t1929 p.consumeLiteral(")") - _t1914 := &pb.MinMonoid{Type: type1096} - result1098 := _t1914 - p.recordSpan(int(span_start1097), "MinMonoid") - return result1098 + _t1930 := &pb.MinMonoid{Type: type1104} + result1106 := _t1930 + p.recordSpan(int(span_start1105), "MinMonoid") + return result1106 } func (p *Parser) parse_max_monoid() *pb.MaxMonoid { - span_start1100 := int64(p.spanStart()) + span_start1108 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("max") - _t1915 := p.parse_type() - type1099 := _t1915 + _t1931 := p.parse_type() + type1107 := _t1931 p.consumeLiteral(")") - _t1916 := &pb.MaxMonoid{Type: type1099} - result1101 := _t1916 - p.recordSpan(int(span_start1100), "MaxMonoid") - return result1101 + _t1932 := &pb.MaxMonoid{Type: type1107} + result1109 := _t1932 + p.recordSpan(int(span_start1108), "MaxMonoid") + return result1109 } func (p *Parser) parse_sum_monoid() *pb.SumMonoid { - span_start1103 := int64(p.spanStart()) + span_start1111 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("sum") - _t1917 := p.parse_type() - type1102 := _t1917 + _t1933 := p.parse_type() + type1110 := _t1933 p.consumeLiteral(")") - _t1918 := &pb.SumMonoid{Type: type1102} - result1104 := _t1918 - p.recordSpan(int(span_start1103), "SumMonoid") - return result1104 + _t1934 := &pb.SumMonoid{Type: type1110} + result1112 := _t1934 + p.recordSpan(int(span_start1111), "SumMonoid") + return result1112 } func (p *Parser) parse_monus_def() *pb.MonusDef { - span_start1109 := int64(p.spanStart()) + span_start1117 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("monus") - _t1919 := p.parse_monoid() - monoid1105 := _t1919 - _t1920 := p.parse_relation_id() - relation_id1106 := _t1920 - _t1921 := p.parse_abstraction_with_arity() - abstraction_with_arity1107 := _t1921 - var _t1922 []*pb.Attribute + _t1935 := p.parse_monoid() + monoid1113 := _t1935 + _t1936 := p.parse_relation_id() + relation_id1114 := _t1936 + _t1937 := p.parse_abstraction_with_arity() + abstraction_with_arity1115 := _t1937 + var _t1938 []*pb.Attribute if p.matchLookaheadLiteral("(", 0) { - _t1923 := p.parse_attrs() - _t1922 = _t1923 + _t1939 := p.parse_attrs() + _t1938 = _t1939 } - attrs1108 := _t1922 + attrs1116 := _t1938 p.consumeLiteral(")") - _t1924 := attrs1108 - if attrs1108 == nil { - _t1924 = []*pb.Attribute{} + _t1940 := attrs1116 + if attrs1116 == nil { + _t1940 = []*pb.Attribute{} } - _t1925 := &pb.MonusDef{Monoid: monoid1105, Name: relation_id1106, Body: abstraction_with_arity1107[0].(*pb.Abstraction), Attrs: _t1924, ValueArity: abstraction_with_arity1107[1].(int64)} - result1110 := _t1925 - p.recordSpan(int(span_start1109), "MonusDef") - return result1110 + _t1941 := &pb.MonusDef{Monoid: monoid1113, Name: relation_id1114, Body: abstraction_with_arity1115[0].(*pb.Abstraction), Attrs: _t1940, ValueArity: abstraction_with_arity1115[1].(int64)} + result1118 := _t1941 + p.recordSpan(int(span_start1117), "MonusDef") + return result1118 } func (p *Parser) parse_constraint() *pb.Constraint { - span_start1115 := int64(p.spanStart()) + span_start1123 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("functional_dependency") - _t1926 := p.parse_relation_id() - relation_id1111 := _t1926 - _t1927 := p.parse_abstraction() - abstraction1112 := _t1927 - _t1928 := p.parse_functional_dependency_keys() - functional_dependency_keys1113 := _t1928 - _t1929 := p.parse_functional_dependency_values() - functional_dependency_values1114 := _t1929 + _t1942 := p.parse_relation_id() + relation_id1119 := _t1942 + _t1943 := p.parse_abstraction() + abstraction1120 := _t1943 + _t1944 := p.parse_functional_dependency_keys() + functional_dependency_keys1121 := _t1944 + _t1945 := p.parse_functional_dependency_values() + functional_dependency_values1122 := _t1945 p.consumeLiteral(")") - _t1930 := &pb.FunctionalDependency{Guard: abstraction1112, Keys: functional_dependency_keys1113, Values: functional_dependency_values1114} - _t1931 := &pb.Constraint{Name: relation_id1111} - _t1931.ConstraintType = &pb.Constraint_FunctionalDependency{FunctionalDependency: _t1930} - result1116 := _t1931 - p.recordSpan(int(span_start1115), "Constraint") - return result1116 + _t1946 := &pb.FunctionalDependency{Guard: abstraction1120, Keys: functional_dependency_keys1121, Values: functional_dependency_values1122} + _t1947 := &pb.Constraint{Name: relation_id1119} + _t1947.ConstraintType = &pb.Constraint_FunctionalDependency{FunctionalDependency: _t1946} + result1124 := _t1947 + p.recordSpan(int(span_start1123), "Constraint") + return result1124 } func (p *Parser) parse_functional_dependency_keys() []*pb.Var { p.consumeLiteral("(") p.consumeLiteral("keys") - xs1117 := []*pb.Var{} - cond1118 := p.matchLookaheadTerminal("SYMBOL", 0) - for cond1118 { - _t1932 := p.parse_var() - item1119 := _t1932 - xs1117 = append(xs1117, item1119) - cond1118 = p.matchLookaheadTerminal("SYMBOL", 0) - } - vars1120 := xs1117 + xs1125 := []*pb.Var{} + cond1126 := p.matchLookaheadTerminal("SYMBOL", 0) + for cond1126 { + _t1948 := p.parse_var() + item1127 := _t1948 + xs1125 = append(xs1125, item1127) + cond1126 = p.matchLookaheadTerminal("SYMBOL", 0) + } + vars1128 := xs1125 p.consumeLiteral(")") - return vars1120 + return vars1128 } func (p *Parser) parse_functional_dependency_values() []*pb.Var { p.consumeLiteral("(") p.consumeLiteral("values") - xs1121 := []*pb.Var{} - cond1122 := p.matchLookaheadTerminal("SYMBOL", 0) - for cond1122 { - _t1933 := p.parse_var() - item1123 := _t1933 - xs1121 = append(xs1121, item1123) - cond1122 = p.matchLookaheadTerminal("SYMBOL", 0) - } - vars1124 := xs1121 + xs1129 := []*pb.Var{} + cond1130 := p.matchLookaheadTerminal("SYMBOL", 0) + for cond1130 { + _t1949 := p.parse_var() + item1131 := _t1949 + xs1129 = append(xs1129, item1131) + cond1130 = p.matchLookaheadTerminal("SYMBOL", 0) + } + vars1132 := xs1129 p.consumeLiteral(")") - return vars1124 + return vars1132 } func (p *Parser) parse_data() *pb.Data { - span_start1130 := int64(p.spanStart()) - var _t1934 int64 + span_start1138 := int64(p.spanStart()) + var _t1950 int64 if p.matchLookaheadLiteral("(", 0) { - var _t1935 int64 + var _t1951 int64 if p.matchLookaheadLiteral("iceberg_data", 1) { - _t1935 = 3 + _t1951 = 3 } else { - var _t1936 int64 + var _t1952 int64 if p.matchLookaheadLiteral("edb", 1) { - _t1936 = 0 + _t1952 = 0 } else { - var _t1937 int64 + var _t1953 int64 if p.matchLookaheadLiteral("csv_data", 1) { - _t1937 = 2 + _t1953 = 2 } else { - var _t1938 int64 + var _t1954 int64 if p.matchLookaheadLiteral("betree_relation", 1) { - _t1938 = 1 + _t1954 = 1 } else { - _t1938 = -1 + _t1954 = -1 } - _t1937 = _t1938 + _t1953 = _t1954 } - _t1936 = _t1937 + _t1952 = _t1953 } - _t1935 = _t1936 + _t1951 = _t1952 } - _t1934 = _t1935 + _t1950 = _t1951 } else { - _t1934 = -1 - } - prediction1125 := _t1934 - var _t1939 *pb.Data - if prediction1125 == 3 { - _t1940 := p.parse_iceberg_data() - iceberg_data1129 := _t1940 - _t1941 := &pb.Data{} - _t1941.DataType = &pb.Data_IcebergData{IcebergData: iceberg_data1129} - _t1939 = _t1941 + _t1950 = -1 + } + prediction1133 := _t1950 + var _t1955 *pb.Data + if prediction1133 == 3 { + _t1956 := p.parse_iceberg_data() + iceberg_data1137 := _t1956 + _t1957 := &pb.Data{} + _t1957.DataType = &pb.Data_IcebergData{IcebergData: iceberg_data1137} + _t1955 = _t1957 } else { - var _t1942 *pb.Data - if prediction1125 == 2 { - _t1943 := p.parse_csv_data() - csv_data1128 := _t1943 - _t1944 := &pb.Data{} - _t1944.DataType = &pb.Data_CsvData{CsvData: csv_data1128} - _t1942 = _t1944 + var _t1958 *pb.Data + if prediction1133 == 2 { + _t1959 := p.parse_csv_data() + csv_data1136 := _t1959 + _t1960 := &pb.Data{} + _t1960.DataType = &pb.Data_CsvData{CsvData: csv_data1136} + _t1958 = _t1960 } else { - var _t1945 *pb.Data - if prediction1125 == 1 { - _t1946 := p.parse_betree_relation() - betree_relation1127 := _t1946 - _t1947 := &pb.Data{} - _t1947.DataType = &pb.Data_BetreeRelation{BetreeRelation: betree_relation1127} - _t1945 = _t1947 + var _t1961 *pb.Data + if prediction1133 == 1 { + _t1962 := p.parse_betree_relation() + betree_relation1135 := _t1962 + _t1963 := &pb.Data{} + _t1963.DataType = &pb.Data_BetreeRelation{BetreeRelation: betree_relation1135} + _t1961 = _t1963 } else { - var _t1948 *pb.Data - if prediction1125 == 0 { - _t1949 := p.parse_edb() - edb1126 := _t1949 - _t1950 := &pb.Data{} - _t1950.DataType = &pb.Data_Edb{Edb: edb1126} - _t1948 = _t1950 + var _t1964 *pb.Data + if prediction1133 == 0 { + _t1965 := p.parse_edb() + edb1134 := _t1965 + _t1966 := &pb.Data{} + _t1966.DataType = &pb.Data_Edb{Edb: edb1134} + _t1964 = _t1966 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in data", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1945 = _t1948 + _t1961 = _t1964 } - _t1942 = _t1945 + _t1958 = _t1961 } - _t1939 = _t1942 + _t1955 = _t1958 } - result1131 := _t1939 - p.recordSpan(int(span_start1130), "Data") - return result1131 + result1139 := _t1955 + p.recordSpan(int(span_start1138), "Data") + return result1139 } func (p *Parser) parse_edb() *pb.EDB { - span_start1135 := int64(p.spanStart()) + span_start1143 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("edb") - _t1951 := p.parse_relation_id() - relation_id1132 := _t1951 - _t1952 := p.parse_edb_path() - edb_path1133 := _t1952 - _t1953 := p.parse_edb_types() - edb_types1134 := _t1953 + _t1967 := p.parse_relation_id() + relation_id1140 := _t1967 + _t1968 := p.parse_edb_path() + edb_path1141 := _t1968 + _t1969 := p.parse_edb_types() + edb_types1142 := _t1969 p.consumeLiteral(")") - _t1954 := &pb.EDB{TargetId: relation_id1132, Path: edb_path1133, Types: edb_types1134} - result1136 := _t1954 - p.recordSpan(int(span_start1135), "EDB") - return result1136 + _t1970 := &pb.EDB{TargetId: relation_id1140, Path: edb_path1141, Types: edb_types1142} + result1144 := _t1970 + p.recordSpan(int(span_start1143), "EDB") + return result1144 } func (p *Parser) parse_edb_path() []string { p.consumeLiteral("[") - xs1137 := []string{} - cond1138 := p.matchLookaheadTerminal("STRING", 0) - for cond1138 { - item1139 := p.consumeTerminal("STRING").Value.str - xs1137 = append(xs1137, item1139) - cond1138 = p.matchLookaheadTerminal("STRING", 0) - } - strings1140 := xs1137 + xs1145 := []string{} + cond1146 := p.matchLookaheadTerminal("STRING", 0) + for cond1146 { + item1147 := p.consumeTerminal("STRING").Value.str + xs1145 = append(xs1145, item1147) + cond1146 = p.matchLookaheadTerminal("STRING", 0) + } + strings1148 := xs1145 p.consumeLiteral("]") - return strings1140 + return strings1148 } func (p *Parser) parse_edb_types() []*pb.Type { p.consumeLiteral("[") - xs1141 := []*pb.Type{} - cond1142 := (((((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("BOOLEAN", 0)) || p.matchLookaheadLiteral("DATE", 0)) || p.matchLookaheadLiteral("DATETIME", 0)) || p.matchLookaheadLiteral("FLOAT", 0)) || p.matchLookaheadLiteral("FLOAT32", 0)) || p.matchLookaheadLiteral("INT", 0)) || p.matchLookaheadLiteral("INT128", 0)) || p.matchLookaheadLiteral("INT32", 0)) || p.matchLookaheadLiteral("MISSING", 0)) || p.matchLookaheadLiteral("STRING", 0)) || p.matchLookaheadLiteral("UINT128", 0)) || p.matchLookaheadLiteral("UINT32", 0)) || p.matchLookaheadLiteral("UNKNOWN", 0)) - for cond1142 { - _t1955 := p.parse_type() - item1143 := _t1955 - xs1141 = append(xs1141, item1143) - cond1142 = (((((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("BOOLEAN", 0)) || p.matchLookaheadLiteral("DATE", 0)) || p.matchLookaheadLiteral("DATETIME", 0)) || p.matchLookaheadLiteral("FLOAT", 0)) || p.matchLookaheadLiteral("FLOAT32", 0)) || p.matchLookaheadLiteral("INT", 0)) || p.matchLookaheadLiteral("INT128", 0)) || p.matchLookaheadLiteral("INT32", 0)) || p.matchLookaheadLiteral("MISSING", 0)) || p.matchLookaheadLiteral("STRING", 0)) || p.matchLookaheadLiteral("UINT128", 0)) || p.matchLookaheadLiteral("UINT32", 0)) || p.matchLookaheadLiteral("UNKNOWN", 0)) - } - types1144 := xs1141 + xs1149 := []*pb.Type{} + cond1150 := (((((((((((((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 cond1150 { + _t1971 := p.parse_type() + item1151 := _t1971 + xs1149 = append(xs1149, item1151) + cond1150 = (((((((((((((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)) + } + types1152 := xs1149 p.consumeLiteral("]") - return types1144 + return types1152 } func (p *Parser) parse_betree_relation() *pb.BeTreeRelation { - span_start1147 := int64(p.spanStart()) + span_start1155 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("betree_relation") - _t1956 := p.parse_relation_id() - relation_id1145 := _t1956 - _t1957 := p.parse_betree_info() - betree_info1146 := _t1957 + _t1972 := p.parse_relation_id() + relation_id1153 := _t1972 + _t1973 := p.parse_betree_info() + betree_info1154 := _t1973 p.consumeLiteral(")") - _t1958 := &pb.BeTreeRelation{Name: relation_id1145, RelationInfo: betree_info1146} - result1148 := _t1958 - p.recordSpan(int(span_start1147), "BeTreeRelation") - return result1148 + _t1974 := &pb.BeTreeRelation{Name: relation_id1153, RelationInfo: betree_info1154} + result1156 := _t1974 + p.recordSpan(int(span_start1155), "BeTreeRelation") + return result1156 } func (p *Parser) parse_betree_info() *pb.BeTreeInfo { - span_start1152 := int64(p.spanStart()) + span_start1160 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("betree_info") - _t1959 := p.parse_betree_info_key_types() - betree_info_key_types1149 := _t1959 - _t1960 := p.parse_betree_info_value_types() - betree_info_value_types1150 := _t1960 - _t1961 := p.parse_config_dict() - config_dict1151 := _t1961 + _t1975 := p.parse_betree_info_key_types() + betree_info_key_types1157 := _t1975 + _t1976 := p.parse_betree_info_value_types() + betree_info_value_types1158 := _t1976 + _t1977 := p.parse_config_dict() + config_dict1159 := _t1977 p.consumeLiteral(")") - _t1962 := p.construct_betree_info(betree_info_key_types1149, betree_info_value_types1150, config_dict1151) - result1153 := _t1962 - p.recordSpan(int(span_start1152), "BeTreeInfo") - return result1153 + _t1978 := p.construct_betree_info(betree_info_key_types1157, betree_info_value_types1158, config_dict1159) + result1161 := _t1978 + p.recordSpan(int(span_start1160), "BeTreeInfo") + return result1161 } func (p *Parser) parse_betree_info_key_types() []*pb.Type { p.consumeLiteral("(") p.consumeLiteral("key_types") - xs1154 := []*pb.Type{} - cond1155 := (((((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("BOOLEAN", 0)) || p.matchLookaheadLiteral("DATE", 0)) || p.matchLookaheadLiteral("DATETIME", 0)) || p.matchLookaheadLiteral("FLOAT", 0)) || p.matchLookaheadLiteral("FLOAT32", 0)) || p.matchLookaheadLiteral("INT", 0)) || p.matchLookaheadLiteral("INT128", 0)) || p.matchLookaheadLiteral("INT32", 0)) || p.matchLookaheadLiteral("MISSING", 0)) || p.matchLookaheadLiteral("STRING", 0)) || p.matchLookaheadLiteral("UINT128", 0)) || p.matchLookaheadLiteral("UINT32", 0)) || p.matchLookaheadLiteral("UNKNOWN", 0)) - for cond1155 { - _t1963 := p.parse_type() - item1156 := _t1963 - xs1154 = append(xs1154, item1156) - cond1155 = (((((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("BOOLEAN", 0)) || p.matchLookaheadLiteral("DATE", 0)) || p.matchLookaheadLiteral("DATETIME", 0)) || p.matchLookaheadLiteral("FLOAT", 0)) || p.matchLookaheadLiteral("FLOAT32", 0)) || p.matchLookaheadLiteral("INT", 0)) || p.matchLookaheadLiteral("INT128", 0)) || p.matchLookaheadLiteral("INT32", 0)) || p.matchLookaheadLiteral("MISSING", 0)) || p.matchLookaheadLiteral("STRING", 0)) || p.matchLookaheadLiteral("UINT128", 0)) || p.matchLookaheadLiteral("UINT32", 0)) || p.matchLookaheadLiteral("UNKNOWN", 0)) - } - types1157 := xs1154 + xs1162 := []*pb.Type{} + cond1163 := (((((((((((((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 cond1163 { + _t1979 := p.parse_type() + item1164 := _t1979 + xs1162 = append(xs1162, item1164) + cond1163 = (((((((((((((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)) + } + types1165 := xs1162 p.consumeLiteral(")") - return types1157 + return types1165 } func (p *Parser) parse_betree_info_value_types() []*pb.Type { p.consumeLiteral("(") p.consumeLiteral("value_types") - xs1158 := []*pb.Type{} - cond1159 := (((((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("BOOLEAN", 0)) || p.matchLookaheadLiteral("DATE", 0)) || p.matchLookaheadLiteral("DATETIME", 0)) || p.matchLookaheadLiteral("FLOAT", 0)) || p.matchLookaheadLiteral("FLOAT32", 0)) || p.matchLookaheadLiteral("INT", 0)) || p.matchLookaheadLiteral("INT128", 0)) || p.matchLookaheadLiteral("INT32", 0)) || p.matchLookaheadLiteral("MISSING", 0)) || p.matchLookaheadLiteral("STRING", 0)) || p.matchLookaheadLiteral("UINT128", 0)) || p.matchLookaheadLiteral("UINT32", 0)) || p.matchLookaheadLiteral("UNKNOWN", 0)) - for cond1159 { - _t1964 := p.parse_type() - item1160 := _t1964 - xs1158 = append(xs1158, item1160) - cond1159 = (((((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("BOOLEAN", 0)) || p.matchLookaheadLiteral("DATE", 0)) || p.matchLookaheadLiteral("DATETIME", 0)) || p.matchLookaheadLiteral("FLOAT", 0)) || p.matchLookaheadLiteral("FLOAT32", 0)) || p.matchLookaheadLiteral("INT", 0)) || p.matchLookaheadLiteral("INT128", 0)) || p.matchLookaheadLiteral("INT32", 0)) || p.matchLookaheadLiteral("MISSING", 0)) || p.matchLookaheadLiteral("STRING", 0)) || p.matchLookaheadLiteral("UINT128", 0)) || p.matchLookaheadLiteral("UINT32", 0)) || p.matchLookaheadLiteral("UNKNOWN", 0)) - } - types1161 := xs1158 + xs1166 := []*pb.Type{} + cond1167 := (((((((((((((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 cond1167 { + _t1980 := p.parse_type() + item1168 := _t1980 + xs1166 = append(xs1166, item1168) + cond1167 = (((((((((((((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)) + } + types1169 := xs1166 p.consumeLiteral(")") - return types1161 + return types1169 } func (p *Parser) parse_csv_data() *pb.CSVData { - span_start1166 := int64(p.spanStart()) + span_start1174 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("csv_data") - _t1965 := p.parse_csvlocator() - csvlocator1162 := _t1965 - _t1966 := p.parse_csv_config() - csv_config1163 := _t1966 - _t1967 := p.parse_gnf_columns() - gnf_columns1164 := _t1967 - _t1968 := p.parse_csv_asof() - csv_asof1165 := _t1968 + _t1981 := p.parse_csvlocator() + csvlocator1170 := _t1981 + _t1982 := p.parse_csv_config() + csv_config1171 := _t1982 + _t1983 := p.parse_gnf_columns() + gnf_columns1172 := _t1983 + _t1984 := p.parse_csv_asof() + csv_asof1173 := _t1984 p.consumeLiteral(")") - _t1969 := &pb.CSVData{Locator: csvlocator1162, Config: csv_config1163, Columns: gnf_columns1164, Asof: csv_asof1165} - result1167 := _t1969 - p.recordSpan(int(span_start1166), "CSVData") - return result1167 + _t1985 := &pb.CSVData{Locator: csvlocator1170, Config: csv_config1171, Columns: gnf_columns1172, Asof: csv_asof1173} + result1175 := _t1985 + p.recordSpan(int(span_start1174), "CSVData") + return result1175 } func (p *Parser) parse_csvlocator() *pb.CSVLocator { - span_start1170 := int64(p.spanStart()) + span_start1178 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("csv_locator") - var _t1970 []string + var _t1986 []string if (p.matchLookaheadLiteral("(", 0) && p.matchLookaheadLiteral("paths", 1)) { - _t1971 := p.parse_csv_locator_paths() - _t1970 = _t1971 + _t1987 := p.parse_csv_locator_paths() + _t1986 = _t1987 } - csv_locator_paths1168 := _t1970 - var _t1972 *string + csv_locator_paths1176 := _t1986 + var _t1988 *string if p.matchLookaheadLiteral("(", 0) { - _t1973 := p.parse_csv_locator_inline_data() - _t1972 = ptr(_t1973) + _t1989 := p.parse_csv_locator_inline_data() + _t1988 = ptr(_t1989) } - csv_locator_inline_data1169 := _t1972 + csv_locator_inline_data1177 := _t1988 p.consumeLiteral(")") - _t1974 := csv_locator_paths1168 - if csv_locator_paths1168 == nil { - _t1974 = []string{} + _t1990 := csv_locator_paths1176 + if csv_locator_paths1176 == nil { + _t1990 = []string{} } - _t1975 := &pb.CSVLocator{Paths: _t1974, InlineData: []byte(deref(csv_locator_inline_data1169, ""))} - result1171 := _t1975 - p.recordSpan(int(span_start1170), "CSVLocator") - return result1171 + _t1991 := &pb.CSVLocator{Paths: _t1990, InlineData: []byte(deref(csv_locator_inline_data1177, ""))} + result1179 := _t1991 + p.recordSpan(int(span_start1178), "CSVLocator") + return result1179 } func (p *Parser) parse_csv_locator_paths() []string { p.consumeLiteral("(") p.consumeLiteral("paths") - xs1172 := []string{} - cond1173 := p.matchLookaheadTerminal("STRING", 0) - for cond1173 { - item1174 := p.consumeTerminal("STRING").Value.str - xs1172 = append(xs1172, item1174) - cond1173 = p.matchLookaheadTerminal("STRING", 0) - } - strings1175 := xs1172 + xs1180 := []string{} + cond1181 := p.matchLookaheadTerminal("STRING", 0) + for cond1181 { + item1182 := p.consumeTerminal("STRING").Value.str + xs1180 = append(xs1180, item1182) + cond1181 = p.matchLookaheadTerminal("STRING", 0) + } + strings1183 := xs1180 p.consumeLiteral(")") - return strings1175 + return strings1183 } func (p *Parser) parse_csv_locator_inline_data() string { p.consumeLiteral("(") p.consumeLiteral("inline_data") - formatted_string1176 := p.consumeTerminal("STRING").Value.str + formatted_string1184 := p.consumeTerminal("STRING").Value.str p.consumeLiteral(")") - return formatted_string1176 + return formatted_string1184 } func (p *Parser) parse_csv_config() *pb.CSVConfig { - span_start1179 := int64(p.spanStart()) + span_start1187 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("csv_config") - _t1976 := p.parse_config_dict() - config_dict1177 := _t1976 - var _t1977 [][]interface{} + _t1992 := p.parse_config_dict() + config_dict1185 := _t1992 + var _t1993 [][]interface{} if p.matchLookaheadLiteral("(", 0) { - _t1978 := p.parse__storage_integration() - _t1977 = _t1978 + _t1994 := p.parse__storage_integration() + _t1993 = _t1994 } - _storage_integration1178 := _t1977 + _storage_integration1186 := _t1993 p.consumeLiteral(")") - _t1979 := p.construct_csv_config(config_dict1177, _storage_integration1178) - result1180 := _t1979 - p.recordSpan(int(span_start1179), "CSVConfig") - return result1180 + _t1995 := p.construct_csv_config(config_dict1185, _storage_integration1186) + result1188 := _t1995 + p.recordSpan(int(span_start1187), "CSVConfig") + return result1188 } func (p *Parser) parse__storage_integration() [][]interface{} { p.consumeLiteral("(") p.consumeLiteral("storage_integration") - _t1980 := p.parse_config_dict() - config_dict1181 := _t1980 + _t1996 := p.parse_config_dict() + config_dict1189 := _t1996 p.consumeLiteral(")") - return config_dict1181 + return config_dict1189 } func (p *Parser) parse_gnf_columns() []*pb.GNFColumn { p.consumeLiteral("(") p.consumeLiteral("columns") - xs1182 := []*pb.GNFColumn{} - cond1183 := p.matchLookaheadLiteral("(", 0) - for cond1183 { - _t1981 := p.parse_gnf_column() - item1184 := _t1981 - xs1182 = append(xs1182, item1184) - cond1183 = p.matchLookaheadLiteral("(", 0) - } - gnf_columns1185 := xs1182 + xs1190 := []*pb.GNFColumn{} + cond1191 := p.matchLookaheadLiteral("(", 0) + for cond1191 { + _t1997 := p.parse_gnf_column() + item1192 := _t1997 + xs1190 = append(xs1190, item1192) + cond1191 = p.matchLookaheadLiteral("(", 0) + } + gnf_columns1193 := xs1190 p.consumeLiteral(")") - return gnf_columns1185 + return gnf_columns1193 } func (p *Parser) parse_gnf_column() *pb.GNFColumn { - span_start1192 := int64(p.spanStart()) + span_start1200 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("column") - _t1982 := p.parse_gnf_column_path() - gnf_column_path1186 := _t1982 - var _t1983 *pb.RelationId + _t1998 := p.parse_gnf_column_path() + gnf_column_path1194 := _t1998 + var _t1999 *pb.RelationId if (p.matchLookaheadLiteral(":", 0) || p.matchLookaheadTerminal("UINT128", 0)) { - _t1984 := p.parse_relation_id() - _t1983 = _t1984 + _t2000 := p.parse_relation_id() + _t1999 = _t2000 } - relation_id1187 := _t1983 + relation_id1195 := _t1999 p.consumeLiteral("[") - xs1188 := []*pb.Type{} - cond1189 := (((((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("BOOLEAN", 0)) || p.matchLookaheadLiteral("DATE", 0)) || p.matchLookaheadLiteral("DATETIME", 0)) || p.matchLookaheadLiteral("FLOAT", 0)) || p.matchLookaheadLiteral("FLOAT32", 0)) || p.matchLookaheadLiteral("INT", 0)) || p.matchLookaheadLiteral("INT128", 0)) || p.matchLookaheadLiteral("INT32", 0)) || p.matchLookaheadLiteral("MISSING", 0)) || p.matchLookaheadLiteral("STRING", 0)) || p.matchLookaheadLiteral("UINT128", 0)) || p.matchLookaheadLiteral("UINT32", 0)) || p.matchLookaheadLiteral("UNKNOWN", 0)) - for cond1189 { - _t1985 := p.parse_type() - item1190 := _t1985 - xs1188 = append(xs1188, item1190) - cond1189 = (((((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("BOOLEAN", 0)) || p.matchLookaheadLiteral("DATE", 0)) || p.matchLookaheadLiteral("DATETIME", 0)) || p.matchLookaheadLiteral("FLOAT", 0)) || p.matchLookaheadLiteral("FLOAT32", 0)) || p.matchLookaheadLiteral("INT", 0)) || p.matchLookaheadLiteral("INT128", 0)) || p.matchLookaheadLiteral("INT32", 0)) || p.matchLookaheadLiteral("MISSING", 0)) || p.matchLookaheadLiteral("STRING", 0)) || p.matchLookaheadLiteral("UINT128", 0)) || p.matchLookaheadLiteral("UINT32", 0)) || p.matchLookaheadLiteral("UNKNOWN", 0)) - } - types1191 := xs1188 + xs1196 := []*pb.Type{} + cond1197 := (((((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("BOOLEAN", 0)) || p.matchLookaheadLiteral("DATE", 0)) || p.matchLookaheadLiteral("DATETIME", 0)) || p.matchLookaheadLiteral("FLOAT", 0)) || p.matchLookaheadLiteral("FLOAT32", 0)) || p.matchLookaheadLiteral("INT", 0)) || p.matchLookaheadLiteral("INT128", 0)) || p.matchLookaheadLiteral("INT32", 0)) || p.matchLookaheadLiteral("MISSING", 0)) || p.matchLookaheadLiteral("STRING", 0)) || p.matchLookaheadLiteral("UINT128", 0)) || p.matchLookaheadLiteral("UINT32", 0)) || p.matchLookaheadLiteral("UNKNOWN", 0)) + for cond1197 { + _t2001 := p.parse_type() + item1198 := _t2001 + xs1196 = append(xs1196, item1198) + cond1197 = (((((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("BOOLEAN", 0)) || p.matchLookaheadLiteral("DATE", 0)) || p.matchLookaheadLiteral("DATETIME", 0)) || p.matchLookaheadLiteral("FLOAT", 0)) || p.matchLookaheadLiteral("FLOAT32", 0)) || p.matchLookaheadLiteral("INT", 0)) || p.matchLookaheadLiteral("INT128", 0)) || p.matchLookaheadLiteral("INT32", 0)) || p.matchLookaheadLiteral("MISSING", 0)) || p.matchLookaheadLiteral("STRING", 0)) || p.matchLookaheadLiteral("UINT128", 0)) || p.matchLookaheadLiteral("UINT32", 0)) || p.matchLookaheadLiteral("UNKNOWN", 0)) + } + types1199 := xs1196 p.consumeLiteral("]") p.consumeLiteral(")") - _t1986 := &pb.GNFColumn{ColumnPath: gnf_column_path1186, TargetId: relation_id1187, Types: types1191} - result1193 := _t1986 - p.recordSpan(int(span_start1192), "GNFColumn") - return result1193 + _t2002 := &pb.GNFColumn{ColumnPath: gnf_column_path1194, TargetId: relation_id1195, Types: types1199} + result1201 := _t2002 + p.recordSpan(int(span_start1200), "GNFColumn") + return result1201 } func (p *Parser) parse_gnf_column_path() []string { - var _t1987 int64 + var _t2003 int64 if p.matchLookaheadLiteral("[", 0) { - _t1987 = 1 + _t2003 = 1 } else { - var _t1988 int64 + var _t2004 int64 if p.matchLookaheadTerminal("STRING", 0) { - _t1988 = 0 + _t2004 = 0 } else { - _t1988 = -1 + _t2004 = -1 } - _t1987 = _t1988 + _t2003 = _t2004 } - prediction1194 := _t1987 - var _t1989 []string - if prediction1194 == 1 { + prediction1202 := _t2003 + var _t2005 []string + if prediction1202 == 1 { p.consumeLiteral("[") - xs1196 := []string{} - cond1197 := p.matchLookaheadTerminal("STRING", 0) - for cond1197 { - item1198 := p.consumeTerminal("STRING").Value.str - xs1196 = append(xs1196, item1198) - cond1197 = p.matchLookaheadTerminal("STRING", 0) + xs1204 := []string{} + cond1205 := p.matchLookaheadTerminal("STRING", 0) + for cond1205 { + item1206 := p.consumeTerminal("STRING").Value.str + xs1204 = append(xs1204, item1206) + cond1205 = p.matchLookaheadTerminal("STRING", 0) } - strings1199 := xs1196 + strings1207 := xs1204 p.consumeLiteral("]") - _t1989 = strings1199 + _t2005 = strings1207 } else { - var _t1990 []string - if prediction1194 == 0 { - string1195 := p.consumeTerminal("STRING").Value.str - _ = string1195 - _t1990 = []string{string1195} + var _t2006 []string + if prediction1202 == 0 { + string1203 := p.consumeTerminal("STRING").Value.str + _ = string1203 + _t2006 = []string{string1203} } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in gnf_column_path", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1989 = _t1990 + _t2005 = _t2006 } - return _t1989 + return _t2005 } func (p *Parser) parse_csv_asof() string { p.consumeLiteral("(") p.consumeLiteral("asof") - string1200 := p.consumeTerminal("STRING").Value.str + string1208 := p.consumeTerminal("STRING").Value.str p.consumeLiteral(")") - return string1200 + return string1208 } func (p *Parser) parse_iceberg_data() *pb.IcebergData { - span_start1207 := int64(p.spanStart()) + span_start1215 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("iceberg_data") - _t1991 := p.parse_iceberg_locator() - iceberg_locator1201 := _t1991 - _t1992 := p.parse_iceberg_catalog_config() - iceberg_catalog_config1202 := _t1992 - _t1993 := p.parse_gnf_columns() - gnf_columns1203 := _t1993 - var _t1994 *string + _t2007 := p.parse_iceberg_locator() + iceberg_locator1209 := _t2007 + _t2008 := p.parse_iceberg_catalog_config() + iceberg_catalog_config1210 := _t2008 + _t2009 := p.parse_gnf_columns() + gnf_columns1211 := _t2009 + var _t2010 *string if (p.matchLookaheadLiteral("(", 0) && p.matchLookaheadLiteral("from_snapshot", 1)) { - _t1995 := p.parse_iceberg_from_snapshot() - _t1994 = ptr(_t1995) + _t2011 := p.parse_iceberg_from_snapshot() + _t2010 = ptr(_t2011) } - iceberg_from_snapshot1204 := _t1994 - var _t1996 *string + iceberg_from_snapshot1212 := _t2010 + var _t2012 *string if p.matchLookaheadLiteral("(", 0) { - _t1997 := p.parse_iceberg_to_snapshot() - _t1996 = ptr(_t1997) + _t2013 := p.parse_iceberg_to_snapshot() + _t2012 = ptr(_t2013) } - iceberg_to_snapshot1205 := _t1996 - _t1998 := p.parse_boolean_value() - boolean_value1206 := _t1998 + iceberg_to_snapshot1213 := _t2012 + _t2014 := p.parse_boolean_value() + boolean_value1214 := _t2014 p.consumeLiteral(")") - _t1999 := p.construct_iceberg_data(iceberg_locator1201, iceberg_catalog_config1202, gnf_columns1203, iceberg_from_snapshot1204, iceberg_to_snapshot1205, boolean_value1206) - result1208 := _t1999 - p.recordSpan(int(span_start1207), "IcebergData") - return result1208 + _t2015 := p.construct_iceberg_data(iceberg_locator1209, iceberg_catalog_config1210, gnf_columns1211, iceberg_from_snapshot1212, iceberg_to_snapshot1213, boolean_value1214) + result1216 := _t2015 + p.recordSpan(int(span_start1215), "IcebergData") + return result1216 } func (p *Parser) parse_iceberg_locator() *pb.IcebergLocator { - span_start1212 := int64(p.spanStart()) + span_start1220 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("iceberg_locator") - _t2000 := p.parse_iceberg_locator_table_name() - iceberg_locator_table_name1209 := _t2000 - _t2001 := p.parse_iceberg_locator_namespace() - iceberg_locator_namespace1210 := _t2001 - _t2002 := p.parse_iceberg_locator_warehouse() - iceberg_locator_warehouse1211 := _t2002 + _t2016 := p.parse_iceberg_locator_table_name() + iceberg_locator_table_name1217 := _t2016 + _t2017 := p.parse_iceberg_locator_namespace() + iceberg_locator_namespace1218 := _t2017 + _t2018 := p.parse_iceberg_locator_warehouse() + iceberg_locator_warehouse1219 := _t2018 p.consumeLiteral(")") - _t2003 := &pb.IcebergLocator{TableName: iceberg_locator_table_name1209, Namespace: iceberg_locator_namespace1210, Warehouse: iceberg_locator_warehouse1211} - result1213 := _t2003 - p.recordSpan(int(span_start1212), "IcebergLocator") - return result1213 + _t2019 := &pb.IcebergLocator{TableName: iceberg_locator_table_name1217, Namespace: iceberg_locator_namespace1218, Warehouse: iceberg_locator_warehouse1219} + result1221 := _t2019 + p.recordSpan(int(span_start1220), "IcebergLocator") + return result1221 } func (p *Parser) parse_iceberg_locator_table_name() string { p.consumeLiteral("(") p.consumeLiteral("table_name") - string1214 := p.consumeTerminal("STRING").Value.str + string1222 := p.consumeTerminal("STRING").Value.str p.consumeLiteral(")") - return string1214 + return string1222 } func (p *Parser) parse_iceberg_locator_namespace() []string { p.consumeLiteral("(") p.consumeLiteral("namespace") - xs1215 := []string{} - cond1216 := p.matchLookaheadTerminal("STRING", 0) - for cond1216 { - item1217 := p.consumeTerminal("STRING").Value.str - xs1215 = append(xs1215, item1217) - cond1216 = p.matchLookaheadTerminal("STRING", 0) - } - strings1218 := xs1215 + xs1223 := []string{} + cond1224 := p.matchLookaheadTerminal("STRING", 0) + for cond1224 { + item1225 := p.consumeTerminal("STRING").Value.str + xs1223 = append(xs1223, item1225) + cond1224 = p.matchLookaheadTerminal("STRING", 0) + } + strings1226 := xs1223 p.consumeLiteral(")") - return strings1218 + return strings1226 } func (p *Parser) parse_iceberg_locator_warehouse() string { p.consumeLiteral("(") p.consumeLiteral("warehouse") - string1219 := p.consumeTerminal("STRING").Value.str + string1227 := p.consumeTerminal("STRING").Value.str p.consumeLiteral(")") - return string1219 + return string1227 } func (p *Parser) parse_iceberg_catalog_config() *pb.IcebergCatalogConfig { - span_start1224 := int64(p.spanStart()) + span_start1232 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("iceberg_catalog_config") - _t2004 := p.parse_iceberg_catalog_uri() - iceberg_catalog_uri1220 := _t2004 - var _t2005 *string + _t2020 := p.parse_iceberg_catalog_uri() + iceberg_catalog_uri1228 := _t2020 + var _t2021 *string if (p.matchLookaheadLiteral("(", 0) && p.matchLookaheadLiteral("scope", 1)) { - _t2006 := p.parse_iceberg_catalog_config_scope() - _t2005 = ptr(_t2006) - } - iceberg_catalog_config_scope1221 := _t2005 - _t2007 := p.parse_iceberg_properties() - iceberg_properties1222 := _t2007 - _t2008 := p.parse_iceberg_auth_properties() - iceberg_auth_properties1223 := _t2008 + _t2022 := p.parse_iceberg_catalog_config_scope() + _t2021 = ptr(_t2022) + } + iceberg_catalog_config_scope1229 := _t2021 + _t2023 := p.parse_iceberg_properties() + iceberg_properties1230 := _t2023 + _t2024 := p.parse_iceberg_auth_properties() + iceberg_auth_properties1231 := _t2024 p.consumeLiteral(")") - _t2009 := p.construct_iceberg_catalog_config(iceberg_catalog_uri1220, iceberg_catalog_config_scope1221, iceberg_properties1222, iceberg_auth_properties1223) - result1225 := _t2009 - p.recordSpan(int(span_start1224), "IcebergCatalogConfig") - return result1225 + _t2025 := p.construct_iceberg_catalog_config(iceberg_catalog_uri1228, iceberg_catalog_config_scope1229, iceberg_properties1230, iceberg_auth_properties1231) + result1233 := _t2025 + p.recordSpan(int(span_start1232), "IcebergCatalogConfig") + return result1233 } func (p *Parser) parse_iceberg_catalog_uri() string { p.consumeLiteral("(") p.consumeLiteral("catalog_uri") - string1226 := p.consumeTerminal("STRING").Value.str + string1234 := p.consumeTerminal("STRING").Value.str p.consumeLiteral(")") - return string1226 + return string1234 } func (p *Parser) parse_iceberg_catalog_config_scope() string { p.consumeLiteral("(") p.consumeLiteral("scope") - string1227 := p.consumeTerminal("STRING").Value.str + string1235 := p.consumeTerminal("STRING").Value.str p.consumeLiteral(")") - return string1227 + return string1235 } func (p *Parser) parse_iceberg_properties() [][]interface{} { p.consumeLiteral("(") p.consumeLiteral("properties") - xs1228 := [][]interface{}{} - cond1229 := p.matchLookaheadLiteral("(", 0) - for cond1229 { - _t2010 := p.parse_iceberg_property_entry() - item1230 := _t2010 - xs1228 = append(xs1228, item1230) - cond1229 = p.matchLookaheadLiteral("(", 0) - } - iceberg_property_entrys1231 := xs1228 + xs1236 := [][]interface{}{} + cond1237 := p.matchLookaheadLiteral("(", 0) + for cond1237 { + _t2026 := p.parse_iceberg_property_entry() + item1238 := _t2026 + xs1236 = append(xs1236, item1238) + cond1237 = p.matchLookaheadLiteral("(", 0) + } + iceberg_property_entrys1239 := xs1236 p.consumeLiteral(")") - return iceberg_property_entrys1231 + return iceberg_property_entrys1239 } func (p *Parser) parse_iceberg_property_entry() []interface{} { p.consumeLiteral("(") p.consumeLiteral("prop") - string1232 := p.consumeTerminal("STRING").Value.str - string_31233 := p.consumeTerminal("STRING").Value.str + string1240 := p.consumeTerminal("STRING").Value.str + string_31241 := p.consumeTerminal("STRING").Value.str p.consumeLiteral(")") - return []interface{}{string1232, string_31233} + return []interface{}{string1240, string_31241} } func (p *Parser) parse_iceberg_auth_properties() [][]interface{} { p.consumeLiteral("(") p.consumeLiteral("auth_properties") - xs1234 := [][]interface{}{} - cond1235 := p.matchLookaheadLiteral("(", 0) - for cond1235 { - _t2011 := p.parse_iceberg_masked_property_entry() - item1236 := _t2011 - xs1234 = append(xs1234, item1236) - cond1235 = p.matchLookaheadLiteral("(", 0) - } - iceberg_masked_property_entrys1237 := xs1234 + xs1242 := [][]interface{}{} + cond1243 := p.matchLookaheadLiteral("(", 0) + for cond1243 { + _t2027 := p.parse_iceberg_masked_property_entry() + item1244 := _t2027 + xs1242 = append(xs1242, item1244) + cond1243 = p.matchLookaheadLiteral("(", 0) + } + iceberg_masked_property_entrys1245 := xs1242 p.consumeLiteral(")") - return iceberg_masked_property_entrys1237 + return iceberg_masked_property_entrys1245 } func (p *Parser) parse_iceberg_masked_property_entry() []interface{} { p.consumeLiteral("(") p.consumeLiteral("prop") - string1238 := p.consumeTerminal("STRING").Value.str - string_31239 := p.consumeTerminal("STRING").Value.str + string1246 := p.consumeTerminal("STRING").Value.str + string_31247 := p.consumeTerminal("STRING").Value.str p.consumeLiteral(")") - return []interface{}{string1238, string_31239} + return []interface{}{string1246, string_31247} } func (p *Parser) parse_iceberg_from_snapshot() string { p.consumeLiteral("(") p.consumeLiteral("from_snapshot") - string1240 := p.consumeTerminal("STRING").Value.str + string1248 := p.consumeTerminal("STRING").Value.str p.consumeLiteral(")") - return string1240 + return string1248 } func (p *Parser) parse_iceberg_to_snapshot() string { p.consumeLiteral("(") p.consumeLiteral("to_snapshot") - string1241 := p.consumeTerminal("STRING").Value.str + string1249 := p.consumeTerminal("STRING").Value.str p.consumeLiteral(")") - return string1241 + return string1249 } func (p *Parser) parse_undefine() *pb.Undefine { - span_start1243 := int64(p.spanStart()) + span_start1251 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("undefine") - _t2012 := p.parse_fragment_id() - fragment_id1242 := _t2012 + _t2028 := p.parse_fragment_id() + fragment_id1250 := _t2028 p.consumeLiteral(")") - _t2013 := &pb.Undefine{FragmentId: fragment_id1242} - result1244 := _t2013 - p.recordSpan(int(span_start1243), "Undefine") - return result1244 + _t2029 := &pb.Undefine{FragmentId: fragment_id1250} + result1252 := _t2029 + p.recordSpan(int(span_start1251), "Undefine") + return result1252 } func (p *Parser) parse_context() *pb.Context { - span_start1249 := int64(p.spanStart()) + span_start1257 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("context") - xs1245 := []*pb.RelationId{} - cond1246 := (p.matchLookaheadLiteral(":", 0) || p.matchLookaheadTerminal("UINT128", 0)) - for cond1246 { - _t2014 := p.parse_relation_id() - item1247 := _t2014 - xs1245 = append(xs1245, item1247) - cond1246 = (p.matchLookaheadLiteral(":", 0) || p.matchLookaheadTerminal("UINT128", 0)) - } - relation_ids1248 := xs1245 + xs1253 := []*pb.RelationId{} + cond1254 := (p.matchLookaheadLiteral(":", 0) || p.matchLookaheadTerminal("UINT128", 0)) + for cond1254 { + _t2030 := p.parse_relation_id() + item1255 := _t2030 + xs1253 = append(xs1253, item1255) + cond1254 = (p.matchLookaheadLiteral(":", 0) || p.matchLookaheadTerminal("UINT128", 0)) + } + relation_ids1256 := xs1253 p.consumeLiteral(")") - _t2015 := &pb.Context{Relations: relation_ids1248} - result1250 := _t2015 - p.recordSpan(int(span_start1249), "Context") - return result1250 + _t2031 := &pb.Context{Relations: relation_ids1256} + result1258 := _t2031 + p.recordSpan(int(span_start1257), "Context") + return result1258 } func (p *Parser) parse_snapshot() *pb.Snapshot { - span_start1256 := int64(p.spanStart()) + span_start1264 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("snapshot") - _t2016 := p.parse_edb_path() - edb_path1251 := _t2016 - xs1252 := []*pb.SnapshotMapping{} - cond1253 := p.matchLookaheadLiteral("[", 0) - for cond1253 { - _t2017 := p.parse_snapshot_mapping() - item1254 := _t2017 - xs1252 = append(xs1252, item1254) - cond1253 = p.matchLookaheadLiteral("[", 0) - } - snapshot_mappings1255 := xs1252 + _t2032 := p.parse_edb_path() + edb_path1259 := _t2032 + xs1260 := []*pb.SnapshotMapping{} + cond1261 := p.matchLookaheadLiteral("[", 0) + for cond1261 { + _t2033 := p.parse_snapshot_mapping() + item1262 := _t2033 + xs1260 = append(xs1260, item1262) + cond1261 = p.matchLookaheadLiteral("[", 0) + } + snapshot_mappings1263 := xs1260 p.consumeLiteral(")") - _t2018 := &pb.Snapshot{Prefix: edb_path1251, Mappings: snapshot_mappings1255} - result1257 := _t2018 - p.recordSpan(int(span_start1256), "Snapshot") - return result1257 + _t2034 := &pb.Snapshot{Prefix: edb_path1259, Mappings: snapshot_mappings1263} + result1265 := _t2034 + p.recordSpan(int(span_start1264), "Snapshot") + return result1265 } func (p *Parser) parse_snapshot_mapping() *pb.SnapshotMapping { - span_start1260 := int64(p.spanStart()) - _t2019 := p.parse_edb_path() - edb_path1258 := _t2019 - _t2020 := p.parse_relation_id() - relation_id1259 := _t2020 - _t2021 := &pb.SnapshotMapping{DestinationPath: edb_path1258, SourceRelation: relation_id1259} - result1261 := _t2021 - p.recordSpan(int(span_start1260), "SnapshotMapping") - return result1261 + span_start1268 := int64(p.spanStart()) + _t2035 := p.parse_edb_path() + edb_path1266 := _t2035 + _t2036 := p.parse_relation_id() + relation_id1267 := _t2036 + _t2037 := &pb.SnapshotMapping{DestinationPath: edb_path1266, SourceRelation: relation_id1267} + result1269 := _t2037 + p.recordSpan(int(span_start1268), "SnapshotMapping") + return result1269 } func (p *Parser) parse_epoch_reads() []*pb.Read { p.consumeLiteral("(") p.consumeLiteral("reads") - xs1262 := []*pb.Read{} - cond1263 := p.matchLookaheadLiteral("(", 0) - for cond1263 { - _t2022 := p.parse_read() - item1264 := _t2022 - xs1262 = append(xs1262, item1264) - cond1263 = p.matchLookaheadLiteral("(", 0) - } - reads1265 := xs1262 + xs1270 := []*pb.Read{} + cond1271 := p.matchLookaheadLiteral("(", 0) + for cond1271 { + _t2038 := p.parse_read() + item1272 := _t2038 + xs1270 = append(xs1270, item1272) + cond1271 = p.matchLookaheadLiteral("(", 0) + } + reads1273 := xs1270 p.consumeLiteral(")") - return reads1265 + return reads1273 } func (p *Parser) parse_read() *pb.Read { - span_start1272 := int64(p.spanStart()) - var _t2023 int64 + span_start1281 := int64(p.spanStart()) + var _t2039 int64 if p.matchLookaheadLiteral("(", 0) { - var _t2024 int64 + var _t2040 int64 if p.matchLookaheadLiteral("what_if", 1) { - _t2024 = 2 + _t2040 = 2 } else { - var _t2025 int64 - if p.matchLookaheadLiteral("output", 1) { - _t2025 = 1 + var _t2041 int64 + if p.matchLookaheadLiteral("output_export", 1) { + _t2041 = 5 } else { - var _t2026 int64 - if p.matchLookaheadLiteral("export_iceberg", 1) { - _t2026 = 4 + var _t2042 int64 + if p.matchLookaheadLiteral("output", 1) { + _t2042 = 1 } else { - var _t2027 int64 - if p.matchLookaheadLiteral("export", 1) { - _t2027 = 4 + var _t2043 int64 + if p.matchLookaheadLiteral("export_iceberg", 1) { + _t2043 = 4 } else { - var _t2028 int64 - if p.matchLookaheadLiteral("demand", 1) { - _t2028 = 0 + var _t2044 int64 + if p.matchLookaheadLiteral("export", 1) { + _t2044 = 4 } else { - var _t2029 int64 - if p.matchLookaheadLiteral("abort", 1) { - _t2029 = 3 + var _t2045 int64 + if p.matchLookaheadLiteral("demand", 1) { + _t2045 = 0 } else { - _t2029 = -1 + var _t2046 int64 + if p.matchLookaheadLiteral("abort", 1) { + _t2046 = 3 + } else { + _t2046 = -1 + } + _t2045 = _t2046 } - _t2028 = _t2029 + _t2044 = _t2045 } - _t2027 = _t2028 + _t2043 = _t2044 } - _t2026 = _t2027 + _t2042 = _t2043 } - _t2025 = _t2026 + _t2041 = _t2042 } - _t2024 = _t2025 + _t2040 = _t2041 } - _t2023 = _t2024 + _t2039 = _t2040 } else { - _t2023 = -1 - } - prediction1266 := _t2023 - var _t2030 *pb.Read - if prediction1266 == 4 { - _t2031 := p.parse_export() - export1271 := _t2031 - _t2032 := &pb.Read{} - _t2032.ReadType = &pb.Read_Export{Export: export1271} - _t2030 = _t2032 + _t2039 = -1 + } + prediction1274 := _t2039 + var _t2047 *pb.Read + if prediction1274 == 5 { + _t2048 := p.parse_export_output() + export_output1280 := _t2048 + _t2049 := &pb.Read{} + _t2049.ReadType = &pb.Read_ExportOutput{ExportOutput: export_output1280} + _t2047 = _t2049 } else { - var _t2033 *pb.Read - if prediction1266 == 3 { - _t2034 := p.parse_abort() - abort1270 := _t2034 - _t2035 := &pb.Read{} - _t2035.ReadType = &pb.Read_Abort{Abort: abort1270} - _t2033 = _t2035 + var _t2050 *pb.Read + if prediction1274 == 4 { + _t2051 := p.parse_export() + export1279 := _t2051 + _t2052 := &pb.Read{} + _t2052.ReadType = &pb.Read_Export{Export: export1279} + _t2050 = _t2052 } else { - var _t2036 *pb.Read - if prediction1266 == 2 { - _t2037 := p.parse_what_if() - what_if1269 := _t2037 - _t2038 := &pb.Read{} - _t2038.ReadType = &pb.Read_WhatIf{WhatIf: what_if1269} - _t2036 = _t2038 + var _t2053 *pb.Read + if prediction1274 == 3 { + _t2054 := p.parse_abort() + abort1278 := _t2054 + _t2055 := &pb.Read{} + _t2055.ReadType = &pb.Read_Abort{Abort: abort1278} + _t2053 = _t2055 } else { - var _t2039 *pb.Read - if prediction1266 == 1 { - _t2040 := p.parse_output() - output1268 := _t2040 - _t2041 := &pb.Read{} - _t2041.ReadType = &pb.Read_Output{Output: output1268} - _t2039 = _t2041 + var _t2056 *pb.Read + if prediction1274 == 2 { + _t2057 := p.parse_what_if() + what_if1277 := _t2057 + _t2058 := &pb.Read{} + _t2058.ReadType = &pb.Read_WhatIf{WhatIf: what_if1277} + _t2056 = _t2058 } else { - var _t2042 *pb.Read - if prediction1266 == 0 { - _t2043 := p.parse_demand() - demand1267 := _t2043 - _t2044 := &pb.Read{} - _t2044.ReadType = &pb.Read_Demand{Demand: demand1267} - _t2042 = _t2044 + var _t2059 *pb.Read + if prediction1274 == 1 { + _t2060 := p.parse_output() + output1276 := _t2060 + _t2061 := &pb.Read{} + _t2061.ReadType = &pb.Read_Output{Output: output1276} + _t2059 = _t2061 } else { - panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in read", p.lookahead(0).Type, p.lookahead(0).Value)}) + var _t2062 *pb.Read + if prediction1274 == 0 { + _t2063 := p.parse_demand() + demand1275 := _t2063 + _t2064 := &pb.Read{} + _t2064.ReadType = &pb.Read_Demand{Demand: demand1275} + _t2062 = _t2064 + } else { + panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in read", p.lookahead(0).Type, p.lookahead(0).Value)}) + } + _t2059 = _t2062 } - _t2039 = _t2042 + _t2056 = _t2059 } - _t2036 = _t2039 + _t2053 = _t2056 } - _t2033 = _t2036 + _t2050 = _t2053 } - _t2030 = _t2033 + _t2047 = _t2050 } - result1273 := _t2030 - p.recordSpan(int(span_start1272), "Read") - return result1273 + result1282 := _t2047 + p.recordSpan(int(span_start1281), "Read") + return result1282 } func (p *Parser) parse_demand() *pb.Demand { - span_start1275 := int64(p.spanStart()) + span_start1284 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("demand") - _t2045 := p.parse_relation_id() - relation_id1274 := _t2045 + _t2065 := p.parse_relation_id() + relation_id1283 := _t2065 p.consumeLiteral(")") - _t2046 := &pb.Demand{RelationId: relation_id1274} - result1276 := _t2046 - p.recordSpan(int(span_start1275), "Demand") - return result1276 + _t2066 := &pb.Demand{RelationId: relation_id1283} + result1285 := _t2066 + p.recordSpan(int(span_start1284), "Demand") + return result1285 } func (p *Parser) parse_output() *pb.Output { - span_start1279 := int64(p.spanStart()) + span_start1288 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("output") - _t2047 := p.parse_name() - name1277 := _t2047 - _t2048 := p.parse_relation_id() - relation_id1278 := _t2048 + _t2067 := p.parse_name() + name1286 := _t2067 + _t2068 := p.parse_relation_id() + relation_id1287 := _t2068 p.consumeLiteral(")") - _t2049 := &pb.Output{Name: name1277, RelationId: relation_id1278} - result1280 := _t2049 - p.recordSpan(int(span_start1279), "Output") - return result1280 + _t2069 := &pb.Output{Name: name1286, RelationId: relation_id1287} + result1289 := _t2069 + p.recordSpan(int(span_start1288), "Output") + return result1289 } func (p *Parser) parse_what_if() *pb.WhatIf { - span_start1283 := int64(p.spanStart()) + span_start1292 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("what_if") - _t2050 := p.parse_name() - name1281 := _t2050 - _t2051 := p.parse_epoch() - epoch1282 := _t2051 + _t2070 := p.parse_name() + name1290 := _t2070 + _t2071 := p.parse_epoch() + epoch1291 := _t2071 p.consumeLiteral(")") - _t2052 := &pb.WhatIf{Branch: name1281, Epoch: epoch1282} - result1284 := _t2052 - p.recordSpan(int(span_start1283), "WhatIf") - return result1284 + _t2072 := &pb.WhatIf{Branch: name1290, Epoch: epoch1291} + result1293 := _t2072 + p.recordSpan(int(span_start1292), "WhatIf") + return result1293 } func (p *Parser) parse_abort() *pb.Abort { - span_start1287 := int64(p.spanStart()) + span_start1296 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("abort") - var _t2053 *string + var _t2073 *string if (p.matchLookaheadLiteral(":", 0) && p.matchLookaheadTerminal("SYMBOL", 1)) { - _t2054 := p.parse_name() - _t2053 = ptr(_t2054) + _t2074 := p.parse_name() + _t2073 = ptr(_t2074) } - name1285 := _t2053 - _t2055 := p.parse_relation_id() - relation_id1286 := _t2055 + name1294 := _t2073 + _t2075 := p.parse_relation_id() + relation_id1295 := _t2075 p.consumeLiteral(")") - _t2056 := &pb.Abort{Name: deref(name1285, "abort"), RelationId: relation_id1286} - result1288 := _t2056 - p.recordSpan(int(span_start1287), "Abort") - return result1288 + _t2076 := &pb.Abort{Name: deref(name1294, "abort"), RelationId: relation_id1295} + result1297 := _t2076 + p.recordSpan(int(span_start1296), "Abort") + return result1297 } func (p *Parser) parse_export() *pb.Export { - span_start1292 := int64(p.spanStart()) - var _t2057 int64 + span_start1301 := int64(p.spanStart()) + var _t2077 int64 if p.matchLookaheadLiteral("(", 0) { - var _t2058 int64 + var _t2078 int64 if p.matchLookaheadLiteral("export_iceberg", 1) { - _t2058 = 1 + _t2078 = 1 } else { - var _t2059 int64 + var _t2079 int64 if p.matchLookaheadLiteral("export", 1) { - _t2059 = 0 + _t2079 = 0 } else { - _t2059 = -1 + _t2079 = -1 } - _t2058 = _t2059 + _t2078 = _t2079 } - _t2057 = _t2058 + _t2077 = _t2078 } else { - _t2057 = -1 + _t2077 = -1 } - prediction1289 := _t2057 - var _t2060 *pb.Export - if prediction1289 == 1 { + prediction1298 := _t2077 + var _t2080 *pb.Export + if prediction1298 == 1 { p.consumeLiteral("(") p.consumeLiteral("export_iceberg") - _t2061 := p.parse_export_iceberg_config() - export_iceberg_config1291 := _t2061 + _t2081 := p.parse_export_iceberg_config() + export_iceberg_config1300 := _t2081 p.consumeLiteral(")") - _t2062 := &pb.Export{} - _t2062.ExportConfig = &pb.Export_IcebergConfig{IcebergConfig: export_iceberg_config1291} - _t2060 = _t2062 + _t2082 := &pb.Export{} + _t2082.ExportConfig = &pb.Export_IcebergConfig{IcebergConfig: export_iceberg_config1300} + _t2080 = _t2082 } else { - var _t2063 *pb.Export - if prediction1289 == 0 { + var _t2083 *pb.Export + if prediction1298 == 0 { p.consumeLiteral("(") p.consumeLiteral("export") - _t2064 := p.parse_export_csv_config() - export_csv_config1290 := _t2064 + _t2084 := p.parse_export_csv_config() + export_csv_config1299 := _t2084 p.consumeLiteral(")") - _t2065 := &pb.Export{} - _t2065.ExportConfig = &pb.Export_CsvConfig{CsvConfig: export_csv_config1290} - _t2063 = _t2065 + _t2085 := &pb.Export{} + _t2085.ExportConfig = &pb.Export_CsvConfig{CsvConfig: export_csv_config1299} + _t2083 = _t2085 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in export", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t2060 = _t2063 + _t2080 = _t2083 } - result1293 := _t2060 - p.recordSpan(int(span_start1292), "Export") - return result1293 + result1302 := _t2080 + p.recordSpan(int(span_start1301), "Export") + return result1302 } func (p *Parser) parse_export_csv_config() *pb.ExportCSVConfig { - span_start1301 := int64(p.spanStart()) - var _t2066 int64 + span_start1310 := int64(p.spanStart()) + var _t2086 int64 if p.matchLookaheadLiteral("(", 0) { - var _t2067 int64 + var _t2087 int64 if p.matchLookaheadLiteral("export_csv_config_v2", 1) { - _t2067 = 0 + _t2087 = 0 } else { - var _t2068 int64 + var _t2088 int64 if p.matchLookaheadLiteral("export_csv_config", 1) { - _t2068 = 1 + _t2088 = 1 } else { - _t2068 = -1 + _t2088 = -1 } - _t2067 = _t2068 + _t2087 = _t2088 } - _t2066 = _t2067 + _t2086 = _t2087 } else { - _t2066 = -1 + _t2086 = -1 } - prediction1294 := _t2066 - var _t2069 *pb.ExportCSVConfig - if prediction1294 == 1 { + prediction1303 := _t2086 + var _t2089 *pb.ExportCSVConfig + if prediction1303 == 1 { p.consumeLiteral("(") p.consumeLiteral("export_csv_config") - _t2070 := p.parse_export_csv_path() - export_csv_path1298 := _t2070 - _t2071 := p.parse_export_csv_columns_list() - export_csv_columns_list1299 := _t2071 - _t2072 := p.parse_config_dict() - config_dict1300 := _t2072 + _t2090 := p.parse_export_csv_path() + export_csv_path1307 := _t2090 + _t2091 := p.parse_export_csv_columns_list() + export_csv_columns_list1308 := _t2091 + _t2092 := p.parse_config_dict() + config_dict1309 := _t2092 p.consumeLiteral(")") - _t2073 := p.construct_export_csv_config(export_csv_path1298, export_csv_columns_list1299, config_dict1300) - _t2069 = _t2073 + _t2093 := p.construct_export_csv_config(export_csv_path1307, export_csv_columns_list1308, config_dict1309) + _t2089 = _t2093 } else { - var _t2074 *pb.ExportCSVConfig - if prediction1294 == 0 { + var _t2094 *pb.ExportCSVConfig + if prediction1303 == 0 { p.consumeLiteral("(") p.consumeLiteral("export_csv_config_v2") - _t2075 := p.parse_export_csv_path() - export_csv_path1295 := _t2075 - _t2076 := p.parse_export_csv_source() - export_csv_source1296 := _t2076 - _t2077 := p.parse_csv_config() - csv_config1297 := _t2077 + _t2095 := p.parse_export_csv_path() + export_csv_path1304 := _t2095 + _t2096 := p.parse_export_csv_source() + export_csv_source1305 := _t2096 + _t2097 := p.parse_csv_config() + csv_config1306 := _t2097 p.consumeLiteral(")") - _t2078 := p.construct_export_csv_config_with_source(export_csv_path1295, export_csv_source1296, csv_config1297) - _t2074 = _t2078 + _t2098 := p.construct_export_csv_config_with_source(export_csv_path1304, export_csv_source1305, csv_config1306) + _t2094 = _t2098 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in export_csv_config", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t2069 = _t2074 + _t2089 = _t2094 } - result1302 := _t2069 - p.recordSpan(int(span_start1301), "ExportCSVConfig") - return result1302 + result1311 := _t2089 + p.recordSpan(int(span_start1310), "ExportCSVConfig") + return result1311 } func (p *Parser) parse_export_csv_path() string { p.consumeLiteral("(") p.consumeLiteral("path") - string1303 := p.consumeTerminal("STRING").Value.str + string1312 := p.consumeTerminal("STRING").Value.str p.consumeLiteral(")") - return string1303 + return string1312 } func (p *Parser) parse_export_csv_source() *pb.ExportCSVSource { - span_start1310 := int64(p.spanStart()) - var _t2079 int64 + span_start1319 := int64(p.spanStart()) + var _t2099 int64 if p.matchLookaheadLiteral("(", 0) { - var _t2080 int64 + var _t2100 int64 if p.matchLookaheadLiteral("table_def", 1) { - _t2080 = 1 + _t2100 = 1 } else { - var _t2081 int64 + var _t2101 int64 if p.matchLookaheadLiteral("gnf_columns", 1) { - _t2081 = 0 + _t2101 = 0 } else { - _t2081 = -1 + _t2101 = -1 } - _t2080 = _t2081 + _t2100 = _t2101 } - _t2079 = _t2080 + _t2099 = _t2100 } else { - _t2079 = -1 + _t2099 = -1 } - prediction1304 := _t2079 - var _t2082 *pb.ExportCSVSource - if prediction1304 == 1 { + prediction1313 := _t2099 + var _t2102 *pb.ExportCSVSource + if prediction1313 == 1 { p.consumeLiteral("(") p.consumeLiteral("table_def") - _t2083 := p.parse_relation_id() - relation_id1309 := _t2083 + _t2103 := p.parse_relation_id() + relation_id1318 := _t2103 p.consumeLiteral(")") - _t2084 := &pb.ExportCSVSource{} - _t2084.CsvSource = &pb.ExportCSVSource_TableDef{TableDef: relation_id1309} - _t2082 = _t2084 + _t2104 := &pb.ExportCSVSource{} + _t2104.CsvSource = &pb.ExportCSVSource_TableDef{TableDef: relation_id1318} + _t2102 = _t2104 } else { - var _t2085 *pb.ExportCSVSource - if prediction1304 == 0 { + var _t2105 *pb.ExportCSVSource + if prediction1313 == 0 { p.consumeLiteral("(") p.consumeLiteral("gnf_columns") - xs1305 := []*pb.ExportCSVColumn{} - cond1306 := p.matchLookaheadLiteral("(", 0) - for cond1306 { - _t2086 := p.parse_export_csv_column() - item1307 := _t2086 - xs1305 = append(xs1305, item1307) - cond1306 = p.matchLookaheadLiteral("(", 0) + xs1314 := []*pb.ExportCSVColumn{} + cond1315 := p.matchLookaheadLiteral("(", 0) + for cond1315 { + _t2106 := p.parse_export_csv_column() + item1316 := _t2106 + xs1314 = append(xs1314, item1316) + cond1315 = p.matchLookaheadLiteral("(", 0) } - export_csv_columns1308 := xs1305 + export_csv_columns1317 := xs1314 p.consumeLiteral(")") - _t2087 := &pb.ExportCSVColumns{Columns: export_csv_columns1308} - _t2088 := &pb.ExportCSVSource{} - _t2088.CsvSource = &pb.ExportCSVSource_GnfColumns{GnfColumns: _t2087} - _t2085 = _t2088 + _t2107 := &pb.ExportCSVColumns{Columns: export_csv_columns1317} + _t2108 := &pb.ExportCSVSource{} + _t2108.CsvSource = &pb.ExportCSVSource_GnfColumns{GnfColumns: _t2107} + _t2105 = _t2108 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in export_csv_source", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t2082 = _t2085 + _t2102 = _t2105 } - result1311 := _t2082 - p.recordSpan(int(span_start1310), "ExportCSVSource") - return result1311 + result1320 := _t2102 + p.recordSpan(int(span_start1319), "ExportCSVSource") + return result1320 } func (p *Parser) parse_export_csv_column() *pb.ExportCSVColumn { - span_start1314 := int64(p.spanStart()) + span_start1323 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("column") - string1312 := p.consumeTerminal("STRING").Value.str - _t2089 := p.parse_relation_id() - relation_id1313 := _t2089 + string1321 := p.consumeTerminal("STRING").Value.str + _t2109 := p.parse_relation_id() + relation_id1322 := _t2109 p.consumeLiteral(")") - _t2090 := &pb.ExportCSVColumn{ColumnName: string1312, ColumnData: relation_id1313} - result1315 := _t2090 - p.recordSpan(int(span_start1314), "ExportCSVColumn") - return result1315 + _t2110 := &pb.ExportCSVColumn{ColumnName: string1321, ColumnData: relation_id1322} + result1324 := _t2110 + p.recordSpan(int(span_start1323), "ExportCSVColumn") + return result1324 } func (p *Parser) parse_export_csv_columns_list() []*pb.ExportCSVColumn { p.consumeLiteral("(") p.consumeLiteral("columns") - xs1316 := []*pb.ExportCSVColumn{} - cond1317 := p.matchLookaheadLiteral("(", 0) - for cond1317 { - _t2091 := p.parse_export_csv_column() - item1318 := _t2091 - xs1316 = append(xs1316, item1318) - cond1317 = p.matchLookaheadLiteral("(", 0) - } - export_csv_columns1319 := xs1316 + xs1325 := []*pb.ExportCSVColumn{} + cond1326 := p.matchLookaheadLiteral("(", 0) + for cond1326 { + _t2111 := p.parse_export_csv_column() + item1327 := _t2111 + xs1325 = append(xs1325, item1327) + cond1326 = p.matchLookaheadLiteral("(", 0) + } + export_csv_columns1328 := xs1325 p.consumeLiteral(")") - return export_csv_columns1319 + return export_csv_columns1328 } func (p *Parser) parse_export_iceberg_config() *pb.ExportIcebergConfig { - span_start1325 := int64(p.spanStart()) + span_start1334 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("export_iceberg_config") - _t2092 := p.parse_iceberg_locator() - iceberg_locator1320 := _t2092 - _t2093 := p.parse_iceberg_catalog_config() - iceberg_catalog_config1321 := _t2093 - _t2094 := p.parse_export_iceberg_table_def() - export_iceberg_table_def1322 := _t2094 - _t2095 := p.parse_iceberg_table_properties() - iceberg_table_properties1323 := _t2095 - var _t2096 [][]interface{} + _t2112 := p.parse_iceberg_locator() + iceberg_locator1329 := _t2112 + _t2113 := p.parse_iceberg_catalog_config() + iceberg_catalog_config1330 := _t2113 + _t2114 := p.parse_export_iceberg_table_def() + export_iceberg_table_def1331 := _t2114 + _t2115 := p.parse_iceberg_table_properties() + iceberg_table_properties1332 := _t2115 + var _t2116 [][]interface{} if p.matchLookaheadLiteral("{", 0) { - _t2097 := p.parse_config_dict() - _t2096 = _t2097 + _t2117 := p.parse_config_dict() + _t2116 = _t2117 } - config_dict1324 := _t2096 + config_dict1333 := _t2116 p.consumeLiteral(")") - _t2098 := p.construct_export_iceberg_config_full(iceberg_locator1320, iceberg_catalog_config1321, export_iceberg_table_def1322, iceberg_table_properties1323, config_dict1324) - result1326 := _t2098 - p.recordSpan(int(span_start1325), "ExportIcebergConfig") - return result1326 + _t2118 := p.construct_export_iceberg_config_full(iceberg_locator1329, iceberg_catalog_config1330, export_iceberg_table_def1331, iceberg_table_properties1332, config_dict1333) + result1335 := _t2118 + p.recordSpan(int(span_start1334), "ExportIcebergConfig") + return result1335 } func (p *Parser) parse_export_iceberg_table_def() *pb.RelationId { - span_start1328 := int64(p.spanStart()) + span_start1337 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("table_def") - _t2099 := p.parse_relation_id() - relation_id1327 := _t2099 + _t2119 := p.parse_relation_id() + relation_id1336 := _t2119 p.consumeLiteral(")") - result1329 := relation_id1327 - p.recordSpan(int(span_start1328), "RelationId") - return result1329 + result1338 := relation_id1336 + p.recordSpan(int(span_start1337), "RelationId") + return result1338 } func (p *Parser) parse_iceberg_table_properties() [][]interface{} { p.consumeLiteral("(") p.consumeLiteral("table_properties") - xs1330 := [][]interface{}{} - cond1331 := p.matchLookaheadLiteral("(", 0) - for cond1331 { - _t2100 := p.parse_iceberg_property_entry() - item1332 := _t2100 - xs1330 = append(xs1330, item1332) - cond1331 = p.matchLookaheadLiteral("(", 0) - } - iceberg_property_entrys1333 := xs1330 + xs1339 := [][]interface{}{} + cond1340 := p.matchLookaheadLiteral("(", 0) + for cond1340 { + _t2120 := p.parse_iceberg_property_entry() + item1341 := _t2120 + xs1339 = append(xs1339, item1341) + cond1340 = p.matchLookaheadLiteral("(", 0) + } + iceberg_property_entrys1342 := xs1339 + p.consumeLiteral(")") + return iceberg_property_entrys1342 +} + +func (p *Parser) parse_export_output() *pb.ExportOutput { + span_start1344 := int64(p.spanStart()) + p.consumeLiteral("(") + p.consumeLiteral("output_export") + _t2121 := p.parse_export_csv_output() + export_csv_output1343 := _t2121 + p.consumeLiteral(")") + _t2122 := &pb.ExportOutput{} + _t2122.ExportOutput = &pb.ExportOutput_Csv{Csv: export_csv_output1343} + result1345 := _t2122 + p.recordSpan(int(span_start1344), "ExportOutput") + return result1345 +} + +func (p *Parser) parse_export_csv_output() *pb.ExportCSVOutput { + span_start1348 := int64(p.spanStart()) + p.consumeLiteral("(") + p.consumeLiteral("csv") + _t2123 := p.parse_export_csv_source() + export_csv_source1346 := _t2123 + _t2124 := p.parse_csv_config() + csv_config1347 := _t2124 p.consumeLiteral(")") - return iceberg_property_entrys1333 + _t2125 := &pb.ExportCSVOutput{CsvSource: export_csv_source1346, CsvConfig: csv_config1347} + result1349 := _t2125 + p.recordSpan(int(span_start1348), "ExportCSVOutput") + return result1349 } diff --git a/sdks/go/src/pretty.go b/sdks/go/src/pretty.go index 9d97d637..65770285 100644 --- a/sdks/go/src/pretty.go +++ b/sdks/go/src/pretty.go @@ -343,188 +343,188 @@ func formatBool(b bool) string { // --- Helper functions --- func (p *PrettyPrinter) _make_value_int32(v int32) *pb.Value { - _t1742 := &pb.Value{} - _t1742.Value = &pb.Value_Int32Value{Int32Value: v} - return _t1742 + _t1764 := &pb.Value{} + _t1764.Value = &pb.Value_Int32Value{Int32Value: v} + return _t1764 } func (p *PrettyPrinter) _make_value_int64(v int64) *pb.Value { - _t1743 := &pb.Value{} - _t1743.Value = &pb.Value_IntValue{IntValue: v} - return _t1743 + _t1765 := &pb.Value{} + _t1765.Value = &pb.Value_IntValue{IntValue: v} + return _t1765 } func (p *PrettyPrinter) _make_value_float64(v float64) *pb.Value { - _t1744 := &pb.Value{} - _t1744.Value = &pb.Value_FloatValue{FloatValue: v} - return _t1744 + _t1766 := &pb.Value{} + _t1766.Value = &pb.Value_FloatValue{FloatValue: v} + return _t1766 } func (p *PrettyPrinter) _make_value_string(v string) *pb.Value { - _t1745 := &pb.Value{} - _t1745.Value = &pb.Value_StringValue{StringValue: v} - return _t1745 + _t1767 := &pb.Value{} + _t1767.Value = &pb.Value_StringValue{StringValue: v} + return _t1767 } func (p *PrettyPrinter) _make_value_boolean(v bool) *pb.Value { - _t1746 := &pb.Value{} - _t1746.Value = &pb.Value_BooleanValue{BooleanValue: v} - return _t1746 + _t1768 := &pb.Value{} + _t1768.Value = &pb.Value_BooleanValue{BooleanValue: v} + return _t1768 } func (p *PrettyPrinter) _make_value_uint128(v *pb.UInt128Value) *pb.Value { - _t1747 := &pb.Value{} - _t1747.Value = &pb.Value_Uint128Value{Uint128Value: v} - return _t1747 + _t1769 := &pb.Value{} + _t1769.Value = &pb.Value_Uint128Value{Uint128Value: v} + return _t1769 } func (p *PrettyPrinter) deconstruct_configure(msg *pb.Configure) [][]interface{} { result := [][]interface{}{} if msg.GetIvmConfig().GetLevel() == pb.MaintenanceLevel_MAINTENANCE_LEVEL_AUTO { - _t1748 := p._make_value_string("auto") - result = append(result, []interface{}{"ivm.maintenance_level", _t1748}) + _t1770 := p._make_value_string("auto") + result = append(result, []interface{}{"ivm.maintenance_level", _t1770}) } else { if msg.GetIvmConfig().GetLevel() == pb.MaintenanceLevel_MAINTENANCE_LEVEL_ALL { - _t1749 := p._make_value_string("all") - result = append(result, []interface{}{"ivm.maintenance_level", _t1749}) + _t1771 := p._make_value_string("all") + result = append(result, []interface{}{"ivm.maintenance_level", _t1771}) } else { if msg.GetIvmConfig().GetLevel() == pb.MaintenanceLevel_MAINTENANCE_LEVEL_OFF { - _t1750 := p._make_value_string("off") - result = append(result, []interface{}{"ivm.maintenance_level", _t1750}) + _t1772 := p._make_value_string("off") + result = append(result, []interface{}{"ivm.maintenance_level", _t1772}) } } } - _t1751 := p._make_value_int64(msg.GetSemanticsVersion()) - result = append(result, []interface{}{"semantics_version", _t1751}) + _t1773 := p._make_value_int64(msg.GetSemanticsVersion()) + result = append(result, []interface{}{"semantics_version", _t1773}) return listSort(result) } func (p *PrettyPrinter) deconstruct_csv_config(msg *pb.CSVConfig) [][]interface{} { result := [][]interface{}{} - _t1752 := p._make_value_int32(msg.GetHeaderRow()) - result = append(result, []interface{}{"csv_header_row", _t1752}) - _t1753 := p._make_value_int64(msg.GetSkip()) - result = append(result, []interface{}{"csv_skip", _t1753}) + _t1774 := p._make_value_int32(msg.GetHeaderRow()) + result = append(result, []interface{}{"csv_header_row", _t1774}) + _t1775 := p._make_value_int64(msg.GetSkip()) + result = append(result, []interface{}{"csv_skip", _t1775}) if msg.GetNewLine() != "" { - _t1754 := p._make_value_string(msg.GetNewLine()) - result = append(result, []interface{}{"csv_new_line", _t1754}) - } - _t1755 := p._make_value_string(msg.GetDelimiter()) - result = append(result, []interface{}{"csv_delimiter", _t1755}) - _t1756 := p._make_value_string(msg.GetQuotechar()) - result = append(result, []interface{}{"csv_quotechar", _t1756}) - _t1757 := p._make_value_string(msg.GetEscapechar()) - result = append(result, []interface{}{"csv_escapechar", _t1757}) + _t1776 := p._make_value_string(msg.GetNewLine()) + result = append(result, []interface{}{"csv_new_line", _t1776}) + } + _t1777 := p._make_value_string(msg.GetDelimiter()) + result = append(result, []interface{}{"csv_delimiter", _t1777}) + _t1778 := p._make_value_string(msg.GetQuotechar()) + result = append(result, []interface{}{"csv_quotechar", _t1778}) + _t1779 := p._make_value_string(msg.GetEscapechar()) + result = append(result, []interface{}{"csv_escapechar", _t1779}) if msg.GetComment() != "" { - _t1758 := p._make_value_string(msg.GetComment()) - result = append(result, []interface{}{"csv_comment", _t1758}) + _t1780 := p._make_value_string(msg.GetComment()) + result = append(result, []interface{}{"csv_comment", _t1780}) } for _, missing_string := range msg.GetMissingStrings() { - _t1759 := p._make_value_string(missing_string) - result = append(result, []interface{}{"csv_missing_strings", _t1759}) - } - _t1760 := p._make_value_string(msg.GetDecimalSeparator()) - result = append(result, []interface{}{"csv_decimal_separator", _t1760}) - _t1761 := p._make_value_string(msg.GetEncoding()) - result = append(result, []interface{}{"csv_encoding", _t1761}) - _t1762 := p._make_value_string(msg.GetCompression()) - result = append(result, []interface{}{"csv_compression", _t1762}) + _t1781 := p._make_value_string(missing_string) + result = append(result, []interface{}{"csv_missing_strings", _t1781}) + } + _t1782 := p._make_value_string(msg.GetDecimalSeparator()) + result = append(result, []interface{}{"csv_decimal_separator", _t1782}) + _t1783 := p._make_value_string(msg.GetEncoding()) + result = append(result, []interface{}{"csv_encoding", _t1783}) + _t1784 := p._make_value_string(msg.GetCompression()) + result = append(result, []interface{}{"csv_compression", _t1784}) if msg.GetPartitionSizeMb() != 0 { - _t1763 := p._make_value_int64(msg.GetPartitionSizeMb()) - result = append(result, []interface{}{"csv_partition_size_mb", _t1763}) + _t1785 := p._make_value_int64(msg.GetPartitionSizeMb()) + result = append(result, []interface{}{"csv_partition_size_mb", _t1785}) } return listSort(result) } func (p *PrettyPrinter) deconstruct_csv_storage_integration_optional(msg *pb.CSVConfig) [][]interface{} { - var _t1764 interface{} + var _t1786 interface{} if !(hasProtoField(msg, "storage_integration")) { return nil } - _ = _t1764 + _ = _t1786 si := msg.GetStorageIntegration() result := [][]interface{}{} if si.GetProvider() != "" { - _t1765 := p._make_value_string(si.GetProvider()) - result = append(result, []interface{}{"provider", _t1765}) + _t1787 := p._make_value_string(si.GetProvider()) + result = append(result, []interface{}{"provider", _t1787}) } if si.GetAzureSasToken() != "" { - _t1766 := p._make_value_string("***") - result = append(result, []interface{}{"azure_sas_token", _t1766}) + _t1788 := p._make_value_string("***") + result = append(result, []interface{}{"azure_sas_token", _t1788}) } if si.GetS3Region() != "" { - _t1767 := p._make_value_string(si.GetS3Region()) - result = append(result, []interface{}{"s3_region", _t1767}) + _t1789 := p._make_value_string(si.GetS3Region()) + result = append(result, []interface{}{"s3_region", _t1789}) } if si.GetS3AccessKeyId() != "" { - _t1768 := p._make_value_string("***") - result = append(result, []interface{}{"s3_access_key_id", _t1768}) + _t1790 := p._make_value_string("***") + result = append(result, []interface{}{"s3_access_key_id", _t1790}) } if si.GetS3SecretAccessKey() != "" { - _t1769 := p._make_value_string("***") - result = append(result, []interface{}{"s3_secret_access_key", _t1769}) + _t1791 := p._make_value_string("***") + result = append(result, []interface{}{"s3_secret_access_key", _t1791}) } return listSort(result) } func (p *PrettyPrinter) deconstruct_betree_info_config(msg *pb.BeTreeInfo) [][]interface{} { result := [][]interface{}{} - _t1770 := p._make_value_float64(msg.GetStorageConfig().GetEpsilon()) - result = append(result, []interface{}{"betree_config_epsilon", _t1770}) - _t1771 := p._make_value_int64(msg.GetStorageConfig().GetMaxPivots()) - result = append(result, []interface{}{"betree_config_max_pivots", _t1771}) - _t1772 := p._make_value_int64(msg.GetStorageConfig().GetMaxDeltas()) - result = append(result, []interface{}{"betree_config_max_deltas", _t1772}) - _t1773 := p._make_value_int64(msg.GetStorageConfig().GetMaxLeaf()) - result = append(result, []interface{}{"betree_config_max_leaf", _t1773}) + _t1792 := p._make_value_float64(msg.GetStorageConfig().GetEpsilon()) + result = append(result, []interface{}{"betree_config_epsilon", _t1792}) + _t1793 := p._make_value_int64(msg.GetStorageConfig().GetMaxPivots()) + result = append(result, []interface{}{"betree_config_max_pivots", _t1793}) + _t1794 := p._make_value_int64(msg.GetStorageConfig().GetMaxDeltas()) + result = append(result, []interface{}{"betree_config_max_deltas", _t1794}) + _t1795 := p._make_value_int64(msg.GetStorageConfig().GetMaxLeaf()) + result = append(result, []interface{}{"betree_config_max_leaf", _t1795}) if hasProtoField(msg.GetRelationLocator(), "root_pageid") { if msg.GetRelationLocator().GetRootPageid() != nil { - _t1774 := p._make_value_uint128(msg.GetRelationLocator().GetRootPageid()) - result = append(result, []interface{}{"betree_locator_root_pageid", _t1774}) + _t1796 := p._make_value_uint128(msg.GetRelationLocator().GetRootPageid()) + result = append(result, []interface{}{"betree_locator_root_pageid", _t1796}) } } if hasProtoField(msg.GetRelationLocator(), "inline_data") { if msg.GetRelationLocator().GetInlineData() != nil { - _t1775 := p._make_value_string(string(msg.GetRelationLocator().GetInlineData())) - result = append(result, []interface{}{"betree_locator_inline_data", _t1775}) + _t1797 := p._make_value_string(string(msg.GetRelationLocator().GetInlineData())) + result = append(result, []interface{}{"betree_locator_inline_data", _t1797}) } } - _t1776 := p._make_value_int64(msg.GetRelationLocator().GetElementCount()) - result = append(result, []interface{}{"betree_locator_element_count", _t1776}) - _t1777 := p._make_value_int64(msg.GetRelationLocator().GetTreeHeight()) - result = append(result, []interface{}{"betree_locator_tree_height", _t1777}) + _t1798 := p._make_value_int64(msg.GetRelationLocator().GetElementCount()) + result = append(result, []interface{}{"betree_locator_element_count", _t1798}) + _t1799 := p._make_value_int64(msg.GetRelationLocator().GetTreeHeight()) + result = append(result, []interface{}{"betree_locator_tree_height", _t1799}) return listSort(result) } func (p *PrettyPrinter) deconstruct_export_csv_config(msg *pb.ExportCSVConfig) [][]interface{} { result := [][]interface{}{} if msg.PartitionSize != nil { - _t1778 := p._make_value_int64(*msg.PartitionSize) - result = append(result, []interface{}{"partition_size", _t1778}) + _t1800 := p._make_value_int64(*msg.PartitionSize) + result = append(result, []interface{}{"partition_size", _t1800}) } if msg.Compression != nil { - _t1779 := p._make_value_string(*msg.Compression) - result = append(result, []interface{}{"compression", _t1779}) + _t1801 := p._make_value_string(*msg.Compression) + result = append(result, []interface{}{"compression", _t1801}) } if msg.SyntaxHeaderRow != nil { - _t1780 := p._make_value_boolean(*msg.SyntaxHeaderRow) - result = append(result, []interface{}{"syntax_header_row", _t1780}) + _t1802 := p._make_value_boolean(*msg.SyntaxHeaderRow) + result = append(result, []interface{}{"syntax_header_row", _t1802}) } if msg.SyntaxMissingString != nil { - _t1781 := p._make_value_string(*msg.SyntaxMissingString) - result = append(result, []interface{}{"syntax_missing_string", _t1781}) + _t1803 := p._make_value_string(*msg.SyntaxMissingString) + result = append(result, []interface{}{"syntax_missing_string", _t1803}) } if msg.SyntaxDelim != nil { - _t1782 := p._make_value_string(*msg.SyntaxDelim) - result = append(result, []interface{}{"syntax_delim", _t1782}) + _t1804 := p._make_value_string(*msg.SyntaxDelim) + result = append(result, []interface{}{"syntax_delim", _t1804}) } if msg.SyntaxQuotechar != nil { - _t1783 := p._make_value_string(*msg.SyntaxQuotechar) - result = append(result, []interface{}{"syntax_quotechar", _t1783}) + _t1805 := p._make_value_string(*msg.SyntaxQuotechar) + result = append(result, []interface{}{"syntax_quotechar", _t1805}) } if msg.SyntaxEscapechar != nil { - _t1784 := p._make_value_string(*msg.SyntaxEscapechar) - result = append(result, []interface{}{"syntax_escapechar", _t1784}) + _t1806 := p._make_value_string(*msg.SyntaxEscapechar) + result = append(result, []interface{}{"syntax_escapechar", _t1806}) } return listSort(result) } @@ -534,51 +534,51 @@ func (p *PrettyPrinter) mask_secret_value(pair []interface{}) string { } func (p *PrettyPrinter) deconstruct_iceberg_catalog_config_scope_optional(msg *pb.IcebergCatalogConfig) *string { - var _t1785 interface{} + var _t1807 interface{} if *msg.Scope != "" { return ptr(*msg.Scope) } - _ = _t1785 + _ = _t1807 return nil } func (p *PrettyPrinter) deconstruct_iceberg_data_from_snapshot_optional(msg *pb.IcebergData) *string { - var _t1786 interface{} + var _t1808 interface{} if *msg.FromSnapshot != "" { return ptr(*msg.FromSnapshot) } - _ = _t1786 + _ = _t1808 return nil } func (p *PrettyPrinter) deconstruct_iceberg_data_to_snapshot_optional(msg *pb.IcebergData) *string { - var _t1787 interface{} + var _t1809 interface{} if *msg.ToSnapshot != "" { return ptr(*msg.ToSnapshot) } - _ = _t1787 + _ = _t1809 return nil } func (p *PrettyPrinter) deconstruct_export_iceberg_config_optional(msg *pb.ExportIcebergConfig) [][]interface{} { result := [][]interface{}{} if *msg.Prefix != "" { - _t1788 := p._make_value_string(*msg.Prefix) - result = append(result, []interface{}{"prefix", _t1788}) + _t1810 := p._make_value_string(*msg.Prefix) + result = append(result, []interface{}{"prefix", _t1810}) } if *msg.TargetFileSizeBytes != 0 { - _t1789 := p._make_value_int64(*msg.TargetFileSizeBytes) - result = append(result, []interface{}{"target_file_size_bytes", _t1789}) + _t1811 := p._make_value_int64(*msg.TargetFileSizeBytes) + result = append(result, []interface{}{"target_file_size_bytes", _t1811}) } if msg.GetCompression() != "" { - _t1790 := p._make_value_string(msg.GetCompression()) - result = append(result, []interface{}{"compression", _t1790}) + _t1812 := p._make_value_string(msg.GetCompression()) + result = append(result, []interface{}{"compression", _t1812}) } - var _t1791 interface{} + var _t1813 interface{} if int64(len(result)) == 0 { return nil } - _ = _t1791 + _ = _t1813 return listSort(result) } @@ -589,11 +589,11 @@ func (p *PrettyPrinter) deconstruct_relation_id_string(msg *pb.RelationId) strin func (p *PrettyPrinter) deconstruct_relation_id_uint128(msg *pb.RelationId) *pb.UInt128Value { name := p.relationIdToString(msg) - var _t1792 interface{} + var _t1814 interface{} if name == nil { return p.relationIdToUint128(msg) } - _ = _t1792 + _ = _t1814 return nil } @@ -611,45 +611,45 @@ func (p *PrettyPrinter) deconstruct_bindings_with_arity(abs *pb.Abstraction, val // --- Pretty-print methods --- func (p *PrettyPrinter) pretty_transaction(msg *pb.Transaction) interface{} { - flat808 := p.tryFlat(msg, func() { p.pretty_transaction(msg) }) - if flat808 != nil { - p.write(*flat808) + flat818 := p.tryFlat(msg, func() { p.pretty_transaction(msg) }) + if flat818 != nil { + p.write(*flat818) return nil } else { _dollar_dollar := msg - var _t1598 *pb.Configure + var _t1618 *pb.Configure if hasProtoField(_dollar_dollar, "configure") { - _t1598 = _dollar_dollar.GetConfigure() + _t1618 = _dollar_dollar.GetConfigure() } - var _t1599 *pb.Sync + var _t1619 *pb.Sync if hasProtoField(_dollar_dollar, "sync") { - _t1599 = _dollar_dollar.GetSync() + _t1619 = _dollar_dollar.GetSync() } - fields799 := []interface{}{_t1598, _t1599, _dollar_dollar.GetEpochs()} - unwrapped_fields800 := fields799 + fields809 := []interface{}{_t1618, _t1619, _dollar_dollar.GetEpochs()} + unwrapped_fields810 := fields809 p.write("(") p.write("transaction") p.indentSexp() - field801 := unwrapped_fields800[0].(*pb.Configure) - if field801 != nil { + field811 := unwrapped_fields810[0].(*pb.Configure) + if field811 != nil { p.newline() - opt_val802 := field801 - p.pretty_configure(opt_val802) + opt_val812 := field811 + p.pretty_configure(opt_val812) } - field803 := unwrapped_fields800[1].(*pb.Sync) - if field803 != nil { + field813 := unwrapped_fields810[1].(*pb.Sync) + if field813 != nil { p.newline() - opt_val804 := field803 - p.pretty_sync(opt_val804) + opt_val814 := field813 + p.pretty_sync(opt_val814) } - field805 := unwrapped_fields800[2].([]*pb.Epoch) - if !(len(field805) == 0) { + field815 := unwrapped_fields810[2].([]*pb.Epoch) + if !(len(field815) == 0) { p.newline() - for i807, elem806 := range field805 { - if (i807 > 0) { + for i817, elem816 := range field815 { + if (i817 > 0) { p.newline() } - p.pretty_epoch(elem806) + p.pretty_epoch(elem816) } } p.dedent() @@ -659,20 +659,20 @@ func (p *PrettyPrinter) pretty_transaction(msg *pb.Transaction) interface{} { } func (p *PrettyPrinter) pretty_configure(msg *pb.Configure) interface{} { - flat811 := p.tryFlat(msg, func() { p.pretty_configure(msg) }) - if flat811 != nil { - p.write(*flat811) + flat821 := p.tryFlat(msg, func() { p.pretty_configure(msg) }) + if flat821 != nil { + p.write(*flat821) return nil } else { _dollar_dollar := msg - _t1600 := p.deconstruct_configure(_dollar_dollar) - fields809 := _t1600 - unwrapped_fields810 := fields809 + _t1620 := p.deconstruct_configure(_dollar_dollar) + fields819 := _t1620 + unwrapped_fields820 := fields819 p.write("(") p.write("configure") p.indentSexp() p.newline() - p.pretty_config_dict(unwrapped_fields810) + p.pretty_config_dict(unwrapped_fields820) p.dedent() p.write(")") } @@ -680,21 +680,21 @@ func (p *PrettyPrinter) pretty_configure(msg *pb.Configure) interface{} { } func (p *PrettyPrinter) pretty_config_dict(msg [][]interface{}) interface{} { - flat815 := p.tryFlat(msg, func() { p.pretty_config_dict(msg) }) - if flat815 != nil { - p.write(*flat815) + flat825 := p.tryFlat(msg, func() { p.pretty_config_dict(msg) }) + if flat825 != nil { + p.write(*flat825) return nil } else { - fields812 := msg + fields822 := msg p.write("{") p.indent() - if !(len(fields812) == 0) { + if !(len(fields822) == 0) { p.newline() - for i814, elem813 := range fields812 { - if (i814 > 0) { + for i824, elem823 := range fields822 { + if (i824 > 0) { p.newline() } - p.pretty_config_key_value(elem813) + p.pretty_config_key_value(elem823) } } p.dedent() @@ -704,152 +704,152 @@ func (p *PrettyPrinter) pretty_config_dict(msg [][]interface{}) interface{} { } func (p *PrettyPrinter) pretty_config_key_value(msg []interface{}) interface{} { - flat820 := p.tryFlat(msg, func() { p.pretty_config_key_value(msg) }) - if flat820 != nil { - p.write(*flat820) + flat830 := p.tryFlat(msg, func() { p.pretty_config_key_value(msg) }) + if flat830 != nil { + p.write(*flat830) return nil } else { _dollar_dollar := msg - fields816 := []interface{}{_dollar_dollar[0].(string), _dollar_dollar[1].(*pb.Value)} - unwrapped_fields817 := fields816 + fields826 := []interface{}{_dollar_dollar[0].(string), _dollar_dollar[1].(*pb.Value)} + unwrapped_fields827 := fields826 p.write(":") - field818 := unwrapped_fields817[0].(string) - p.write(field818) + field828 := unwrapped_fields827[0].(string) + p.write(field828) p.write(" ") - field819 := unwrapped_fields817[1].(*pb.Value) - p.pretty_raw_value(field819) + field829 := unwrapped_fields827[1].(*pb.Value) + p.pretty_raw_value(field829) } return nil } func (p *PrettyPrinter) pretty_raw_value(msg *pb.Value) interface{} { - flat846 := p.tryFlat(msg, func() { p.pretty_raw_value(msg) }) - if flat846 != nil { - p.write(*flat846) + flat856 := p.tryFlat(msg, func() { p.pretty_raw_value(msg) }) + if flat856 != nil { + p.write(*flat856) return nil } else { _dollar_dollar := msg - var _t1601 *pb.DateValue + var _t1621 *pb.DateValue if hasProtoField(_dollar_dollar, "date_value") { - _t1601 = _dollar_dollar.GetDateValue() + _t1621 = _dollar_dollar.GetDateValue() } - deconstruct_result844 := _t1601 - if deconstruct_result844 != nil { - unwrapped845 := deconstruct_result844 - p.pretty_raw_date(unwrapped845) + deconstruct_result854 := _t1621 + if deconstruct_result854 != nil { + unwrapped855 := deconstruct_result854 + p.pretty_raw_date(unwrapped855) } else { _dollar_dollar := msg - var _t1602 *pb.DateTimeValue + var _t1622 *pb.DateTimeValue if hasProtoField(_dollar_dollar, "datetime_value") { - _t1602 = _dollar_dollar.GetDatetimeValue() + _t1622 = _dollar_dollar.GetDatetimeValue() } - deconstruct_result842 := _t1602 - if deconstruct_result842 != nil { - unwrapped843 := deconstruct_result842 - p.pretty_raw_datetime(unwrapped843) + deconstruct_result852 := _t1622 + if deconstruct_result852 != nil { + unwrapped853 := deconstruct_result852 + p.pretty_raw_datetime(unwrapped853) } else { _dollar_dollar := msg - var _t1603 *string + var _t1623 *string if hasProtoField(_dollar_dollar, "string_value") { - _t1603 = ptr(_dollar_dollar.GetStringValue()) + _t1623 = ptr(_dollar_dollar.GetStringValue()) } - deconstruct_result840 := _t1603 - if deconstruct_result840 != nil { - unwrapped841 := *deconstruct_result840 - p.write(p.formatStringValue(unwrapped841)) + deconstruct_result850 := _t1623 + if deconstruct_result850 != nil { + unwrapped851 := *deconstruct_result850 + p.write(p.formatStringValue(unwrapped851)) } else { _dollar_dollar := msg - var _t1604 *int32 + var _t1624 *int32 if hasProtoField(_dollar_dollar, "int32_value") { - _t1604 = ptr(_dollar_dollar.GetInt32Value()) + _t1624 = ptr(_dollar_dollar.GetInt32Value()) } - deconstruct_result838 := _t1604 - if deconstruct_result838 != nil { - unwrapped839 := *deconstruct_result838 - p.write(fmt.Sprintf("%di32", unwrapped839)) + deconstruct_result848 := _t1624 + if deconstruct_result848 != nil { + unwrapped849 := *deconstruct_result848 + p.write(fmt.Sprintf("%di32", unwrapped849)) } else { _dollar_dollar := msg - var _t1605 *int64 + var _t1625 *int64 if hasProtoField(_dollar_dollar, "int_value") { - _t1605 = ptr(_dollar_dollar.GetIntValue()) + _t1625 = ptr(_dollar_dollar.GetIntValue()) } - deconstruct_result836 := _t1605 - if deconstruct_result836 != nil { - unwrapped837 := *deconstruct_result836 - p.write(fmt.Sprintf("%d", unwrapped837)) + deconstruct_result846 := _t1625 + if deconstruct_result846 != nil { + unwrapped847 := *deconstruct_result846 + p.write(fmt.Sprintf("%d", unwrapped847)) } else { _dollar_dollar := msg - var _t1606 *float32 + var _t1626 *float32 if hasProtoField(_dollar_dollar, "float32_value") { - _t1606 = ptr(_dollar_dollar.GetFloat32Value()) + _t1626 = ptr(_dollar_dollar.GetFloat32Value()) } - deconstruct_result834 := _t1606 - if deconstruct_result834 != nil { - unwrapped835 := *deconstruct_result834 - p.write(formatFloat32(unwrapped835)) + deconstruct_result844 := _t1626 + if deconstruct_result844 != nil { + unwrapped845 := *deconstruct_result844 + p.write(formatFloat32(unwrapped845)) } else { _dollar_dollar := msg - var _t1607 *float64 + var _t1627 *float64 if hasProtoField(_dollar_dollar, "float_value") { - _t1607 = ptr(_dollar_dollar.GetFloatValue()) + _t1627 = ptr(_dollar_dollar.GetFloatValue()) } - deconstruct_result832 := _t1607 - if deconstruct_result832 != nil { - unwrapped833 := *deconstruct_result832 - p.write(formatFloat64(unwrapped833)) + deconstruct_result842 := _t1627 + if deconstruct_result842 != nil { + unwrapped843 := *deconstruct_result842 + p.write(formatFloat64(unwrapped843)) } else { _dollar_dollar := msg - var _t1608 *uint32 + var _t1628 *uint32 if hasProtoField(_dollar_dollar, "uint32_value") { - _t1608 = ptr(_dollar_dollar.GetUint32Value()) + _t1628 = ptr(_dollar_dollar.GetUint32Value()) } - deconstruct_result830 := _t1608 - if deconstruct_result830 != nil { - unwrapped831 := *deconstruct_result830 - p.write(fmt.Sprintf("%du32", unwrapped831)) + deconstruct_result840 := _t1628 + if deconstruct_result840 != nil { + unwrapped841 := *deconstruct_result840 + p.write(fmt.Sprintf("%du32", unwrapped841)) } else { _dollar_dollar := msg - var _t1609 *pb.UInt128Value + var _t1629 *pb.UInt128Value if hasProtoField(_dollar_dollar, "uint128_value") { - _t1609 = _dollar_dollar.GetUint128Value() + _t1629 = _dollar_dollar.GetUint128Value() } - deconstruct_result828 := _t1609 - if deconstruct_result828 != nil { - unwrapped829 := deconstruct_result828 - p.write(p.formatUint128(unwrapped829)) + deconstruct_result838 := _t1629 + if deconstruct_result838 != nil { + unwrapped839 := deconstruct_result838 + p.write(p.formatUint128(unwrapped839)) } else { _dollar_dollar := msg - var _t1610 *pb.Int128Value + var _t1630 *pb.Int128Value if hasProtoField(_dollar_dollar, "int128_value") { - _t1610 = _dollar_dollar.GetInt128Value() + _t1630 = _dollar_dollar.GetInt128Value() } - deconstruct_result826 := _t1610 - if deconstruct_result826 != nil { - unwrapped827 := deconstruct_result826 - p.write(p.formatInt128(unwrapped827)) + deconstruct_result836 := _t1630 + if deconstruct_result836 != nil { + unwrapped837 := deconstruct_result836 + p.write(p.formatInt128(unwrapped837)) } else { _dollar_dollar := msg - var _t1611 *pb.DecimalValue + var _t1631 *pb.DecimalValue if hasProtoField(_dollar_dollar, "decimal_value") { - _t1611 = _dollar_dollar.GetDecimalValue() + _t1631 = _dollar_dollar.GetDecimalValue() } - deconstruct_result824 := _t1611 - if deconstruct_result824 != nil { - unwrapped825 := deconstruct_result824 - p.write(p.formatDecimal(unwrapped825)) + deconstruct_result834 := _t1631 + if deconstruct_result834 != nil { + unwrapped835 := deconstruct_result834 + p.write(p.formatDecimal(unwrapped835)) } else { _dollar_dollar := msg - var _t1612 *bool + var _t1632 *bool if hasProtoField(_dollar_dollar, "boolean_value") { - _t1612 = ptr(_dollar_dollar.GetBooleanValue()) + _t1632 = ptr(_dollar_dollar.GetBooleanValue()) } - deconstruct_result822 := _t1612 - if deconstruct_result822 != nil { - unwrapped823 := *deconstruct_result822 - p.pretty_boolean_value(unwrapped823) + deconstruct_result832 := _t1632 + if deconstruct_result832 != nil { + unwrapped833 := *deconstruct_result832 + p.pretty_boolean_value(unwrapped833) } else { - fields821 := msg - _ = fields821 + fields831 := msg + _ = fields831 p.write("missing") } } @@ -868,26 +868,26 @@ func (p *PrettyPrinter) pretty_raw_value(msg *pb.Value) interface{} { } func (p *PrettyPrinter) pretty_raw_date(msg *pb.DateValue) interface{} { - flat852 := p.tryFlat(msg, func() { p.pretty_raw_date(msg) }) - if flat852 != nil { - p.write(*flat852) + flat862 := p.tryFlat(msg, func() { p.pretty_raw_date(msg) }) + if flat862 != nil { + p.write(*flat862) return nil } else { _dollar_dollar := msg - fields847 := []interface{}{int64(_dollar_dollar.GetYear()), int64(_dollar_dollar.GetMonth()), int64(_dollar_dollar.GetDay())} - unwrapped_fields848 := fields847 + fields857 := []interface{}{int64(_dollar_dollar.GetYear()), int64(_dollar_dollar.GetMonth()), int64(_dollar_dollar.GetDay())} + unwrapped_fields858 := fields857 p.write("(") p.write("date") p.indentSexp() p.newline() - field849 := unwrapped_fields848[0].(int64) - p.write(fmt.Sprintf("%d", field849)) + field859 := unwrapped_fields858[0].(int64) + p.write(fmt.Sprintf("%d", field859)) p.newline() - field850 := unwrapped_fields848[1].(int64) - p.write(fmt.Sprintf("%d", field850)) + field860 := unwrapped_fields858[1].(int64) + p.write(fmt.Sprintf("%d", field860)) p.newline() - field851 := unwrapped_fields848[2].(int64) - p.write(fmt.Sprintf("%d", field851)) + field861 := unwrapped_fields858[2].(int64) + p.write(fmt.Sprintf("%d", field861)) p.dedent() p.write(")") } @@ -895,40 +895,40 @@ func (p *PrettyPrinter) pretty_raw_date(msg *pb.DateValue) interface{} { } func (p *PrettyPrinter) pretty_raw_datetime(msg *pb.DateTimeValue) interface{} { - flat863 := p.tryFlat(msg, func() { p.pretty_raw_datetime(msg) }) - if flat863 != nil { - p.write(*flat863) + flat873 := p.tryFlat(msg, func() { p.pretty_raw_datetime(msg) }) + if flat873 != nil { + p.write(*flat873) return nil } else { _dollar_dollar := msg - fields853 := []interface{}{int64(_dollar_dollar.GetYear()), int64(_dollar_dollar.GetMonth()), int64(_dollar_dollar.GetDay()), int64(_dollar_dollar.GetHour()), int64(_dollar_dollar.GetMinute()), int64(_dollar_dollar.GetSecond()), ptr(int64(_dollar_dollar.GetMicrosecond()))} - unwrapped_fields854 := fields853 + fields863 := []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_fields864 := fields863 p.write("(") p.write("datetime") p.indentSexp() p.newline() - field855 := unwrapped_fields854[0].(int64) - p.write(fmt.Sprintf("%d", field855)) + field865 := unwrapped_fields864[0].(int64) + p.write(fmt.Sprintf("%d", field865)) p.newline() - field856 := unwrapped_fields854[1].(int64) - p.write(fmt.Sprintf("%d", field856)) + field866 := unwrapped_fields864[1].(int64) + p.write(fmt.Sprintf("%d", field866)) p.newline() - field857 := unwrapped_fields854[2].(int64) - p.write(fmt.Sprintf("%d", field857)) + field867 := unwrapped_fields864[2].(int64) + p.write(fmt.Sprintf("%d", field867)) p.newline() - field858 := unwrapped_fields854[3].(int64) - p.write(fmt.Sprintf("%d", field858)) + field868 := unwrapped_fields864[3].(int64) + p.write(fmt.Sprintf("%d", field868)) p.newline() - field859 := unwrapped_fields854[4].(int64) - p.write(fmt.Sprintf("%d", field859)) + field869 := unwrapped_fields864[4].(int64) + p.write(fmt.Sprintf("%d", field869)) p.newline() - field860 := unwrapped_fields854[5].(int64) - p.write(fmt.Sprintf("%d", field860)) - field861 := unwrapped_fields854[6].(*int64) - if field861 != nil { + field870 := unwrapped_fields864[5].(int64) + p.write(fmt.Sprintf("%d", field870)) + field871 := unwrapped_fields864[6].(*int64) + if field871 != nil { p.newline() - opt_val862 := *field861 - p.write(fmt.Sprintf("%d", opt_val862)) + opt_val872 := *field871 + p.write(fmt.Sprintf("%d", opt_val872)) } p.dedent() p.write(")") @@ -938,25 +938,25 @@ func (p *PrettyPrinter) pretty_raw_datetime(msg *pb.DateTimeValue) interface{} { func (p *PrettyPrinter) pretty_boolean_value(msg bool) interface{} { _dollar_dollar := msg - var _t1613 []interface{} + var _t1633 []interface{} if _dollar_dollar { - _t1613 = []interface{}{} + _t1633 = []interface{}{} } - deconstruct_result866 := _t1613 - if deconstruct_result866 != nil { - unwrapped867 := deconstruct_result866 - _ = unwrapped867 + deconstruct_result876 := _t1633 + if deconstruct_result876 != nil { + unwrapped877 := deconstruct_result876 + _ = unwrapped877 p.write("true") } else { _dollar_dollar := msg - var _t1614 []interface{} + var _t1634 []interface{} if !(_dollar_dollar) { - _t1614 = []interface{}{} + _t1634 = []interface{}{} } - deconstruct_result864 := _t1614 - if deconstruct_result864 != nil { - unwrapped865 := deconstruct_result864 - _ = unwrapped865 + deconstruct_result874 := _t1634 + if deconstruct_result874 != nil { + unwrapped875 := deconstruct_result874 + _ = unwrapped875 p.write("false") } else { panic(ParseError{msg: "No matching rule for boolean_value"}) @@ -966,24 +966,24 @@ func (p *PrettyPrinter) pretty_boolean_value(msg bool) interface{} { } func (p *PrettyPrinter) pretty_sync(msg *pb.Sync) interface{} { - flat872 := p.tryFlat(msg, func() { p.pretty_sync(msg) }) - if flat872 != nil { - p.write(*flat872) + flat882 := p.tryFlat(msg, func() { p.pretty_sync(msg) }) + if flat882 != nil { + p.write(*flat882) return nil } else { _dollar_dollar := msg - fields868 := _dollar_dollar.GetFragments() - unwrapped_fields869 := fields868 + fields878 := _dollar_dollar.GetFragments() + unwrapped_fields879 := fields878 p.write("(") p.write("sync") p.indentSexp() - if !(len(unwrapped_fields869) == 0) { + if !(len(unwrapped_fields879) == 0) { p.newline() - for i871, elem870 := range unwrapped_fields869 { - if (i871 > 0) { + for i881, elem880 := range unwrapped_fields879 { + if (i881 > 0) { p.newline() } - p.pretty_fragment_id(elem870) + p.pretty_fragment_id(elem880) } } p.dedent() @@ -993,51 +993,51 @@ func (p *PrettyPrinter) pretty_sync(msg *pb.Sync) interface{} { } func (p *PrettyPrinter) pretty_fragment_id(msg *pb.FragmentId) interface{} { - flat875 := p.tryFlat(msg, func() { p.pretty_fragment_id(msg) }) - if flat875 != nil { - p.write(*flat875) + flat885 := p.tryFlat(msg, func() { p.pretty_fragment_id(msg) }) + if flat885 != nil { + p.write(*flat885) return nil } else { _dollar_dollar := msg - fields873 := p.fragmentIdToString(_dollar_dollar) - unwrapped_fields874 := fields873 + fields883 := p.fragmentIdToString(_dollar_dollar) + unwrapped_fields884 := fields883 p.write(":") - p.write(unwrapped_fields874) + p.write(unwrapped_fields884) } return nil } func (p *PrettyPrinter) pretty_epoch(msg *pb.Epoch) interface{} { - flat882 := p.tryFlat(msg, func() { p.pretty_epoch(msg) }) - if flat882 != nil { - p.write(*flat882) + flat892 := p.tryFlat(msg, func() { p.pretty_epoch(msg) }) + if flat892 != nil { + p.write(*flat892) return nil } else { _dollar_dollar := msg - var _t1615 []*pb.Write + var _t1635 []*pb.Write if !(len(_dollar_dollar.GetWrites()) == 0) { - _t1615 = _dollar_dollar.GetWrites() + _t1635 = _dollar_dollar.GetWrites() } - var _t1616 []*pb.Read + var _t1636 []*pb.Read if !(len(_dollar_dollar.GetReads()) == 0) { - _t1616 = _dollar_dollar.GetReads() + _t1636 = _dollar_dollar.GetReads() } - fields876 := []interface{}{_t1615, _t1616} - unwrapped_fields877 := fields876 + fields886 := []interface{}{_t1635, _t1636} + unwrapped_fields887 := fields886 p.write("(") p.write("epoch") p.indentSexp() - field878 := unwrapped_fields877[0].([]*pb.Write) - if field878 != nil { + field888 := unwrapped_fields887[0].([]*pb.Write) + if field888 != nil { p.newline() - opt_val879 := field878 - p.pretty_epoch_writes(opt_val879) + opt_val889 := field888 + p.pretty_epoch_writes(opt_val889) } - field880 := unwrapped_fields877[1].([]*pb.Read) - if field880 != nil { + field890 := unwrapped_fields887[1].([]*pb.Read) + if field890 != nil { p.newline() - opt_val881 := field880 - p.pretty_epoch_reads(opt_val881) + opt_val891 := field890 + p.pretty_epoch_reads(opt_val891) } p.dedent() p.write(")") @@ -1046,22 +1046,22 @@ func (p *PrettyPrinter) pretty_epoch(msg *pb.Epoch) interface{} { } func (p *PrettyPrinter) pretty_epoch_writes(msg []*pb.Write) interface{} { - flat886 := p.tryFlat(msg, func() { p.pretty_epoch_writes(msg) }) - if flat886 != nil { - p.write(*flat886) + flat896 := p.tryFlat(msg, func() { p.pretty_epoch_writes(msg) }) + if flat896 != nil { + p.write(*flat896) return nil } else { - fields883 := msg + fields893 := msg p.write("(") p.write("writes") p.indentSexp() - if !(len(fields883) == 0) { + if !(len(fields893) == 0) { p.newline() - for i885, elem884 := range fields883 { - if (i885 > 0) { + for i895, elem894 := range fields893 { + if (i895 > 0) { p.newline() } - p.pretty_write(elem884) + p.pretty_write(elem894) } } p.dedent() @@ -1071,50 +1071,50 @@ func (p *PrettyPrinter) pretty_epoch_writes(msg []*pb.Write) interface{} { } func (p *PrettyPrinter) pretty_write(msg *pb.Write) interface{} { - flat895 := p.tryFlat(msg, func() { p.pretty_write(msg) }) - if flat895 != nil { - p.write(*flat895) + flat905 := p.tryFlat(msg, func() { p.pretty_write(msg) }) + if flat905 != nil { + p.write(*flat905) return nil } else { _dollar_dollar := msg - var _t1617 *pb.Define + var _t1637 *pb.Define if hasProtoField(_dollar_dollar, "define") { - _t1617 = _dollar_dollar.GetDefine() + _t1637 = _dollar_dollar.GetDefine() } - deconstruct_result893 := _t1617 - if deconstruct_result893 != nil { - unwrapped894 := deconstruct_result893 - p.pretty_define(unwrapped894) + deconstruct_result903 := _t1637 + if deconstruct_result903 != nil { + unwrapped904 := deconstruct_result903 + p.pretty_define(unwrapped904) } else { _dollar_dollar := msg - var _t1618 *pb.Undefine + var _t1638 *pb.Undefine if hasProtoField(_dollar_dollar, "undefine") { - _t1618 = _dollar_dollar.GetUndefine() + _t1638 = _dollar_dollar.GetUndefine() } - deconstruct_result891 := _t1618 - if deconstruct_result891 != nil { - unwrapped892 := deconstruct_result891 - p.pretty_undefine(unwrapped892) + deconstruct_result901 := _t1638 + if deconstruct_result901 != nil { + unwrapped902 := deconstruct_result901 + p.pretty_undefine(unwrapped902) } else { _dollar_dollar := msg - var _t1619 *pb.Context + var _t1639 *pb.Context if hasProtoField(_dollar_dollar, "context") { - _t1619 = _dollar_dollar.GetContext() + _t1639 = _dollar_dollar.GetContext() } - deconstruct_result889 := _t1619 - if deconstruct_result889 != nil { - unwrapped890 := deconstruct_result889 - p.pretty_context(unwrapped890) + deconstruct_result899 := _t1639 + if deconstruct_result899 != nil { + unwrapped900 := deconstruct_result899 + p.pretty_context(unwrapped900) } else { _dollar_dollar := msg - var _t1620 *pb.Snapshot + var _t1640 *pb.Snapshot if hasProtoField(_dollar_dollar, "snapshot") { - _t1620 = _dollar_dollar.GetSnapshot() + _t1640 = _dollar_dollar.GetSnapshot() } - deconstruct_result887 := _t1620 - if deconstruct_result887 != nil { - unwrapped888 := deconstruct_result887 - p.pretty_snapshot(unwrapped888) + deconstruct_result897 := _t1640 + if deconstruct_result897 != nil { + unwrapped898 := deconstruct_result897 + p.pretty_snapshot(unwrapped898) } else { panic(ParseError{msg: "No matching rule for write"}) } @@ -1126,19 +1126,19 @@ func (p *PrettyPrinter) pretty_write(msg *pb.Write) interface{} { } func (p *PrettyPrinter) pretty_define(msg *pb.Define) interface{} { - flat898 := p.tryFlat(msg, func() { p.pretty_define(msg) }) - if flat898 != nil { - p.write(*flat898) + flat908 := p.tryFlat(msg, func() { p.pretty_define(msg) }) + if flat908 != nil { + p.write(*flat908) return nil } else { _dollar_dollar := msg - fields896 := _dollar_dollar.GetFragment() - unwrapped_fields897 := fields896 + fields906 := _dollar_dollar.GetFragment() + unwrapped_fields907 := fields906 p.write("(") p.write("define") p.indentSexp() p.newline() - p.pretty_fragment(unwrapped_fields897) + p.pretty_fragment(unwrapped_fields907) p.dedent() p.write(")") } @@ -1146,29 +1146,29 @@ func (p *PrettyPrinter) pretty_define(msg *pb.Define) interface{} { } func (p *PrettyPrinter) pretty_fragment(msg *pb.Fragment) interface{} { - flat905 := p.tryFlat(msg, func() { p.pretty_fragment(msg) }) - if flat905 != nil { - p.write(*flat905) + flat915 := p.tryFlat(msg, func() { p.pretty_fragment(msg) }) + if flat915 != nil { + p.write(*flat915) return nil } else { _dollar_dollar := msg p.startPrettyFragment(_dollar_dollar) - fields899 := []interface{}{_dollar_dollar.GetId(), _dollar_dollar.GetDeclarations()} - unwrapped_fields900 := fields899 + fields909 := []interface{}{_dollar_dollar.GetId(), _dollar_dollar.GetDeclarations()} + unwrapped_fields910 := fields909 p.write("(") p.write("fragment") p.indentSexp() p.newline() - field901 := unwrapped_fields900[0].(*pb.FragmentId) - p.pretty_new_fragment_id(field901) - field902 := unwrapped_fields900[1].([]*pb.Declaration) - if !(len(field902) == 0) { + field911 := unwrapped_fields910[0].(*pb.FragmentId) + p.pretty_new_fragment_id(field911) + field912 := unwrapped_fields910[1].([]*pb.Declaration) + if !(len(field912) == 0) { p.newline() - for i904, elem903 := range field902 { - if (i904 > 0) { + for i914, elem913 := range field912 { + if (i914 > 0) { p.newline() } - p.pretty_declaration(elem903) + p.pretty_declaration(elem913) } } p.dedent() @@ -1178,62 +1178,62 @@ func (p *PrettyPrinter) pretty_fragment(msg *pb.Fragment) interface{} { } func (p *PrettyPrinter) pretty_new_fragment_id(msg *pb.FragmentId) interface{} { - flat907 := p.tryFlat(msg, func() { p.pretty_new_fragment_id(msg) }) - if flat907 != nil { - p.write(*flat907) + flat917 := p.tryFlat(msg, func() { p.pretty_new_fragment_id(msg) }) + if flat917 != nil { + p.write(*flat917) return nil } else { - fields906 := msg - p.pretty_fragment_id(fields906) + fields916 := msg + p.pretty_fragment_id(fields916) } return nil } func (p *PrettyPrinter) pretty_declaration(msg *pb.Declaration) interface{} { - flat916 := p.tryFlat(msg, func() { p.pretty_declaration(msg) }) - if flat916 != nil { - p.write(*flat916) + flat926 := p.tryFlat(msg, func() { p.pretty_declaration(msg) }) + if flat926 != nil { + p.write(*flat926) return nil } else { _dollar_dollar := msg - var _t1621 *pb.Def + var _t1641 *pb.Def if hasProtoField(_dollar_dollar, "def") { - _t1621 = _dollar_dollar.GetDef() + _t1641 = _dollar_dollar.GetDef() } - deconstruct_result914 := _t1621 - if deconstruct_result914 != nil { - unwrapped915 := deconstruct_result914 - p.pretty_def(unwrapped915) + deconstruct_result924 := _t1641 + if deconstruct_result924 != nil { + unwrapped925 := deconstruct_result924 + p.pretty_def(unwrapped925) } else { _dollar_dollar := msg - var _t1622 *pb.Algorithm + var _t1642 *pb.Algorithm if hasProtoField(_dollar_dollar, "algorithm") { - _t1622 = _dollar_dollar.GetAlgorithm() + _t1642 = _dollar_dollar.GetAlgorithm() } - deconstruct_result912 := _t1622 - if deconstruct_result912 != nil { - unwrapped913 := deconstruct_result912 - p.pretty_algorithm(unwrapped913) + deconstruct_result922 := _t1642 + if deconstruct_result922 != nil { + unwrapped923 := deconstruct_result922 + p.pretty_algorithm(unwrapped923) } else { _dollar_dollar := msg - var _t1623 *pb.Constraint + var _t1643 *pb.Constraint if hasProtoField(_dollar_dollar, "constraint") { - _t1623 = _dollar_dollar.GetConstraint() + _t1643 = _dollar_dollar.GetConstraint() } - deconstruct_result910 := _t1623 - if deconstruct_result910 != nil { - unwrapped911 := deconstruct_result910 - p.pretty_constraint(unwrapped911) + deconstruct_result920 := _t1643 + if deconstruct_result920 != nil { + unwrapped921 := deconstruct_result920 + p.pretty_constraint(unwrapped921) } else { _dollar_dollar := msg - var _t1624 *pb.Data + var _t1644 *pb.Data if hasProtoField(_dollar_dollar, "data") { - _t1624 = _dollar_dollar.GetData() + _t1644 = _dollar_dollar.GetData() } - deconstruct_result908 := _t1624 - if deconstruct_result908 != nil { - unwrapped909 := deconstruct_result908 - p.pretty_data(unwrapped909) + deconstruct_result918 := _t1644 + if deconstruct_result918 != nil { + unwrapped919 := deconstruct_result918 + p.pretty_data(unwrapped919) } else { panic(ParseError{msg: "No matching rule for declaration"}) } @@ -1245,32 +1245,32 @@ func (p *PrettyPrinter) pretty_declaration(msg *pb.Declaration) interface{} { } func (p *PrettyPrinter) pretty_def(msg *pb.Def) interface{} { - flat923 := p.tryFlat(msg, func() { p.pretty_def(msg) }) - if flat923 != nil { - p.write(*flat923) + flat933 := p.tryFlat(msg, func() { p.pretty_def(msg) }) + if flat933 != nil { + p.write(*flat933) return nil } else { _dollar_dollar := msg - var _t1625 []*pb.Attribute + var _t1645 []*pb.Attribute if !(len(_dollar_dollar.GetAttrs()) == 0) { - _t1625 = _dollar_dollar.GetAttrs() + _t1645 = _dollar_dollar.GetAttrs() } - fields917 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetBody(), _t1625} - unwrapped_fields918 := fields917 + fields927 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetBody(), _t1645} + unwrapped_fields928 := fields927 p.write("(") p.write("def") p.indentSexp() p.newline() - field919 := unwrapped_fields918[0].(*pb.RelationId) - p.pretty_relation_id(field919) + field929 := unwrapped_fields928[0].(*pb.RelationId) + p.pretty_relation_id(field929) p.newline() - field920 := unwrapped_fields918[1].(*pb.Abstraction) - p.pretty_abstraction(field920) - field921 := unwrapped_fields918[2].([]*pb.Attribute) - if field921 != nil { + field930 := unwrapped_fields928[1].(*pb.Abstraction) + p.pretty_abstraction(field930) + field931 := unwrapped_fields928[2].([]*pb.Attribute) + if field931 != nil { p.newline() - opt_val922 := field921 - p.pretty_attrs(opt_val922) + opt_val932 := field931 + p.pretty_attrs(opt_val932) } p.dedent() p.write(")") @@ -1279,29 +1279,29 @@ func (p *PrettyPrinter) pretty_def(msg *pb.Def) interface{} { } func (p *PrettyPrinter) pretty_relation_id(msg *pb.RelationId) interface{} { - flat928 := p.tryFlat(msg, func() { p.pretty_relation_id(msg) }) - if flat928 != nil { - p.write(*flat928) + flat938 := p.tryFlat(msg, func() { p.pretty_relation_id(msg) }) + if flat938 != nil { + p.write(*flat938) return nil } else { _dollar_dollar := msg - var _t1626 *string + var _t1646 *string if p.relationIdToString(_dollar_dollar) != nil { - _t1627 := p.deconstruct_relation_id_string(_dollar_dollar) - _t1626 = ptr(_t1627) + _t1647 := p.deconstruct_relation_id_string(_dollar_dollar) + _t1646 = ptr(_t1647) } - deconstruct_result926 := _t1626 - if deconstruct_result926 != nil { - unwrapped927 := *deconstruct_result926 + deconstruct_result936 := _t1646 + if deconstruct_result936 != nil { + unwrapped937 := *deconstruct_result936 p.write(":") - p.write(unwrapped927) + p.write(unwrapped937) } else { _dollar_dollar := msg - _t1628 := p.deconstruct_relation_id_uint128(_dollar_dollar) - deconstruct_result924 := _t1628 - if deconstruct_result924 != nil { - unwrapped925 := deconstruct_result924 - p.write(p.formatUint128(unwrapped925)) + _t1648 := p.deconstruct_relation_id_uint128(_dollar_dollar) + deconstruct_result934 := _t1648 + if deconstruct_result934 != nil { + unwrapped935 := deconstruct_result934 + p.write(p.formatUint128(unwrapped935)) } else { panic(ParseError{msg: "No matching rule for relation_id"}) } @@ -1311,22 +1311,22 @@ func (p *PrettyPrinter) pretty_relation_id(msg *pb.RelationId) interface{} { } func (p *PrettyPrinter) pretty_abstraction(msg *pb.Abstraction) interface{} { - flat933 := p.tryFlat(msg, func() { p.pretty_abstraction(msg) }) - if flat933 != nil { - p.write(*flat933) + flat943 := p.tryFlat(msg, func() { p.pretty_abstraction(msg) }) + if flat943 != nil { + p.write(*flat943) return nil } else { _dollar_dollar := msg - _t1629 := p.deconstruct_bindings(_dollar_dollar) - fields929 := []interface{}{_t1629, _dollar_dollar.GetValue()} - unwrapped_fields930 := fields929 + _t1649 := p.deconstruct_bindings(_dollar_dollar) + fields939 := []interface{}{_t1649, _dollar_dollar.GetValue()} + unwrapped_fields940 := fields939 p.write("(") p.indent() - field931 := unwrapped_fields930[0].([]interface{}) - p.pretty_bindings(field931) + field941 := unwrapped_fields940[0].([]interface{}) + p.pretty_bindings(field941) p.newline() - field932 := unwrapped_fields930[1].(*pb.Formula) - p.pretty_formula(field932) + field942 := unwrapped_fields940[1].(*pb.Formula) + p.pretty_formula(field942) p.dedent() p.write(")") } @@ -1334,32 +1334,32 @@ func (p *PrettyPrinter) pretty_abstraction(msg *pb.Abstraction) interface{} { } func (p *PrettyPrinter) pretty_bindings(msg []interface{}) interface{} { - flat941 := p.tryFlat(msg, func() { p.pretty_bindings(msg) }) - if flat941 != nil { - p.write(*flat941) + flat951 := p.tryFlat(msg, func() { p.pretty_bindings(msg) }) + if flat951 != nil { + p.write(*flat951) return nil } else { _dollar_dollar := msg - var _t1630 []*pb.Binding + var _t1650 []*pb.Binding if !(len(_dollar_dollar[1].([]*pb.Binding)) == 0) { - _t1630 = _dollar_dollar[1].([]*pb.Binding) + _t1650 = _dollar_dollar[1].([]*pb.Binding) } - fields934 := []interface{}{_dollar_dollar[0].([]*pb.Binding), _t1630} - unwrapped_fields935 := fields934 + fields944 := []interface{}{_dollar_dollar[0].([]*pb.Binding), _t1650} + unwrapped_fields945 := fields944 p.write("[") p.indent() - field936 := unwrapped_fields935[0].([]*pb.Binding) - for i938, elem937 := range field936 { - if (i938 > 0) { + field946 := unwrapped_fields945[0].([]*pb.Binding) + for i948, elem947 := range field946 { + if (i948 > 0) { p.newline() } - p.pretty_binding(elem937) + p.pretty_binding(elem947) } - field939 := unwrapped_fields935[1].([]*pb.Binding) - if field939 != nil { + field949 := unwrapped_fields945[1].([]*pb.Binding) + if field949 != nil { p.newline() - opt_val940 := field939 - p.pretty_value_bindings(opt_val940) + opt_val950 := field949 + p.pretty_value_bindings(opt_val950) } p.dedent() p.write("]") @@ -1368,168 +1368,168 @@ func (p *PrettyPrinter) pretty_bindings(msg []interface{}) interface{} { } func (p *PrettyPrinter) pretty_binding(msg *pb.Binding) interface{} { - flat946 := p.tryFlat(msg, func() { p.pretty_binding(msg) }) - if flat946 != nil { - p.write(*flat946) + flat956 := p.tryFlat(msg, func() { p.pretty_binding(msg) }) + if flat956 != nil { + p.write(*flat956) return nil } else { _dollar_dollar := msg - fields942 := []interface{}{_dollar_dollar.GetVar().GetName(), _dollar_dollar.GetType()} - unwrapped_fields943 := fields942 - field944 := unwrapped_fields943[0].(string) - p.write(field944) + fields952 := []interface{}{_dollar_dollar.GetVar().GetName(), _dollar_dollar.GetType()} + unwrapped_fields953 := fields952 + field954 := unwrapped_fields953[0].(string) + p.write(field954) p.write("::") - field945 := unwrapped_fields943[1].(*pb.Type) - p.pretty_type(field945) + field955 := unwrapped_fields953[1].(*pb.Type) + p.pretty_type(field955) } return nil } func (p *PrettyPrinter) pretty_type(msg *pb.Type) interface{} { - flat975 := p.tryFlat(msg, func() { p.pretty_type(msg) }) - if flat975 != nil { - p.write(*flat975) + flat985 := p.tryFlat(msg, func() { p.pretty_type(msg) }) + if flat985 != nil { + p.write(*flat985) return nil } else { _dollar_dollar := msg - var _t1631 *pb.UnspecifiedType + var _t1651 *pb.UnspecifiedType if hasProtoField(_dollar_dollar, "unspecified_type") { - _t1631 = _dollar_dollar.GetUnspecifiedType() + _t1651 = _dollar_dollar.GetUnspecifiedType() } - deconstruct_result973 := _t1631 - if deconstruct_result973 != nil { - unwrapped974 := deconstruct_result973 - p.pretty_unspecified_type(unwrapped974) + deconstruct_result983 := _t1651 + if deconstruct_result983 != nil { + unwrapped984 := deconstruct_result983 + p.pretty_unspecified_type(unwrapped984) } else { _dollar_dollar := msg - var _t1632 *pb.StringType + var _t1652 *pb.StringType if hasProtoField(_dollar_dollar, "string_type") { - _t1632 = _dollar_dollar.GetStringType() + _t1652 = _dollar_dollar.GetStringType() } - deconstruct_result971 := _t1632 - if deconstruct_result971 != nil { - unwrapped972 := deconstruct_result971 - p.pretty_string_type(unwrapped972) + deconstruct_result981 := _t1652 + if deconstruct_result981 != nil { + unwrapped982 := deconstruct_result981 + p.pretty_string_type(unwrapped982) } else { _dollar_dollar := msg - var _t1633 *pb.IntType + var _t1653 *pb.IntType if hasProtoField(_dollar_dollar, "int_type") { - _t1633 = _dollar_dollar.GetIntType() + _t1653 = _dollar_dollar.GetIntType() } - deconstruct_result969 := _t1633 - if deconstruct_result969 != nil { - unwrapped970 := deconstruct_result969 - p.pretty_int_type(unwrapped970) + deconstruct_result979 := _t1653 + if deconstruct_result979 != nil { + unwrapped980 := deconstruct_result979 + p.pretty_int_type(unwrapped980) } else { _dollar_dollar := msg - var _t1634 *pb.FloatType + var _t1654 *pb.FloatType if hasProtoField(_dollar_dollar, "float_type") { - _t1634 = _dollar_dollar.GetFloatType() + _t1654 = _dollar_dollar.GetFloatType() } - deconstruct_result967 := _t1634 - if deconstruct_result967 != nil { - unwrapped968 := deconstruct_result967 - p.pretty_float_type(unwrapped968) + deconstruct_result977 := _t1654 + if deconstruct_result977 != nil { + unwrapped978 := deconstruct_result977 + p.pretty_float_type(unwrapped978) } else { _dollar_dollar := msg - var _t1635 *pb.UInt128Type + var _t1655 *pb.UInt128Type if hasProtoField(_dollar_dollar, "uint128_type") { - _t1635 = _dollar_dollar.GetUint128Type() + _t1655 = _dollar_dollar.GetUint128Type() } - deconstruct_result965 := _t1635 - if deconstruct_result965 != nil { - unwrapped966 := deconstruct_result965 - p.pretty_uint128_type(unwrapped966) + deconstruct_result975 := _t1655 + if deconstruct_result975 != nil { + unwrapped976 := deconstruct_result975 + p.pretty_uint128_type(unwrapped976) } else { _dollar_dollar := msg - var _t1636 *pb.Int128Type + var _t1656 *pb.Int128Type if hasProtoField(_dollar_dollar, "int128_type") { - _t1636 = _dollar_dollar.GetInt128Type() + _t1656 = _dollar_dollar.GetInt128Type() } - deconstruct_result963 := _t1636 - if deconstruct_result963 != nil { - unwrapped964 := deconstruct_result963 - p.pretty_int128_type(unwrapped964) + deconstruct_result973 := _t1656 + if deconstruct_result973 != nil { + unwrapped974 := deconstruct_result973 + p.pretty_int128_type(unwrapped974) } else { _dollar_dollar := msg - var _t1637 *pb.DateType + var _t1657 *pb.DateType if hasProtoField(_dollar_dollar, "date_type") { - _t1637 = _dollar_dollar.GetDateType() + _t1657 = _dollar_dollar.GetDateType() } - deconstruct_result961 := _t1637 - if deconstruct_result961 != nil { - unwrapped962 := deconstruct_result961 - p.pretty_date_type(unwrapped962) + deconstruct_result971 := _t1657 + if deconstruct_result971 != nil { + unwrapped972 := deconstruct_result971 + p.pretty_date_type(unwrapped972) } else { _dollar_dollar := msg - var _t1638 *pb.DateTimeType + var _t1658 *pb.DateTimeType if hasProtoField(_dollar_dollar, "datetime_type") { - _t1638 = _dollar_dollar.GetDatetimeType() + _t1658 = _dollar_dollar.GetDatetimeType() } - deconstruct_result959 := _t1638 - if deconstruct_result959 != nil { - unwrapped960 := deconstruct_result959 - p.pretty_datetime_type(unwrapped960) + deconstruct_result969 := _t1658 + if deconstruct_result969 != nil { + unwrapped970 := deconstruct_result969 + p.pretty_datetime_type(unwrapped970) } else { _dollar_dollar := msg - var _t1639 *pb.MissingType + var _t1659 *pb.MissingType if hasProtoField(_dollar_dollar, "missing_type") { - _t1639 = _dollar_dollar.GetMissingType() + _t1659 = _dollar_dollar.GetMissingType() } - deconstruct_result957 := _t1639 - if deconstruct_result957 != nil { - unwrapped958 := deconstruct_result957 - p.pretty_missing_type(unwrapped958) + deconstruct_result967 := _t1659 + if deconstruct_result967 != nil { + unwrapped968 := deconstruct_result967 + p.pretty_missing_type(unwrapped968) } else { _dollar_dollar := msg - var _t1640 *pb.DecimalType + var _t1660 *pb.DecimalType if hasProtoField(_dollar_dollar, "decimal_type") { - _t1640 = _dollar_dollar.GetDecimalType() + _t1660 = _dollar_dollar.GetDecimalType() } - deconstruct_result955 := _t1640 - if deconstruct_result955 != nil { - unwrapped956 := deconstruct_result955 - p.pretty_decimal_type(unwrapped956) + deconstruct_result965 := _t1660 + if deconstruct_result965 != nil { + unwrapped966 := deconstruct_result965 + p.pretty_decimal_type(unwrapped966) } else { _dollar_dollar := msg - var _t1641 *pb.BooleanType + var _t1661 *pb.BooleanType if hasProtoField(_dollar_dollar, "boolean_type") { - _t1641 = _dollar_dollar.GetBooleanType() + _t1661 = _dollar_dollar.GetBooleanType() } - deconstruct_result953 := _t1641 - if deconstruct_result953 != nil { - unwrapped954 := deconstruct_result953 - p.pretty_boolean_type(unwrapped954) + deconstruct_result963 := _t1661 + if deconstruct_result963 != nil { + unwrapped964 := deconstruct_result963 + p.pretty_boolean_type(unwrapped964) } else { _dollar_dollar := msg - var _t1642 *pb.Int32Type + var _t1662 *pb.Int32Type if hasProtoField(_dollar_dollar, "int32_type") { - _t1642 = _dollar_dollar.GetInt32Type() + _t1662 = _dollar_dollar.GetInt32Type() } - deconstruct_result951 := _t1642 - if deconstruct_result951 != nil { - unwrapped952 := deconstruct_result951 - p.pretty_int32_type(unwrapped952) + deconstruct_result961 := _t1662 + if deconstruct_result961 != nil { + unwrapped962 := deconstruct_result961 + p.pretty_int32_type(unwrapped962) } else { _dollar_dollar := msg - var _t1643 *pb.Float32Type + var _t1663 *pb.Float32Type if hasProtoField(_dollar_dollar, "float32_type") { - _t1643 = _dollar_dollar.GetFloat32Type() + _t1663 = _dollar_dollar.GetFloat32Type() } - deconstruct_result949 := _t1643 - if deconstruct_result949 != nil { - unwrapped950 := deconstruct_result949 - p.pretty_float32_type(unwrapped950) + deconstruct_result959 := _t1663 + if deconstruct_result959 != nil { + unwrapped960 := deconstruct_result959 + p.pretty_float32_type(unwrapped960) } else { _dollar_dollar := msg - var _t1644 *pb.UInt32Type + var _t1664 *pb.UInt32Type if hasProtoField(_dollar_dollar, "uint32_type") { - _t1644 = _dollar_dollar.GetUint32Type() + _t1664 = _dollar_dollar.GetUint32Type() } - deconstruct_result947 := _t1644 - if deconstruct_result947 != nil { - unwrapped948 := deconstruct_result947 - p.pretty_uint32_type(unwrapped948) + deconstruct_result957 := _t1664 + if deconstruct_result957 != nil { + unwrapped958 := deconstruct_result957 + p.pretty_uint32_type(unwrapped958) } else { panic(ParseError{msg: "No matching rule for type"}) } @@ -1551,86 +1551,86 @@ func (p *PrettyPrinter) pretty_type(msg *pb.Type) interface{} { } func (p *PrettyPrinter) pretty_unspecified_type(msg *pb.UnspecifiedType) interface{} { - fields976 := msg - _ = fields976 + fields986 := msg + _ = fields986 p.write("UNKNOWN") return nil } func (p *PrettyPrinter) pretty_string_type(msg *pb.StringType) interface{} { - fields977 := msg - _ = fields977 + fields987 := msg + _ = fields987 p.write("STRING") return nil } func (p *PrettyPrinter) pretty_int_type(msg *pb.IntType) interface{} { - fields978 := msg - _ = fields978 + fields988 := msg + _ = fields988 p.write("INT") return nil } func (p *PrettyPrinter) pretty_float_type(msg *pb.FloatType) interface{} { - fields979 := msg - _ = fields979 + fields989 := msg + _ = fields989 p.write("FLOAT") return nil } func (p *PrettyPrinter) pretty_uint128_type(msg *pb.UInt128Type) interface{} { - fields980 := msg - _ = fields980 + fields990 := msg + _ = fields990 p.write("UINT128") return nil } func (p *PrettyPrinter) pretty_int128_type(msg *pb.Int128Type) interface{} { - fields981 := msg - _ = fields981 + fields991 := msg + _ = fields991 p.write("INT128") return nil } func (p *PrettyPrinter) pretty_date_type(msg *pb.DateType) interface{} { - fields982 := msg - _ = fields982 + fields992 := msg + _ = fields992 p.write("DATE") return nil } func (p *PrettyPrinter) pretty_datetime_type(msg *pb.DateTimeType) interface{} { - fields983 := msg - _ = fields983 + fields993 := msg + _ = fields993 p.write("DATETIME") return nil } func (p *PrettyPrinter) pretty_missing_type(msg *pb.MissingType) interface{} { - fields984 := msg - _ = fields984 + fields994 := msg + _ = fields994 p.write("MISSING") return nil } func (p *PrettyPrinter) pretty_decimal_type(msg *pb.DecimalType) interface{} { - flat989 := p.tryFlat(msg, func() { p.pretty_decimal_type(msg) }) - if flat989 != nil { - p.write(*flat989) + flat999 := p.tryFlat(msg, func() { p.pretty_decimal_type(msg) }) + if flat999 != nil { + p.write(*flat999) return nil } else { _dollar_dollar := msg - fields985 := []interface{}{int64(_dollar_dollar.GetPrecision()), int64(_dollar_dollar.GetScale())} - unwrapped_fields986 := fields985 + fields995 := []interface{}{int64(_dollar_dollar.GetPrecision()), int64(_dollar_dollar.GetScale())} + unwrapped_fields996 := fields995 p.write("(") p.write("DECIMAL") p.indentSexp() p.newline() - field987 := unwrapped_fields986[0].(int64) - p.write(fmt.Sprintf("%d", field987)) + field997 := unwrapped_fields996[0].(int64) + p.write(fmt.Sprintf("%d", field997)) p.newline() - field988 := unwrapped_fields986[1].(int64) - p.write(fmt.Sprintf("%d", field988)) + field998 := unwrapped_fields996[1].(int64) + p.write(fmt.Sprintf("%d", field998)) p.dedent() p.write(")") } @@ -1638,48 +1638,48 @@ func (p *PrettyPrinter) pretty_decimal_type(msg *pb.DecimalType) interface{} { } func (p *PrettyPrinter) pretty_boolean_type(msg *pb.BooleanType) interface{} { - fields990 := msg - _ = fields990 + fields1000 := msg + _ = fields1000 p.write("BOOLEAN") return nil } func (p *PrettyPrinter) pretty_int32_type(msg *pb.Int32Type) interface{} { - fields991 := msg - _ = fields991 + fields1001 := msg + _ = fields1001 p.write("INT32") return nil } func (p *PrettyPrinter) pretty_float32_type(msg *pb.Float32Type) interface{} { - fields992 := msg - _ = fields992 + fields1002 := msg + _ = fields1002 p.write("FLOAT32") return nil } func (p *PrettyPrinter) pretty_uint32_type(msg *pb.UInt32Type) interface{} { - fields993 := msg - _ = fields993 + fields1003 := msg + _ = fields1003 p.write("UINT32") return nil } func (p *PrettyPrinter) pretty_value_bindings(msg []*pb.Binding) interface{} { - flat997 := p.tryFlat(msg, func() { p.pretty_value_bindings(msg) }) - if flat997 != nil { - p.write(*flat997) + flat1007 := p.tryFlat(msg, func() { p.pretty_value_bindings(msg) }) + if flat1007 != nil { + p.write(*flat1007) return nil } else { - fields994 := msg + fields1004 := msg p.write("|") - if !(len(fields994) == 0) { + if !(len(fields1004) == 0) { p.write(" ") - for i996, elem995 := range fields994 { - if (i996 > 0) { + for i1006, elem1005 := range fields1004 { + if (i1006 > 0) { p.newline() } - p.pretty_binding(elem995) + p.pretty_binding(elem1005) } } } @@ -1687,140 +1687,140 @@ func (p *PrettyPrinter) pretty_value_bindings(msg []*pb.Binding) interface{} { } func (p *PrettyPrinter) pretty_formula(msg *pb.Formula) interface{} { - flat1024 := p.tryFlat(msg, func() { p.pretty_formula(msg) }) - if flat1024 != nil { - p.write(*flat1024) + flat1034 := p.tryFlat(msg, func() { p.pretty_formula(msg) }) + if flat1034 != nil { + p.write(*flat1034) return nil } else { _dollar_dollar := msg - var _t1645 *pb.Conjunction + var _t1665 *pb.Conjunction if (hasProtoField(_dollar_dollar, "conjunction") && len(_dollar_dollar.GetConjunction().GetArgs()) == 0) { - _t1645 = _dollar_dollar.GetConjunction() + _t1665 = _dollar_dollar.GetConjunction() } - deconstruct_result1022 := _t1645 - if deconstruct_result1022 != nil { - unwrapped1023 := deconstruct_result1022 - p.pretty_true(unwrapped1023) + deconstruct_result1032 := _t1665 + if deconstruct_result1032 != nil { + unwrapped1033 := deconstruct_result1032 + p.pretty_true(unwrapped1033) } else { _dollar_dollar := msg - var _t1646 *pb.Disjunction + var _t1666 *pb.Disjunction if (hasProtoField(_dollar_dollar, "disjunction") && len(_dollar_dollar.GetDisjunction().GetArgs()) == 0) { - _t1646 = _dollar_dollar.GetDisjunction() + _t1666 = _dollar_dollar.GetDisjunction() } - deconstruct_result1020 := _t1646 - if deconstruct_result1020 != nil { - unwrapped1021 := deconstruct_result1020 - p.pretty_false(unwrapped1021) + deconstruct_result1030 := _t1666 + if deconstruct_result1030 != nil { + unwrapped1031 := deconstruct_result1030 + p.pretty_false(unwrapped1031) } else { _dollar_dollar := msg - var _t1647 *pb.Exists + var _t1667 *pb.Exists if hasProtoField(_dollar_dollar, "exists") { - _t1647 = _dollar_dollar.GetExists() + _t1667 = _dollar_dollar.GetExists() } - deconstruct_result1018 := _t1647 - if deconstruct_result1018 != nil { - unwrapped1019 := deconstruct_result1018 - p.pretty_exists(unwrapped1019) + deconstruct_result1028 := _t1667 + if deconstruct_result1028 != nil { + unwrapped1029 := deconstruct_result1028 + p.pretty_exists(unwrapped1029) } else { _dollar_dollar := msg - var _t1648 *pb.Reduce + var _t1668 *pb.Reduce if hasProtoField(_dollar_dollar, "reduce") { - _t1648 = _dollar_dollar.GetReduce() + _t1668 = _dollar_dollar.GetReduce() } - deconstruct_result1016 := _t1648 - if deconstruct_result1016 != nil { - unwrapped1017 := deconstruct_result1016 - p.pretty_reduce(unwrapped1017) + deconstruct_result1026 := _t1668 + if deconstruct_result1026 != nil { + unwrapped1027 := deconstruct_result1026 + p.pretty_reduce(unwrapped1027) } else { _dollar_dollar := msg - var _t1649 *pb.Conjunction + var _t1669 *pb.Conjunction if (hasProtoField(_dollar_dollar, "conjunction") && !(len(_dollar_dollar.GetConjunction().GetArgs()) == 0)) { - _t1649 = _dollar_dollar.GetConjunction() + _t1669 = _dollar_dollar.GetConjunction() } - deconstruct_result1014 := _t1649 - if deconstruct_result1014 != nil { - unwrapped1015 := deconstruct_result1014 - p.pretty_conjunction(unwrapped1015) + deconstruct_result1024 := _t1669 + if deconstruct_result1024 != nil { + unwrapped1025 := deconstruct_result1024 + p.pretty_conjunction(unwrapped1025) } else { _dollar_dollar := msg - var _t1650 *pb.Disjunction + var _t1670 *pb.Disjunction if (hasProtoField(_dollar_dollar, "disjunction") && !(len(_dollar_dollar.GetDisjunction().GetArgs()) == 0)) { - _t1650 = _dollar_dollar.GetDisjunction() + _t1670 = _dollar_dollar.GetDisjunction() } - deconstruct_result1012 := _t1650 - if deconstruct_result1012 != nil { - unwrapped1013 := deconstruct_result1012 - p.pretty_disjunction(unwrapped1013) + deconstruct_result1022 := _t1670 + if deconstruct_result1022 != nil { + unwrapped1023 := deconstruct_result1022 + p.pretty_disjunction(unwrapped1023) } else { _dollar_dollar := msg - var _t1651 *pb.Not + var _t1671 *pb.Not if hasProtoField(_dollar_dollar, "not") { - _t1651 = _dollar_dollar.GetNot() + _t1671 = _dollar_dollar.GetNot() } - deconstruct_result1010 := _t1651 - if deconstruct_result1010 != nil { - unwrapped1011 := deconstruct_result1010 - p.pretty_not(unwrapped1011) + deconstruct_result1020 := _t1671 + if deconstruct_result1020 != nil { + unwrapped1021 := deconstruct_result1020 + p.pretty_not(unwrapped1021) } else { _dollar_dollar := msg - var _t1652 *pb.FFI + var _t1672 *pb.FFI if hasProtoField(_dollar_dollar, "ffi") { - _t1652 = _dollar_dollar.GetFfi() + _t1672 = _dollar_dollar.GetFfi() } - deconstruct_result1008 := _t1652 - if deconstruct_result1008 != nil { - unwrapped1009 := deconstruct_result1008 - p.pretty_ffi(unwrapped1009) + deconstruct_result1018 := _t1672 + if deconstruct_result1018 != nil { + unwrapped1019 := deconstruct_result1018 + p.pretty_ffi(unwrapped1019) } else { _dollar_dollar := msg - var _t1653 *pb.Atom + var _t1673 *pb.Atom if hasProtoField(_dollar_dollar, "atom") { - _t1653 = _dollar_dollar.GetAtom() + _t1673 = _dollar_dollar.GetAtom() } - deconstruct_result1006 := _t1653 - if deconstruct_result1006 != nil { - unwrapped1007 := deconstruct_result1006 - p.pretty_atom(unwrapped1007) + deconstruct_result1016 := _t1673 + if deconstruct_result1016 != nil { + unwrapped1017 := deconstruct_result1016 + p.pretty_atom(unwrapped1017) } else { _dollar_dollar := msg - var _t1654 *pb.Pragma + var _t1674 *pb.Pragma if hasProtoField(_dollar_dollar, "pragma") { - _t1654 = _dollar_dollar.GetPragma() + _t1674 = _dollar_dollar.GetPragma() } - deconstruct_result1004 := _t1654 - if deconstruct_result1004 != nil { - unwrapped1005 := deconstruct_result1004 - p.pretty_pragma(unwrapped1005) + deconstruct_result1014 := _t1674 + if deconstruct_result1014 != nil { + unwrapped1015 := deconstruct_result1014 + p.pretty_pragma(unwrapped1015) } else { _dollar_dollar := msg - var _t1655 *pb.Primitive + var _t1675 *pb.Primitive if hasProtoField(_dollar_dollar, "primitive") { - _t1655 = _dollar_dollar.GetPrimitive() + _t1675 = _dollar_dollar.GetPrimitive() } - deconstruct_result1002 := _t1655 - if deconstruct_result1002 != nil { - unwrapped1003 := deconstruct_result1002 - p.pretty_primitive(unwrapped1003) + deconstruct_result1012 := _t1675 + if deconstruct_result1012 != nil { + unwrapped1013 := deconstruct_result1012 + p.pretty_primitive(unwrapped1013) } else { _dollar_dollar := msg - var _t1656 *pb.RelAtom + var _t1676 *pb.RelAtom if hasProtoField(_dollar_dollar, "rel_atom") { - _t1656 = _dollar_dollar.GetRelAtom() + _t1676 = _dollar_dollar.GetRelAtom() } - deconstruct_result1000 := _t1656 - if deconstruct_result1000 != nil { - unwrapped1001 := deconstruct_result1000 - p.pretty_rel_atom(unwrapped1001) + deconstruct_result1010 := _t1676 + if deconstruct_result1010 != nil { + unwrapped1011 := deconstruct_result1010 + p.pretty_rel_atom(unwrapped1011) } else { _dollar_dollar := msg - var _t1657 *pb.Cast + var _t1677 *pb.Cast if hasProtoField(_dollar_dollar, "cast") { - _t1657 = _dollar_dollar.GetCast() + _t1677 = _dollar_dollar.GetCast() } - deconstruct_result998 := _t1657 - if deconstruct_result998 != nil { - unwrapped999 := deconstruct_result998 - p.pretty_cast(unwrapped999) + deconstruct_result1008 := _t1677 + if deconstruct_result1008 != nil { + unwrapped1009 := deconstruct_result1008 + p.pretty_cast(unwrapped1009) } else { panic(ParseError{msg: "No matching rule for formula"}) } @@ -1841,8 +1841,8 @@ func (p *PrettyPrinter) pretty_formula(msg *pb.Formula) interface{} { } func (p *PrettyPrinter) pretty_true(msg *pb.Conjunction) interface{} { - fields1025 := msg - _ = fields1025 + fields1035 := msg + _ = fields1035 p.write("(") p.write("true") p.write(")") @@ -1850,8 +1850,8 @@ func (p *PrettyPrinter) pretty_true(msg *pb.Conjunction) interface{} { } func (p *PrettyPrinter) pretty_false(msg *pb.Disjunction) interface{} { - fields1026 := msg - _ = fields1026 + fields1036 := msg + _ = fields1036 p.write("(") p.write("false") p.write(")") @@ -1859,24 +1859,24 @@ func (p *PrettyPrinter) pretty_false(msg *pb.Disjunction) interface{} { } func (p *PrettyPrinter) pretty_exists(msg *pb.Exists) interface{} { - flat1031 := p.tryFlat(msg, func() { p.pretty_exists(msg) }) - if flat1031 != nil { - p.write(*flat1031) + flat1041 := p.tryFlat(msg, func() { p.pretty_exists(msg) }) + if flat1041 != nil { + p.write(*flat1041) return nil } else { _dollar_dollar := msg - _t1658 := p.deconstruct_bindings(_dollar_dollar.GetBody()) - fields1027 := []interface{}{_t1658, _dollar_dollar.GetBody().GetValue()} - unwrapped_fields1028 := fields1027 + _t1678 := p.deconstruct_bindings(_dollar_dollar.GetBody()) + fields1037 := []interface{}{_t1678, _dollar_dollar.GetBody().GetValue()} + unwrapped_fields1038 := fields1037 p.write("(") p.write("exists") p.indentSexp() p.newline() - field1029 := unwrapped_fields1028[0].([]interface{}) - p.pretty_bindings(field1029) + field1039 := unwrapped_fields1038[0].([]interface{}) + p.pretty_bindings(field1039) p.newline() - field1030 := unwrapped_fields1028[1].(*pb.Formula) - p.pretty_formula(field1030) + field1040 := unwrapped_fields1038[1].(*pb.Formula) + p.pretty_formula(field1040) p.dedent() p.write(")") } @@ -1884,26 +1884,26 @@ func (p *PrettyPrinter) pretty_exists(msg *pb.Exists) interface{} { } func (p *PrettyPrinter) pretty_reduce(msg *pb.Reduce) interface{} { - flat1037 := p.tryFlat(msg, func() { p.pretty_reduce(msg) }) - if flat1037 != nil { - p.write(*flat1037) + flat1047 := p.tryFlat(msg, func() { p.pretty_reduce(msg) }) + if flat1047 != nil { + p.write(*flat1047) return nil } else { _dollar_dollar := msg - fields1032 := []interface{}{_dollar_dollar.GetOp(), _dollar_dollar.GetBody(), _dollar_dollar.GetTerms()} - unwrapped_fields1033 := fields1032 + fields1042 := []interface{}{_dollar_dollar.GetOp(), _dollar_dollar.GetBody(), _dollar_dollar.GetTerms()} + unwrapped_fields1043 := fields1042 p.write("(") p.write("reduce") p.indentSexp() p.newline() - field1034 := unwrapped_fields1033[0].(*pb.Abstraction) - p.pretty_abstraction(field1034) + field1044 := unwrapped_fields1043[0].(*pb.Abstraction) + p.pretty_abstraction(field1044) p.newline() - field1035 := unwrapped_fields1033[1].(*pb.Abstraction) - p.pretty_abstraction(field1035) + field1045 := unwrapped_fields1043[1].(*pb.Abstraction) + p.pretty_abstraction(field1045) p.newline() - field1036 := unwrapped_fields1033[2].([]*pb.Term) - p.pretty_terms(field1036) + field1046 := unwrapped_fields1043[2].([]*pb.Term) + p.pretty_terms(field1046) p.dedent() p.write(")") } @@ -1911,22 +1911,22 @@ func (p *PrettyPrinter) pretty_reduce(msg *pb.Reduce) interface{} { } func (p *PrettyPrinter) pretty_terms(msg []*pb.Term) interface{} { - flat1041 := p.tryFlat(msg, func() { p.pretty_terms(msg) }) - if flat1041 != nil { - p.write(*flat1041) + flat1051 := p.tryFlat(msg, func() { p.pretty_terms(msg) }) + if flat1051 != nil { + p.write(*flat1051) return nil } else { - fields1038 := msg + fields1048 := msg p.write("(") p.write("terms") p.indentSexp() - if !(len(fields1038) == 0) { + if !(len(fields1048) == 0) { p.newline() - for i1040, elem1039 := range fields1038 { - if (i1040 > 0) { + for i1050, elem1049 := range fields1048 { + if (i1050 > 0) { p.newline() } - p.pretty_term(elem1039) + p.pretty_term(elem1049) } } p.dedent() @@ -1936,30 +1936,30 @@ func (p *PrettyPrinter) pretty_terms(msg []*pb.Term) interface{} { } func (p *PrettyPrinter) pretty_term(msg *pb.Term) interface{} { - flat1046 := p.tryFlat(msg, func() { p.pretty_term(msg) }) - if flat1046 != nil { - p.write(*flat1046) + flat1056 := p.tryFlat(msg, func() { p.pretty_term(msg) }) + if flat1056 != nil { + p.write(*flat1056) return nil } else { _dollar_dollar := msg - var _t1659 *pb.Var + var _t1679 *pb.Var if hasProtoField(_dollar_dollar, "var") { - _t1659 = _dollar_dollar.GetVar() + _t1679 = _dollar_dollar.GetVar() } - deconstruct_result1044 := _t1659 - if deconstruct_result1044 != nil { - unwrapped1045 := deconstruct_result1044 - p.pretty_var(unwrapped1045) + deconstruct_result1054 := _t1679 + if deconstruct_result1054 != nil { + unwrapped1055 := deconstruct_result1054 + p.pretty_var(unwrapped1055) } else { _dollar_dollar := msg - var _t1660 *pb.Value + var _t1680 *pb.Value if hasProtoField(_dollar_dollar, "constant") { - _t1660 = _dollar_dollar.GetConstant() + _t1680 = _dollar_dollar.GetConstant() } - deconstruct_result1042 := _t1660 - if deconstruct_result1042 != nil { - unwrapped1043 := deconstruct_result1042 - p.pretty_value(unwrapped1043) + deconstruct_result1052 := _t1680 + if deconstruct_result1052 != nil { + unwrapped1053 := deconstruct_result1052 + p.pretty_value(unwrapped1053) } else { panic(ParseError{msg: "No matching rule for term"}) } @@ -1969,147 +1969,147 @@ func (p *PrettyPrinter) pretty_term(msg *pb.Term) interface{} { } func (p *PrettyPrinter) pretty_var(msg *pb.Var) interface{} { - flat1049 := p.tryFlat(msg, func() { p.pretty_var(msg) }) - if flat1049 != nil { - p.write(*flat1049) + flat1059 := p.tryFlat(msg, func() { p.pretty_var(msg) }) + if flat1059 != nil { + p.write(*flat1059) return nil } else { _dollar_dollar := msg - fields1047 := _dollar_dollar.GetName() - unwrapped_fields1048 := fields1047 - p.write(unwrapped_fields1048) + fields1057 := _dollar_dollar.GetName() + unwrapped_fields1058 := fields1057 + p.write(unwrapped_fields1058) } return nil } func (p *PrettyPrinter) pretty_value(msg *pb.Value) interface{} { - flat1075 := p.tryFlat(msg, func() { p.pretty_value(msg) }) - if flat1075 != nil { - p.write(*flat1075) + flat1085 := p.tryFlat(msg, func() { p.pretty_value(msg) }) + if flat1085 != nil { + p.write(*flat1085) return nil } else { _dollar_dollar := msg - var _t1661 *pb.DateValue + var _t1681 *pb.DateValue if hasProtoField(_dollar_dollar, "date_value") { - _t1661 = _dollar_dollar.GetDateValue() + _t1681 = _dollar_dollar.GetDateValue() } - deconstruct_result1073 := _t1661 - if deconstruct_result1073 != nil { - unwrapped1074 := deconstruct_result1073 - p.pretty_date(unwrapped1074) + deconstruct_result1083 := _t1681 + if deconstruct_result1083 != nil { + unwrapped1084 := deconstruct_result1083 + p.pretty_date(unwrapped1084) } else { _dollar_dollar := msg - var _t1662 *pb.DateTimeValue + var _t1682 *pb.DateTimeValue if hasProtoField(_dollar_dollar, "datetime_value") { - _t1662 = _dollar_dollar.GetDatetimeValue() + _t1682 = _dollar_dollar.GetDatetimeValue() } - deconstruct_result1071 := _t1662 - if deconstruct_result1071 != nil { - unwrapped1072 := deconstruct_result1071 - p.pretty_datetime(unwrapped1072) + deconstruct_result1081 := _t1682 + if deconstruct_result1081 != nil { + unwrapped1082 := deconstruct_result1081 + p.pretty_datetime(unwrapped1082) } else { _dollar_dollar := msg - var _t1663 *string + var _t1683 *string if hasProtoField(_dollar_dollar, "string_value") { - _t1663 = ptr(_dollar_dollar.GetStringValue()) + _t1683 = ptr(_dollar_dollar.GetStringValue()) } - deconstruct_result1069 := _t1663 - if deconstruct_result1069 != nil { - unwrapped1070 := *deconstruct_result1069 - p.write(p.formatStringValue(unwrapped1070)) + deconstruct_result1079 := _t1683 + if deconstruct_result1079 != nil { + unwrapped1080 := *deconstruct_result1079 + p.write(p.formatStringValue(unwrapped1080)) } else { _dollar_dollar := msg - var _t1664 *int32 + var _t1684 *int32 if hasProtoField(_dollar_dollar, "int32_value") { - _t1664 = ptr(_dollar_dollar.GetInt32Value()) + _t1684 = ptr(_dollar_dollar.GetInt32Value()) } - deconstruct_result1067 := _t1664 - if deconstruct_result1067 != nil { - unwrapped1068 := *deconstruct_result1067 - p.write(fmt.Sprintf("%di32", unwrapped1068)) + deconstruct_result1077 := _t1684 + if deconstruct_result1077 != nil { + unwrapped1078 := *deconstruct_result1077 + p.write(fmt.Sprintf("%di32", unwrapped1078)) } else { _dollar_dollar := msg - var _t1665 *int64 + var _t1685 *int64 if hasProtoField(_dollar_dollar, "int_value") { - _t1665 = ptr(_dollar_dollar.GetIntValue()) + _t1685 = ptr(_dollar_dollar.GetIntValue()) } - deconstruct_result1065 := _t1665 - if deconstruct_result1065 != nil { - unwrapped1066 := *deconstruct_result1065 - p.write(fmt.Sprintf("%d", unwrapped1066)) + deconstruct_result1075 := _t1685 + if deconstruct_result1075 != nil { + unwrapped1076 := *deconstruct_result1075 + p.write(fmt.Sprintf("%d", unwrapped1076)) } else { _dollar_dollar := msg - var _t1666 *float32 + var _t1686 *float32 if hasProtoField(_dollar_dollar, "float32_value") { - _t1666 = ptr(_dollar_dollar.GetFloat32Value()) + _t1686 = ptr(_dollar_dollar.GetFloat32Value()) } - deconstruct_result1063 := _t1666 - if deconstruct_result1063 != nil { - unwrapped1064 := *deconstruct_result1063 - p.write(formatFloat32(unwrapped1064)) + deconstruct_result1073 := _t1686 + if deconstruct_result1073 != nil { + unwrapped1074 := *deconstruct_result1073 + p.write(formatFloat32(unwrapped1074)) } else { _dollar_dollar := msg - var _t1667 *float64 + var _t1687 *float64 if hasProtoField(_dollar_dollar, "float_value") { - _t1667 = ptr(_dollar_dollar.GetFloatValue()) + _t1687 = ptr(_dollar_dollar.GetFloatValue()) } - deconstruct_result1061 := _t1667 - if deconstruct_result1061 != nil { - unwrapped1062 := *deconstruct_result1061 - p.write(formatFloat64(unwrapped1062)) + deconstruct_result1071 := _t1687 + if deconstruct_result1071 != nil { + unwrapped1072 := *deconstruct_result1071 + p.write(formatFloat64(unwrapped1072)) } else { _dollar_dollar := msg - var _t1668 *uint32 + var _t1688 *uint32 if hasProtoField(_dollar_dollar, "uint32_value") { - _t1668 = ptr(_dollar_dollar.GetUint32Value()) + _t1688 = ptr(_dollar_dollar.GetUint32Value()) } - deconstruct_result1059 := _t1668 - if deconstruct_result1059 != nil { - unwrapped1060 := *deconstruct_result1059 - p.write(fmt.Sprintf("%du32", unwrapped1060)) + deconstruct_result1069 := _t1688 + if deconstruct_result1069 != nil { + unwrapped1070 := *deconstruct_result1069 + p.write(fmt.Sprintf("%du32", unwrapped1070)) } else { _dollar_dollar := msg - var _t1669 *pb.UInt128Value + var _t1689 *pb.UInt128Value if hasProtoField(_dollar_dollar, "uint128_value") { - _t1669 = _dollar_dollar.GetUint128Value() + _t1689 = _dollar_dollar.GetUint128Value() } - deconstruct_result1057 := _t1669 - if deconstruct_result1057 != nil { - unwrapped1058 := deconstruct_result1057 - p.write(p.formatUint128(unwrapped1058)) + deconstruct_result1067 := _t1689 + if deconstruct_result1067 != nil { + unwrapped1068 := deconstruct_result1067 + p.write(p.formatUint128(unwrapped1068)) } else { _dollar_dollar := msg - var _t1670 *pb.Int128Value + var _t1690 *pb.Int128Value if hasProtoField(_dollar_dollar, "int128_value") { - _t1670 = _dollar_dollar.GetInt128Value() + _t1690 = _dollar_dollar.GetInt128Value() } - deconstruct_result1055 := _t1670 - if deconstruct_result1055 != nil { - unwrapped1056 := deconstruct_result1055 - p.write(p.formatInt128(unwrapped1056)) + deconstruct_result1065 := _t1690 + if deconstruct_result1065 != nil { + unwrapped1066 := deconstruct_result1065 + p.write(p.formatInt128(unwrapped1066)) } else { _dollar_dollar := msg - var _t1671 *pb.DecimalValue + var _t1691 *pb.DecimalValue if hasProtoField(_dollar_dollar, "decimal_value") { - _t1671 = _dollar_dollar.GetDecimalValue() + _t1691 = _dollar_dollar.GetDecimalValue() } - deconstruct_result1053 := _t1671 - if deconstruct_result1053 != nil { - unwrapped1054 := deconstruct_result1053 - p.write(p.formatDecimal(unwrapped1054)) + deconstruct_result1063 := _t1691 + if deconstruct_result1063 != nil { + unwrapped1064 := deconstruct_result1063 + p.write(p.formatDecimal(unwrapped1064)) } else { _dollar_dollar := msg - var _t1672 *bool + var _t1692 *bool if hasProtoField(_dollar_dollar, "boolean_value") { - _t1672 = ptr(_dollar_dollar.GetBooleanValue()) + _t1692 = ptr(_dollar_dollar.GetBooleanValue()) } - deconstruct_result1051 := _t1672 - if deconstruct_result1051 != nil { - unwrapped1052 := *deconstruct_result1051 - p.pretty_boolean_value(unwrapped1052) + deconstruct_result1061 := _t1692 + if deconstruct_result1061 != nil { + unwrapped1062 := *deconstruct_result1061 + p.pretty_boolean_value(unwrapped1062) } else { - fields1050 := msg - _ = fields1050 + fields1060 := msg + _ = fields1060 p.write("missing") } } @@ -2128,26 +2128,26 @@ func (p *PrettyPrinter) pretty_value(msg *pb.Value) interface{} { } func (p *PrettyPrinter) pretty_date(msg *pb.DateValue) interface{} { - flat1081 := p.tryFlat(msg, func() { p.pretty_date(msg) }) - if flat1081 != nil { - p.write(*flat1081) + flat1091 := p.tryFlat(msg, func() { p.pretty_date(msg) }) + if flat1091 != nil { + p.write(*flat1091) return nil } else { _dollar_dollar := msg - fields1076 := []interface{}{int64(_dollar_dollar.GetYear()), int64(_dollar_dollar.GetMonth()), int64(_dollar_dollar.GetDay())} - unwrapped_fields1077 := fields1076 + fields1086 := []interface{}{int64(_dollar_dollar.GetYear()), int64(_dollar_dollar.GetMonth()), int64(_dollar_dollar.GetDay())} + unwrapped_fields1087 := fields1086 p.write("(") p.write("date") p.indentSexp() p.newline() - field1078 := unwrapped_fields1077[0].(int64) - p.write(fmt.Sprintf("%d", field1078)) + field1088 := unwrapped_fields1087[0].(int64) + p.write(fmt.Sprintf("%d", field1088)) p.newline() - field1079 := unwrapped_fields1077[1].(int64) - p.write(fmt.Sprintf("%d", field1079)) + field1089 := unwrapped_fields1087[1].(int64) + p.write(fmt.Sprintf("%d", field1089)) p.newline() - field1080 := unwrapped_fields1077[2].(int64) - p.write(fmt.Sprintf("%d", field1080)) + field1090 := unwrapped_fields1087[2].(int64) + p.write(fmt.Sprintf("%d", field1090)) p.dedent() p.write(")") } @@ -2155,40 +2155,40 @@ func (p *PrettyPrinter) pretty_date(msg *pb.DateValue) interface{} { } func (p *PrettyPrinter) pretty_datetime(msg *pb.DateTimeValue) interface{} { - flat1092 := p.tryFlat(msg, func() { p.pretty_datetime(msg) }) - if flat1092 != nil { - p.write(*flat1092) + flat1102 := p.tryFlat(msg, func() { p.pretty_datetime(msg) }) + if flat1102 != nil { + p.write(*flat1102) return nil } else { _dollar_dollar := msg - fields1082 := []interface{}{int64(_dollar_dollar.GetYear()), int64(_dollar_dollar.GetMonth()), int64(_dollar_dollar.GetDay()), int64(_dollar_dollar.GetHour()), int64(_dollar_dollar.GetMinute()), int64(_dollar_dollar.GetSecond()), ptr(int64(_dollar_dollar.GetMicrosecond()))} - unwrapped_fields1083 := fields1082 + fields1092 := []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_fields1093 := fields1092 p.write("(") p.write("datetime") p.indentSexp() p.newline() - field1084 := unwrapped_fields1083[0].(int64) - p.write(fmt.Sprintf("%d", field1084)) + field1094 := unwrapped_fields1093[0].(int64) + p.write(fmt.Sprintf("%d", field1094)) p.newline() - field1085 := unwrapped_fields1083[1].(int64) - p.write(fmt.Sprintf("%d", field1085)) + field1095 := unwrapped_fields1093[1].(int64) + p.write(fmt.Sprintf("%d", field1095)) p.newline() - field1086 := unwrapped_fields1083[2].(int64) - p.write(fmt.Sprintf("%d", field1086)) + field1096 := unwrapped_fields1093[2].(int64) + p.write(fmt.Sprintf("%d", field1096)) p.newline() - field1087 := unwrapped_fields1083[3].(int64) - p.write(fmt.Sprintf("%d", field1087)) + field1097 := unwrapped_fields1093[3].(int64) + p.write(fmt.Sprintf("%d", field1097)) p.newline() - field1088 := unwrapped_fields1083[4].(int64) - p.write(fmt.Sprintf("%d", field1088)) + field1098 := unwrapped_fields1093[4].(int64) + p.write(fmt.Sprintf("%d", field1098)) p.newline() - field1089 := unwrapped_fields1083[5].(int64) - p.write(fmt.Sprintf("%d", field1089)) - field1090 := unwrapped_fields1083[6].(*int64) - if field1090 != nil { + field1099 := unwrapped_fields1093[5].(int64) + p.write(fmt.Sprintf("%d", field1099)) + field1100 := unwrapped_fields1093[6].(*int64) + if field1100 != nil { p.newline() - opt_val1091 := *field1090 - p.write(fmt.Sprintf("%d", opt_val1091)) + opt_val1101 := *field1100 + p.write(fmt.Sprintf("%d", opt_val1101)) } p.dedent() p.write(")") @@ -2197,24 +2197,24 @@ func (p *PrettyPrinter) pretty_datetime(msg *pb.DateTimeValue) interface{} { } func (p *PrettyPrinter) pretty_conjunction(msg *pb.Conjunction) interface{} { - flat1097 := p.tryFlat(msg, func() { p.pretty_conjunction(msg) }) - if flat1097 != nil { - p.write(*flat1097) + flat1107 := p.tryFlat(msg, func() { p.pretty_conjunction(msg) }) + if flat1107 != nil { + p.write(*flat1107) return nil } else { _dollar_dollar := msg - fields1093 := _dollar_dollar.GetArgs() - unwrapped_fields1094 := fields1093 + fields1103 := _dollar_dollar.GetArgs() + unwrapped_fields1104 := fields1103 p.write("(") p.write("and") p.indentSexp() - if !(len(unwrapped_fields1094) == 0) { + if !(len(unwrapped_fields1104) == 0) { p.newline() - for i1096, elem1095 := range unwrapped_fields1094 { - if (i1096 > 0) { + for i1106, elem1105 := range unwrapped_fields1104 { + if (i1106 > 0) { p.newline() } - p.pretty_formula(elem1095) + p.pretty_formula(elem1105) } } p.dedent() @@ -2224,24 +2224,24 @@ func (p *PrettyPrinter) pretty_conjunction(msg *pb.Conjunction) interface{} { } func (p *PrettyPrinter) pretty_disjunction(msg *pb.Disjunction) interface{} { - flat1102 := p.tryFlat(msg, func() { p.pretty_disjunction(msg) }) - if flat1102 != nil { - p.write(*flat1102) + flat1112 := p.tryFlat(msg, func() { p.pretty_disjunction(msg) }) + if flat1112 != nil { + p.write(*flat1112) return nil } else { _dollar_dollar := msg - fields1098 := _dollar_dollar.GetArgs() - unwrapped_fields1099 := fields1098 + fields1108 := _dollar_dollar.GetArgs() + unwrapped_fields1109 := fields1108 p.write("(") p.write("or") p.indentSexp() - if !(len(unwrapped_fields1099) == 0) { + if !(len(unwrapped_fields1109) == 0) { p.newline() - for i1101, elem1100 := range unwrapped_fields1099 { - if (i1101 > 0) { + for i1111, elem1110 := range unwrapped_fields1109 { + if (i1111 > 0) { p.newline() } - p.pretty_formula(elem1100) + p.pretty_formula(elem1110) } } p.dedent() @@ -2251,19 +2251,19 @@ func (p *PrettyPrinter) pretty_disjunction(msg *pb.Disjunction) interface{} { } func (p *PrettyPrinter) pretty_not(msg *pb.Not) interface{} { - flat1105 := p.tryFlat(msg, func() { p.pretty_not(msg) }) - if flat1105 != nil { - p.write(*flat1105) + flat1115 := p.tryFlat(msg, func() { p.pretty_not(msg) }) + if flat1115 != nil { + p.write(*flat1115) return nil } else { _dollar_dollar := msg - fields1103 := _dollar_dollar.GetArg() - unwrapped_fields1104 := fields1103 + fields1113 := _dollar_dollar.GetArg() + unwrapped_fields1114 := fields1113 p.write("(") p.write("not") p.indentSexp() p.newline() - p.pretty_formula(unwrapped_fields1104) + p.pretty_formula(unwrapped_fields1114) p.dedent() p.write(")") } @@ -2271,26 +2271,26 @@ func (p *PrettyPrinter) pretty_not(msg *pb.Not) interface{} { } func (p *PrettyPrinter) pretty_ffi(msg *pb.FFI) interface{} { - flat1111 := p.tryFlat(msg, func() { p.pretty_ffi(msg) }) - if flat1111 != nil { - p.write(*flat1111) + flat1121 := p.tryFlat(msg, func() { p.pretty_ffi(msg) }) + if flat1121 != nil { + p.write(*flat1121) return nil } else { _dollar_dollar := msg - fields1106 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetArgs(), _dollar_dollar.GetTerms()} - unwrapped_fields1107 := fields1106 + fields1116 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetArgs(), _dollar_dollar.GetTerms()} + unwrapped_fields1117 := fields1116 p.write("(") p.write("ffi") p.indentSexp() p.newline() - field1108 := unwrapped_fields1107[0].(string) - p.pretty_name(field1108) + field1118 := unwrapped_fields1117[0].(string) + p.pretty_name(field1118) p.newline() - field1109 := unwrapped_fields1107[1].([]*pb.Abstraction) - p.pretty_ffi_args(field1109) + field1119 := unwrapped_fields1117[1].([]*pb.Abstraction) + p.pretty_ffi_args(field1119) p.newline() - field1110 := unwrapped_fields1107[2].([]*pb.Term) - p.pretty_terms(field1110) + field1120 := unwrapped_fields1117[2].([]*pb.Term) + p.pretty_terms(field1120) p.dedent() p.write(")") } @@ -2298,35 +2298,35 @@ func (p *PrettyPrinter) pretty_ffi(msg *pb.FFI) interface{} { } func (p *PrettyPrinter) pretty_name(msg string) interface{} { - flat1113 := p.tryFlat(msg, func() { p.pretty_name(msg) }) - if flat1113 != nil { - p.write(*flat1113) + flat1123 := p.tryFlat(msg, func() { p.pretty_name(msg) }) + if flat1123 != nil { + p.write(*flat1123) return nil } else { - fields1112 := msg + fields1122 := msg p.write(":") - p.write(fields1112) + p.write(fields1122) } return nil } func (p *PrettyPrinter) pretty_ffi_args(msg []*pb.Abstraction) interface{} { - flat1117 := p.tryFlat(msg, func() { p.pretty_ffi_args(msg) }) - if flat1117 != nil { - p.write(*flat1117) + flat1127 := p.tryFlat(msg, func() { p.pretty_ffi_args(msg) }) + if flat1127 != nil { + p.write(*flat1127) return nil } else { - fields1114 := msg + fields1124 := msg p.write("(") p.write("args") p.indentSexp() - if !(len(fields1114) == 0) { + if !(len(fields1124) == 0) { p.newline() - for i1116, elem1115 := range fields1114 { - if (i1116 > 0) { + for i1126, elem1125 := range fields1124 { + if (i1126 > 0) { p.newline() } - p.pretty_abstraction(elem1115) + p.pretty_abstraction(elem1125) } } p.dedent() @@ -2336,28 +2336,28 @@ func (p *PrettyPrinter) pretty_ffi_args(msg []*pb.Abstraction) interface{} { } func (p *PrettyPrinter) pretty_atom(msg *pb.Atom) interface{} { - flat1124 := p.tryFlat(msg, func() { p.pretty_atom(msg) }) - if flat1124 != nil { - p.write(*flat1124) + flat1134 := p.tryFlat(msg, func() { p.pretty_atom(msg) }) + if flat1134 != nil { + p.write(*flat1134) return nil } else { _dollar_dollar := msg - fields1118 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetTerms()} - unwrapped_fields1119 := fields1118 + fields1128 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetTerms()} + unwrapped_fields1129 := fields1128 p.write("(") p.write("atom") p.indentSexp() p.newline() - field1120 := unwrapped_fields1119[0].(*pb.RelationId) - p.pretty_relation_id(field1120) - field1121 := unwrapped_fields1119[1].([]*pb.Term) - if !(len(field1121) == 0) { + field1130 := unwrapped_fields1129[0].(*pb.RelationId) + p.pretty_relation_id(field1130) + field1131 := unwrapped_fields1129[1].([]*pb.Term) + if !(len(field1131) == 0) { p.newline() - for i1123, elem1122 := range field1121 { - if (i1123 > 0) { + for i1133, elem1132 := range field1131 { + if (i1133 > 0) { p.newline() } - p.pretty_term(elem1122) + p.pretty_term(elem1132) } } p.dedent() @@ -2367,28 +2367,28 @@ func (p *PrettyPrinter) pretty_atom(msg *pb.Atom) interface{} { } func (p *PrettyPrinter) pretty_pragma(msg *pb.Pragma) interface{} { - flat1131 := p.tryFlat(msg, func() { p.pretty_pragma(msg) }) - if flat1131 != nil { - p.write(*flat1131) + flat1141 := p.tryFlat(msg, func() { p.pretty_pragma(msg) }) + if flat1141 != nil { + p.write(*flat1141) return nil } else { _dollar_dollar := msg - fields1125 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetTerms()} - unwrapped_fields1126 := fields1125 + fields1135 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetTerms()} + unwrapped_fields1136 := fields1135 p.write("(") p.write("pragma") p.indentSexp() p.newline() - field1127 := unwrapped_fields1126[0].(string) - p.pretty_name(field1127) - field1128 := unwrapped_fields1126[1].([]*pb.Term) - if !(len(field1128) == 0) { + field1137 := unwrapped_fields1136[0].(string) + p.pretty_name(field1137) + field1138 := unwrapped_fields1136[1].([]*pb.Term) + if !(len(field1138) == 0) { p.newline() - for i1130, elem1129 := range field1128 { - if (i1130 > 0) { + for i1140, elem1139 := range field1138 { + if (i1140 > 0) { p.newline() } - p.pretty_term(elem1129) + p.pretty_term(elem1139) } } p.dedent() @@ -2398,109 +2398,109 @@ func (p *PrettyPrinter) pretty_pragma(msg *pb.Pragma) interface{} { } func (p *PrettyPrinter) pretty_primitive(msg *pb.Primitive) interface{} { - flat1147 := p.tryFlat(msg, func() { p.pretty_primitive(msg) }) - if flat1147 != nil { - p.write(*flat1147) + flat1157 := p.tryFlat(msg, func() { p.pretty_primitive(msg) }) + if flat1157 != nil { + p.write(*flat1157) return nil } else { _dollar_dollar := msg - var _t1673 []interface{} + var _t1693 []interface{} if _dollar_dollar.GetName() == "rel_primitive_eq" { - _t1673 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} + _t1693 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} } - guard_result1146 := _t1673 - if guard_result1146 != nil { + guard_result1156 := _t1693 + if guard_result1156 != nil { p.pretty_eq(msg) } else { _dollar_dollar := msg - var _t1674 []interface{} + var _t1694 []interface{} if _dollar_dollar.GetName() == "rel_primitive_lt_monotype" { - _t1674 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} + _t1694 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} } - guard_result1145 := _t1674 - if guard_result1145 != nil { + guard_result1155 := _t1694 + if guard_result1155 != nil { p.pretty_lt(msg) } else { _dollar_dollar := msg - var _t1675 []interface{} + var _t1695 []interface{} if _dollar_dollar.GetName() == "rel_primitive_lt_eq_monotype" { - _t1675 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} + _t1695 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} } - guard_result1144 := _t1675 - if guard_result1144 != nil { + guard_result1154 := _t1695 + if guard_result1154 != nil { p.pretty_lt_eq(msg) } else { _dollar_dollar := msg - var _t1676 []interface{} + var _t1696 []interface{} if _dollar_dollar.GetName() == "rel_primitive_gt_monotype" { - _t1676 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} + _t1696 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} } - guard_result1143 := _t1676 - if guard_result1143 != nil { + guard_result1153 := _t1696 + if guard_result1153 != nil { p.pretty_gt(msg) } else { _dollar_dollar := msg - var _t1677 []interface{} + var _t1697 []interface{} if _dollar_dollar.GetName() == "rel_primitive_gt_eq_monotype" { - _t1677 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} + _t1697 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} } - guard_result1142 := _t1677 - if guard_result1142 != nil { + guard_result1152 := _t1697 + if guard_result1152 != nil { p.pretty_gt_eq(msg) } else { _dollar_dollar := msg - var _t1678 []interface{} + var _t1698 []interface{} if _dollar_dollar.GetName() == "rel_primitive_add_monotype" { - _t1678 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} + _t1698 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} } - guard_result1141 := _t1678 - if guard_result1141 != nil { + guard_result1151 := _t1698 + if guard_result1151 != nil { p.pretty_add(msg) } else { _dollar_dollar := msg - var _t1679 []interface{} + var _t1699 []interface{} if _dollar_dollar.GetName() == "rel_primitive_subtract_monotype" { - _t1679 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} + _t1699 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} } - guard_result1140 := _t1679 - if guard_result1140 != nil { + guard_result1150 := _t1699 + if guard_result1150 != nil { p.pretty_minus(msg) } else { _dollar_dollar := msg - var _t1680 []interface{} + var _t1700 []interface{} if _dollar_dollar.GetName() == "rel_primitive_multiply_monotype" { - _t1680 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} + _t1700 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} } - guard_result1139 := _t1680 - if guard_result1139 != nil { + guard_result1149 := _t1700 + if guard_result1149 != nil { p.pretty_multiply(msg) } else { _dollar_dollar := msg - var _t1681 []interface{} + var _t1701 []interface{} if _dollar_dollar.GetName() == "rel_primitive_divide_monotype" { - _t1681 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} + _t1701 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} } - guard_result1138 := _t1681 - if guard_result1138 != nil { + guard_result1148 := _t1701 + if guard_result1148 != nil { p.pretty_divide(msg) } else { _dollar_dollar := msg - fields1132 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetTerms()} - unwrapped_fields1133 := fields1132 + fields1142 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetTerms()} + unwrapped_fields1143 := fields1142 p.write("(") p.write("primitive") p.indentSexp() p.newline() - field1134 := unwrapped_fields1133[0].(string) - p.pretty_name(field1134) - field1135 := unwrapped_fields1133[1].([]*pb.RelTerm) - if !(len(field1135) == 0) { + field1144 := unwrapped_fields1143[0].(string) + p.pretty_name(field1144) + field1145 := unwrapped_fields1143[1].([]*pb.RelTerm) + if !(len(field1145) == 0) { p.newline() - for i1137, elem1136 := range field1135 { - if (i1137 > 0) { + for i1147, elem1146 := range field1145 { + if (i1147 > 0) { p.newline() } - p.pretty_rel_term(elem1136) + p.pretty_rel_term(elem1146) } } p.dedent() @@ -2519,27 +2519,27 @@ func (p *PrettyPrinter) pretty_primitive(msg *pb.Primitive) interface{} { } func (p *PrettyPrinter) pretty_eq(msg *pb.Primitive) interface{} { - flat1152 := p.tryFlat(msg, func() { p.pretty_eq(msg) }) - if flat1152 != nil { - p.write(*flat1152) + flat1162 := p.tryFlat(msg, func() { p.pretty_eq(msg) }) + if flat1162 != nil { + p.write(*flat1162) return nil } else { _dollar_dollar := msg - var _t1682 []interface{} + var _t1702 []interface{} if _dollar_dollar.GetName() == "rel_primitive_eq" { - _t1682 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} + _t1702 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} } - fields1148 := _t1682 - unwrapped_fields1149 := fields1148 + fields1158 := _t1702 + unwrapped_fields1159 := fields1158 p.write("(") p.write("=") p.indentSexp() p.newline() - field1150 := unwrapped_fields1149[0].(*pb.Term) - p.pretty_term(field1150) + field1160 := unwrapped_fields1159[0].(*pb.Term) + p.pretty_term(field1160) p.newline() - field1151 := unwrapped_fields1149[1].(*pb.Term) - p.pretty_term(field1151) + field1161 := unwrapped_fields1159[1].(*pb.Term) + p.pretty_term(field1161) p.dedent() p.write(")") } @@ -2547,27 +2547,27 @@ func (p *PrettyPrinter) pretty_eq(msg *pb.Primitive) interface{} { } func (p *PrettyPrinter) pretty_lt(msg *pb.Primitive) interface{} { - flat1157 := p.tryFlat(msg, func() { p.pretty_lt(msg) }) - if flat1157 != nil { - p.write(*flat1157) + flat1167 := p.tryFlat(msg, func() { p.pretty_lt(msg) }) + if flat1167 != nil { + p.write(*flat1167) return nil } else { _dollar_dollar := msg - var _t1683 []interface{} + var _t1703 []interface{} if _dollar_dollar.GetName() == "rel_primitive_lt_monotype" { - _t1683 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} + _t1703 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} } - fields1153 := _t1683 - unwrapped_fields1154 := fields1153 + fields1163 := _t1703 + unwrapped_fields1164 := fields1163 p.write("(") p.write("<") p.indentSexp() p.newline() - field1155 := unwrapped_fields1154[0].(*pb.Term) - p.pretty_term(field1155) + field1165 := unwrapped_fields1164[0].(*pb.Term) + p.pretty_term(field1165) p.newline() - field1156 := unwrapped_fields1154[1].(*pb.Term) - p.pretty_term(field1156) + field1166 := unwrapped_fields1164[1].(*pb.Term) + p.pretty_term(field1166) p.dedent() p.write(")") } @@ -2575,27 +2575,27 @@ func (p *PrettyPrinter) pretty_lt(msg *pb.Primitive) interface{} { } func (p *PrettyPrinter) pretty_lt_eq(msg *pb.Primitive) interface{} { - flat1162 := p.tryFlat(msg, func() { p.pretty_lt_eq(msg) }) - if flat1162 != nil { - p.write(*flat1162) + flat1172 := p.tryFlat(msg, func() { p.pretty_lt_eq(msg) }) + if flat1172 != nil { + p.write(*flat1172) return nil } else { _dollar_dollar := msg - var _t1684 []interface{} + var _t1704 []interface{} if _dollar_dollar.GetName() == "rel_primitive_lt_eq_monotype" { - _t1684 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} + _t1704 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} } - fields1158 := _t1684 - unwrapped_fields1159 := fields1158 + fields1168 := _t1704 + unwrapped_fields1169 := fields1168 p.write("(") p.write("<=") p.indentSexp() p.newline() - field1160 := unwrapped_fields1159[0].(*pb.Term) - p.pretty_term(field1160) + field1170 := unwrapped_fields1169[0].(*pb.Term) + p.pretty_term(field1170) p.newline() - field1161 := unwrapped_fields1159[1].(*pb.Term) - p.pretty_term(field1161) + field1171 := unwrapped_fields1169[1].(*pb.Term) + p.pretty_term(field1171) p.dedent() p.write(")") } @@ -2603,27 +2603,27 @@ func (p *PrettyPrinter) pretty_lt_eq(msg *pb.Primitive) interface{} { } func (p *PrettyPrinter) pretty_gt(msg *pb.Primitive) interface{} { - flat1167 := p.tryFlat(msg, func() { p.pretty_gt(msg) }) - if flat1167 != nil { - p.write(*flat1167) + flat1177 := p.tryFlat(msg, func() { p.pretty_gt(msg) }) + if flat1177 != nil { + p.write(*flat1177) return nil } else { _dollar_dollar := msg - var _t1685 []interface{} + var _t1705 []interface{} if _dollar_dollar.GetName() == "rel_primitive_gt_monotype" { - _t1685 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} + _t1705 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} } - fields1163 := _t1685 - unwrapped_fields1164 := fields1163 + fields1173 := _t1705 + unwrapped_fields1174 := fields1173 p.write("(") p.write(">") p.indentSexp() p.newline() - field1165 := unwrapped_fields1164[0].(*pb.Term) - p.pretty_term(field1165) + field1175 := unwrapped_fields1174[0].(*pb.Term) + p.pretty_term(field1175) p.newline() - field1166 := unwrapped_fields1164[1].(*pb.Term) - p.pretty_term(field1166) + field1176 := unwrapped_fields1174[1].(*pb.Term) + p.pretty_term(field1176) p.dedent() p.write(")") } @@ -2631,27 +2631,27 @@ func (p *PrettyPrinter) pretty_gt(msg *pb.Primitive) interface{} { } func (p *PrettyPrinter) pretty_gt_eq(msg *pb.Primitive) interface{} { - flat1172 := p.tryFlat(msg, func() { p.pretty_gt_eq(msg) }) - if flat1172 != nil { - p.write(*flat1172) + flat1182 := p.tryFlat(msg, func() { p.pretty_gt_eq(msg) }) + if flat1182 != nil { + p.write(*flat1182) return nil } else { _dollar_dollar := msg - var _t1686 []interface{} + var _t1706 []interface{} if _dollar_dollar.GetName() == "rel_primitive_gt_eq_monotype" { - _t1686 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} + _t1706 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} } - fields1168 := _t1686 - unwrapped_fields1169 := fields1168 + fields1178 := _t1706 + unwrapped_fields1179 := fields1178 p.write("(") p.write(">=") p.indentSexp() p.newline() - field1170 := unwrapped_fields1169[0].(*pb.Term) - p.pretty_term(field1170) + field1180 := unwrapped_fields1179[0].(*pb.Term) + p.pretty_term(field1180) p.newline() - field1171 := unwrapped_fields1169[1].(*pb.Term) - p.pretty_term(field1171) + field1181 := unwrapped_fields1179[1].(*pb.Term) + p.pretty_term(field1181) p.dedent() p.write(")") } @@ -2659,30 +2659,30 @@ func (p *PrettyPrinter) pretty_gt_eq(msg *pb.Primitive) interface{} { } func (p *PrettyPrinter) pretty_add(msg *pb.Primitive) interface{} { - flat1178 := p.tryFlat(msg, func() { p.pretty_add(msg) }) - if flat1178 != nil { - p.write(*flat1178) + flat1188 := p.tryFlat(msg, func() { p.pretty_add(msg) }) + if flat1188 != nil { + p.write(*flat1188) return nil } else { _dollar_dollar := msg - var _t1687 []interface{} + var _t1707 []interface{} if _dollar_dollar.GetName() == "rel_primitive_add_monotype" { - _t1687 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} + _t1707 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} } - fields1173 := _t1687 - unwrapped_fields1174 := fields1173 + fields1183 := _t1707 + unwrapped_fields1184 := fields1183 p.write("(") p.write("+") p.indentSexp() p.newline() - field1175 := unwrapped_fields1174[0].(*pb.Term) - p.pretty_term(field1175) + field1185 := unwrapped_fields1184[0].(*pb.Term) + p.pretty_term(field1185) p.newline() - field1176 := unwrapped_fields1174[1].(*pb.Term) - p.pretty_term(field1176) + field1186 := unwrapped_fields1184[1].(*pb.Term) + p.pretty_term(field1186) p.newline() - field1177 := unwrapped_fields1174[2].(*pb.Term) - p.pretty_term(field1177) + field1187 := unwrapped_fields1184[2].(*pb.Term) + p.pretty_term(field1187) p.dedent() p.write(")") } @@ -2690,30 +2690,30 @@ func (p *PrettyPrinter) pretty_add(msg *pb.Primitive) interface{} { } func (p *PrettyPrinter) pretty_minus(msg *pb.Primitive) interface{} { - flat1184 := p.tryFlat(msg, func() { p.pretty_minus(msg) }) - if flat1184 != nil { - p.write(*flat1184) + flat1194 := p.tryFlat(msg, func() { p.pretty_minus(msg) }) + if flat1194 != nil { + p.write(*flat1194) return nil } else { _dollar_dollar := msg - var _t1688 []interface{} + var _t1708 []interface{} if _dollar_dollar.GetName() == "rel_primitive_subtract_monotype" { - _t1688 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} + _t1708 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} } - fields1179 := _t1688 - unwrapped_fields1180 := fields1179 + fields1189 := _t1708 + unwrapped_fields1190 := fields1189 p.write("(") p.write("-") p.indentSexp() p.newline() - field1181 := unwrapped_fields1180[0].(*pb.Term) - p.pretty_term(field1181) + field1191 := unwrapped_fields1190[0].(*pb.Term) + p.pretty_term(field1191) p.newline() - field1182 := unwrapped_fields1180[1].(*pb.Term) - p.pretty_term(field1182) + field1192 := unwrapped_fields1190[1].(*pb.Term) + p.pretty_term(field1192) p.newline() - field1183 := unwrapped_fields1180[2].(*pb.Term) - p.pretty_term(field1183) + field1193 := unwrapped_fields1190[2].(*pb.Term) + p.pretty_term(field1193) p.dedent() p.write(")") } @@ -2721,30 +2721,30 @@ func (p *PrettyPrinter) pretty_minus(msg *pb.Primitive) interface{} { } func (p *PrettyPrinter) pretty_multiply(msg *pb.Primitive) interface{} { - flat1190 := p.tryFlat(msg, func() { p.pretty_multiply(msg) }) - if flat1190 != nil { - p.write(*flat1190) + flat1200 := p.tryFlat(msg, func() { p.pretty_multiply(msg) }) + if flat1200 != nil { + p.write(*flat1200) return nil } else { _dollar_dollar := msg - var _t1689 []interface{} + var _t1709 []interface{} if _dollar_dollar.GetName() == "rel_primitive_multiply_monotype" { - _t1689 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} + _t1709 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} } - fields1185 := _t1689 - unwrapped_fields1186 := fields1185 + fields1195 := _t1709 + unwrapped_fields1196 := fields1195 p.write("(") p.write("*") p.indentSexp() p.newline() - field1187 := unwrapped_fields1186[0].(*pb.Term) - p.pretty_term(field1187) + field1197 := unwrapped_fields1196[0].(*pb.Term) + p.pretty_term(field1197) p.newline() - field1188 := unwrapped_fields1186[1].(*pb.Term) - p.pretty_term(field1188) + field1198 := unwrapped_fields1196[1].(*pb.Term) + p.pretty_term(field1198) p.newline() - field1189 := unwrapped_fields1186[2].(*pb.Term) - p.pretty_term(field1189) + field1199 := unwrapped_fields1196[2].(*pb.Term) + p.pretty_term(field1199) p.dedent() p.write(")") } @@ -2752,30 +2752,30 @@ func (p *PrettyPrinter) pretty_multiply(msg *pb.Primitive) interface{} { } func (p *PrettyPrinter) pretty_divide(msg *pb.Primitive) interface{} { - flat1196 := p.tryFlat(msg, func() { p.pretty_divide(msg) }) - if flat1196 != nil { - p.write(*flat1196) + flat1206 := p.tryFlat(msg, func() { p.pretty_divide(msg) }) + if flat1206 != nil { + p.write(*flat1206) return nil } else { _dollar_dollar := msg - var _t1690 []interface{} + var _t1710 []interface{} if _dollar_dollar.GetName() == "rel_primitive_divide_monotype" { - _t1690 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} + _t1710 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} } - fields1191 := _t1690 - unwrapped_fields1192 := fields1191 + fields1201 := _t1710 + unwrapped_fields1202 := fields1201 p.write("(") p.write("/") p.indentSexp() p.newline() - field1193 := unwrapped_fields1192[0].(*pb.Term) - p.pretty_term(field1193) + field1203 := unwrapped_fields1202[0].(*pb.Term) + p.pretty_term(field1203) p.newline() - field1194 := unwrapped_fields1192[1].(*pb.Term) - p.pretty_term(field1194) + field1204 := unwrapped_fields1202[1].(*pb.Term) + p.pretty_term(field1204) p.newline() - field1195 := unwrapped_fields1192[2].(*pb.Term) - p.pretty_term(field1195) + field1205 := unwrapped_fields1202[2].(*pb.Term) + p.pretty_term(field1205) p.dedent() p.write(")") } @@ -2783,30 +2783,30 @@ func (p *PrettyPrinter) pretty_divide(msg *pb.Primitive) interface{} { } func (p *PrettyPrinter) pretty_rel_term(msg *pb.RelTerm) interface{} { - flat1201 := p.tryFlat(msg, func() { p.pretty_rel_term(msg) }) - if flat1201 != nil { - p.write(*flat1201) + flat1211 := p.tryFlat(msg, func() { p.pretty_rel_term(msg) }) + if flat1211 != nil { + p.write(*flat1211) return nil } else { _dollar_dollar := msg - var _t1691 *pb.Value + var _t1711 *pb.Value if hasProtoField(_dollar_dollar, "specialized_value") { - _t1691 = _dollar_dollar.GetSpecializedValue() + _t1711 = _dollar_dollar.GetSpecializedValue() } - deconstruct_result1199 := _t1691 - if deconstruct_result1199 != nil { - unwrapped1200 := deconstruct_result1199 - p.pretty_specialized_value(unwrapped1200) + deconstruct_result1209 := _t1711 + if deconstruct_result1209 != nil { + unwrapped1210 := deconstruct_result1209 + p.pretty_specialized_value(unwrapped1210) } else { _dollar_dollar := msg - var _t1692 *pb.Term + var _t1712 *pb.Term if hasProtoField(_dollar_dollar, "term") { - _t1692 = _dollar_dollar.GetTerm() + _t1712 = _dollar_dollar.GetTerm() } - deconstruct_result1197 := _t1692 - if deconstruct_result1197 != nil { - unwrapped1198 := deconstruct_result1197 - p.pretty_term(unwrapped1198) + deconstruct_result1207 := _t1712 + if deconstruct_result1207 != nil { + unwrapped1208 := deconstruct_result1207 + p.pretty_term(unwrapped1208) } else { panic(ParseError{msg: "No matching rule for rel_term"}) } @@ -2816,41 +2816,41 @@ func (p *PrettyPrinter) pretty_rel_term(msg *pb.RelTerm) interface{} { } func (p *PrettyPrinter) pretty_specialized_value(msg *pb.Value) interface{} { - flat1203 := p.tryFlat(msg, func() { p.pretty_specialized_value(msg) }) - if flat1203 != nil { - p.write(*flat1203) + flat1213 := p.tryFlat(msg, func() { p.pretty_specialized_value(msg) }) + if flat1213 != nil { + p.write(*flat1213) return nil } else { - fields1202 := msg + fields1212 := msg p.write("#") - p.pretty_raw_value(fields1202) + p.pretty_raw_value(fields1212) } return nil } func (p *PrettyPrinter) pretty_rel_atom(msg *pb.RelAtom) interface{} { - flat1210 := p.tryFlat(msg, func() { p.pretty_rel_atom(msg) }) - if flat1210 != nil { - p.write(*flat1210) + flat1220 := p.tryFlat(msg, func() { p.pretty_rel_atom(msg) }) + if flat1220 != nil { + p.write(*flat1220) return nil } else { _dollar_dollar := msg - fields1204 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetTerms()} - unwrapped_fields1205 := fields1204 + fields1214 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetTerms()} + unwrapped_fields1215 := fields1214 p.write("(") p.write("relatom") p.indentSexp() p.newline() - field1206 := unwrapped_fields1205[0].(string) - p.pretty_name(field1206) - field1207 := unwrapped_fields1205[1].([]*pb.RelTerm) - if !(len(field1207) == 0) { + field1216 := unwrapped_fields1215[0].(string) + p.pretty_name(field1216) + field1217 := unwrapped_fields1215[1].([]*pb.RelTerm) + if !(len(field1217) == 0) { p.newline() - for i1209, elem1208 := range field1207 { - if (i1209 > 0) { + for i1219, elem1218 := range field1217 { + if (i1219 > 0) { p.newline() } - p.pretty_rel_term(elem1208) + p.pretty_rel_term(elem1218) } } p.dedent() @@ -2860,23 +2860,23 @@ func (p *PrettyPrinter) pretty_rel_atom(msg *pb.RelAtom) interface{} { } func (p *PrettyPrinter) pretty_cast(msg *pb.Cast) interface{} { - flat1215 := p.tryFlat(msg, func() { p.pretty_cast(msg) }) - if flat1215 != nil { - p.write(*flat1215) + flat1225 := p.tryFlat(msg, func() { p.pretty_cast(msg) }) + if flat1225 != nil { + p.write(*flat1225) return nil } else { _dollar_dollar := msg - fields1211 := []interface{}{_dollar_dollar.GetInput(), _dollar_dollar.GetResult()} - unwrapped_fields1212 := fields1211 + fields1221 := []interface{}{_dollar_dollar.GetInput(), _dollar_dollar.GetResult()} + unwrapped_fields1222 := fields1221 p.write("(") p.write("cast") p.indentSexp() p.newline() - field1213 := unwrapped_fields1212[0].(*pb.Term) - p.pretty_term(field1213) + field1223 := unwrapped_fields1222[0].(*pb.Term) + p.pretty_term(field1223) p.newline() - field1214 := unwrapped_fields1212[1].(*pb.Term) - p.pretty_term(field1214) + field1224 := unwrapped_fields1222[1].(*pb.Term) + p.pretty_term(field1224) p.dedent() p.write(")") } @@ -2884,22 +2884,22 @@ func (p *PrettyPrinter) pretty_cast(msg *pb.Cast) interface{} { } func (p *PrettyPrinter) pretty_attrs(msg []*pb.Attribute) interface{} { - flat1219 := p.tryFlat(msg, func() { p.pretty_attrs(msg) }) - if flat1219 != nil { - p.write(*flat1219) + flat1229 := p.tryFlat(msg, func() { p.pretty_attrs(msg) }) + if flat1229 != nil { + p.write(*flat1229) return nil } else { - fields1216 := msg + fields1226 := msg p.write("(") p.write("attrs") p.indentSexp() - if !(len(fields1216) == 0) { + if !(len(fields1226) == 0) { p.newline() - for i1218, elem1217 := range fields1216 { - if (i1218 > 0) { + for i1228, elem1227 := range fields1226 { + if (i1228 > 0) { p.newline() } - p.pretty_attribute(elem1217) + p.pretty_attribute(elem1227) } } p.dedent() @@ -2909,28 +2909,28 @@ func (p *PrettyPrinter) pretty_attrs(msg []*pb.Attribute) interface{} { } func (p *PrettyPrinter) pretty_attribute(msg *pb.Attribute) interface{} { - flat1226 := p.tryFlat(msg, func() { p.pretty_attribute(msg) }) - if flat1226 != nil { - p.write(*flat1226) + flat1236 := p.tryFlat(msg, func() { p.pretty_attribute(msg) }) + if flat1236 != nil { + p.write(*flat1236) return nil } else { _dollar_dollar := msg - fields1220 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetArgs()} - unwrapped_fields1221 := fields1220 + fields1230 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetArgs()} + unwrapped_fields1231 := fields1230 p.write("(") p.write("attribute") p.indentSexp() p.newline() - field1222 := unwrapped_fields1221[0].(string) - p.pretty_name(field1222) - field1223 := unwrapped_fields1221[1].([]*pb.Value) - if !(len(field1223) == 0) { + field1232 := unwrapped_fields1231[0].(string) + p.pretty_name(field1232) + field1233 := unwrapped_fields1231[1].([]*pb.Value) + if !(len(field1233) == 0) { p.newline() - for i1225, elem1224 := range field1223 { - if (i1225 > 0) { + for i1235, elem1234 := range field1233 { + if (i1235 > 0) { p.newline() } - p.pretty_raw_value(elem1224) + p.pretty_raw_value(elem1234) } } p.dedent() @@ -2940,39 +2940,39 @@ func (p *PrettyPrinter) pretty_attribute(msg *pb.Attribute) interface{} { } func (p *PrettyPrinter) pretty_algorithm(msg *pb.Algorithm) interface{} { - flat1235 := p.tryFlat(msg, func() { p.pretty_algorithm(msg) }) - if flat1235 != nil { - p.write(*flat1235) + flat1245 := p.tryFlat(msg, func() { p.pretty_algorithm(msg) }) + if flat1245 != nil { + p.write(*flat1245) return nil } else { _dollar_dollar := msg - var _t1693 []*pb.Attribute + var _t1713 []*pb.Attribute if !(len(_dollar_dollar.GetAttrs()) == 0) { - _t1693 = _dollar_dollar.GetAttrs() + _t1713 = _dollar_dollar.GetAttrs() } - fields1227 := []interface{}{_dollar_dollar.GetGlobal(), _dollar_dollar.GetBody(), _t1693} - unwrapped_fields1228 := fields1227 + fields1237 := []interface{}{_dollar_dollar.GetGlobal(), _dollar_dollar.GetBody(), _t1713} + unwrapped_fields1238 := fields1237 p.write("(") p.write("algorithm") p.indentSexp() - field1229 := unwrapped_fields1228[0].([]*pb.RelationId) - if !(len(field1229) == 0) { + field1239 := unwrapped_fields1238[0].([]*pb.RelationId) + if !(len(field1239) == 0) { p.newline() - for i1231, elem1230 := range field1229 { - if (i1231 > 0) { + for i1241, elem1240 := range field1239 { + if (i1241 > 0) { p.newline() } - p.pretty_relation_id(elem1230) + p.pretty_relation_id(elem1240) } } p.newline() - field1232 := unwrapped_fields1228[1].(*pb.Script) - p.pretty_script(field1232) - field1233 := unwrapped_fields1228[2].([]*pb.Attribute) - if field1233 != nil { + field1242 := unwrapped_fields1238[1].(*pb.Script) + p.pretty_script(field1242) + field1243 := unwrapped_fields1238[2].([]*pb.Attribute) + if field1243 != nil { p.newline() - opt_val1234 := field1233 - p.pretty_attrs(opt_val1234) + opt_val1244 := field1243 + p.pretty_attrs(opt_val1244) } p.dedent() p.write(")") @@ -2981,24 +2981,24 @@ func (p *PrettyPrinter) pretty_algorithm(msg *pb.Algorithm) interface{} { } func (p *PrettyPrinter) pretty_script(msg *pb.Script) interface{} { - flat1240 := p.tryFlat(msg, func() { p.pretty_script(msg) }) - if flat1240 != nil { - p.write(*flat1240) + flat1250 := p.tryFlat(msg, func() { p.pretty_script(msg) }) + if flat1250 != nil { + p.write(*flat1250) return nil } else { _dollar_dollar := msg - fields1236 := _dollar_dollar.GetConstructs() - unwrapped_fields1237 := fields1236 + fields1246 := _dollar_dollar.GetConstructs() + unwrapped_fields1247 := fields1246 p.write("(") p.write("script") p.indentSexp() - if !(len(unwrapped_fields1237) == 0) { + if !(len(unwrapped_fields1247) == 0) { p.newline() - for i1239, elem1238 := range unwrapped_fields1237 { - if (i1239 > 0) { + for i1249, elem1248 := range unwrapped_fields1247 { + if (i1249 > 0) { p.newline() } - p.pretty_construct(elem1238) + p.pretty_construct(elem1248) } } p.dedent() @@ -3008,30 +3008,30 @@ func (p *PrettyPrinter) pretty_script(msg *pb.Script) interface{} { } func (p *PrettyPrinter) pretty_construct(msg *pb.Construct) interface{} { - flat1245 := p.tryFlat(msg, func() { p.pretty_construct(msg) }) - if flat1245 != nil { - p.write(*flat1245) + flat1255 := p.tryFlat(msg, func() { p.pretty_construct(msg) }) + if flat1255 != nil { + p.write(*flat1255) return nil } else { _dollar_dollar := msg - var _t1694 *pb.Loop + var _t1714 *pb.Loop if hasProtoField(_dollar_dollar, "loop") { - _t1694 = _dollar_dollar.GetLoop() + _t1714 = _dollar_dollar.GetLoop() } - deconstruct_result1243 := _t1694 - if deconstruct_result1243 != nil { - unwrapped1244 := deconstruct_result1243 - p.pretty_loop(unwrapped1244) + deconstruct_result1253 := _t1714 + if deconstruct_result1253 != nil { + unwrapped1254 := deconstruct_result1253 + p.pretty_loop(unwrapped1254) } else { _dollar_dollar := msg - var _t1695 *pb.Instruction + var _t1715 *pb.Instruction if hasProtoField(_dollar_dollar, "instruction") { - _t1695 = _dollar_dollar.GetInstruction() + _t1715 = _dollar_dollar.GetInstruction() } - deconstruct_result1241 := _t1695 - if deconstruct_result1241 != nil { - unwrapped1242 := deconstruct_result1241 - p.pretty_instruction(unwrapped1242) + deconstruct_result1251 := _t1715 + if deconstruct_result1251 != nil { + unwrapped1252 := deconstruct_result1251 + p.pretty_instruction(unwrapped1252) } else { panic(ParseError{msg: "No matching rule for construct"}) } @@ -3041,32 +3041,32 @@ func (p *PrettyPrinter) pretty_construct(msg *pb.Construct) interface{} { } func (p *PrettyPrinter) pretty_loop(msg *pb.Loop) interface{} { - flat1252 := p.tryFlat(msg, func() { p.pretty_loop(msg) }) - if flat1252 != nil { - p.write(*flat1252) + flat1262 := p.tryFlat(msg, func() { p.pretty_loop(msg) }) + if flat1262 != nil { + p.write(*flat1262) return nil } else { _dollar_dollar := msg - var _t1696 []*pb.Attribute + var _t1716 []*pb.Attribute if !(len(_dollar_dollar.GetAttrs()) == 0) { - _t1696 = _dollar_dollar.GetAttrs() + _t1716 = _dollar_dollar.GetAttrs() } - fields1246 := []interface{}{_dollar_dollar.GetInit(), _dollar_dollar.GetBody(), _t1696} - unwrapped_fields1247 := fields1246 + fields1256 := []interface{}{_dollar_dollar.GetInit(), _dollar_dollar.GetBody(), _t1716} + unwrapped_fields1257 := fields1256 p.write("(") p.write("loop") p.indentSexp() p.newline() - field1248 := unwrapped_fields1247[0].([]*pb.Instruction) - p.pretty_init(field1248) + field1258 := unwrapped_fields1257[0].([]*pb.Instruction) + p.pretty_init(field1258) p.newline() - field1249 := unwrapped_fields1247[1].(*pb.Script) - p.pretty_script(field1249) - field1250 := unwrapped_fields1247[2].([]*pb.Attribute) - if field1250 != nil { + field1259 := unwrapped_fields1257[1].(*pb.Script) + p.pretty_script(field1259) + field1260 := unwrapped_fields1257[2].([]*pb.Attribute) + if field1260 != nil { p.newline() - opt_val1251 := field1250 - p.pretty_attrs(opt_val1251) + opt_val1261 := field1260 + p.pretty_attrs(opt_val1261) } p.dedent() p.write(")") @@ -3075,22 +3075,22 @@ func (p *PrettyPrinter) pretty_loop(msg *pb.Loop) interface{} { } func (p *PrettyPrinter) pretty_init(msg []*pb.Instruction) interface{} { - flat1256 := p.tryFlat(msg, func() { p.pretty_init(msg) }) - if flat1256 != nil { - p.write(*flat1256) + flat1266 := p.tryFlat(msg, func() { p.pretty_init(msg) }) + if flat1266 != nil { + p.write(*flat1266) return nil } else { - fields1253 := msg + fields1263 := msg p.write("(") p.write("init") p.indentSexp() - if !(len(fields1253) == 0) { + if !(len(fields1263) == 0) { p.newline() - for i1255, elem1254 := range fields1253 { - if (i1255 > 0) { + for i1265, elem1264 := range fields1263 { + if (i1265 > 0) { p.newline() } - p.pretty_instruction(elem1254) + p.pretty_instruction(elem1264) } } p.dedent() @@ -3100,60 +3100,60 @@ func (p *PrettyPrinter) pretty_init(msg []*pb.Instruction) interface{} { } func (p *PrettyPrinter) pretty_instruction(msg *pb.Instruction) interface{} { - flat1267 := p.tryFlat(msg, func() { p.pretty_instruction(msg) }) - if flat1267 != nil { - p.write(*flat1267) + flat1277 := p.tryFlat(msg, func() { p.pretty_instruction(msg) }) + if flat1277 != nil { + p.write(*flat1277) return nil } else { _dollar_dollar := msg - var _t1697 *pb.Assign + var _t1717 *pb.Assign if hasProtoField(_dollar_dollar, "assign") { - _t1697 = _dollar_dollar.GetAssign() + _t1717 = _dollar_dollar.GetAssign() } - deconstruct_result1265 := _t1697 - if deconstruct_result1265 != nil { - unwrapped1266 := deconstruct_result1265 - p.pretty_assign(unwrapped1266) + deconstruct_result1275 := _t1717 + if deconstruct_result1275 != nil { + unwrapped1276 := deconstruct_result1275 + p.pretty_assign(unwrapped1276) } else { _dollar_dollar := msg - var _t1698 *pb.Upsert + var _t1718 *pb.Upsert if hasProtoField(_dollar_dollar, "upsert") { - _t1698 = _dollar_dollar.GetUpsert() + _t1718 = _dollar_dollar.GetUpsert() } - deconstruct_result1263 := _t1698 - if deconstruct_result1263 != nil { - unwrapped1264 := deconstruct_result1263 - p.pretty_upsert(unwrapped1264) + deconstruct_result1273 := _t1718 + if deconstruct_result1273 != nil { + unwrapped1274 := deconstruct_result1273 + p.pretty_upsert(unwrapped1274) } else { _dollar_dollar := msg - var _t1699 *pb.Break + var _t1719 *pb.Break if hasProtoField(_dollar_dollar, "break") { - _t1699 = _dollar_dollar.GetBreak() + _t1719 = _dollar_dollar.GetBreak() } - deconstruct_result1261 := _t1699 - if deconstruct_result1261 != nil { - unwrapped1262 := deconstruct_result1261 - p.pretty_break(unwrapped1262) + deconstruct_result1271 := _t1719 + if deconstruct_result1271 != nil { + unwrapped1272 := deconstruct_result1271 + p.pretty_break(unwrapped1272) } else { _dollar_dollar := msg - var _t1700 *pb.MonoidDef + var _t1720 *pb.MonoidDef if hasProtoField(_dollar_dollar, "monoid_def") { - _t1700 = _dollar_dollar.GetMonoidDef() + _t1720 = _dollar_dollar.GetMonoidDef() } - deconstruct_result1259 := _t1700 - if deconstruct_result1259 != nil { - unwrapped1260 := deconstruct_result1259 - p.pretty_monoid_def(unwrapped1260) + deconstruct_result1269 := _t1720 + if deconstruct_result1269 != nil { + unwrapped1270 := deconstruct_result1269 + p.pretty_monoid_def(unwrapped1270) } else { _dollar_dollar := msg - var _t1701 *pb.MonusDef + var _t1721 *pb.MonusDef if hasProtoField(_dollar_dollar, "monus_def") { - _t1701 = _dollar_dollar.GetMonusDef() + _t1721 = _dollar_dollar.GetMonusDef() } - deconstruct_result1257 := _t1701 - if deconstruct_result1257 != nil { - unwrapped1258 := deconstruct_result1257 - p.pretty_monus_def(unwrapped1258) + deconstruct_result1267 := _t1721 + if deconstruct_result1267 != nil { + unwrapped1268 := deconstruct_result1267 + p.pretty_monus_def(unwrapped1268) } else { panic(ParseError{msg: "No matching rule for instruction"}) } @@ -3166,32 +3166,32 @@ func (p *PrettyPrinter) pretty_instruction(msg *pb.Instruction) interface{} { } func (p *PrettyPrinter) pretty_assign(msg *pb.Assign) interface{} { - flat1274 := p.tryFlat(msg, func() { p.pretty_assign(msg) }) - if flat1274 != nil { - p.write(*flat1274) + flat1284 := p.tryFlat(msg, func() { p.pretty_assign(msg) }) + if flat1284 != nil { + p.write(*flat1284) return nil } else { _dollar_dollar := msg - var _t1702 []*pb.Attribute + var _t1722 []*pb.Attribute if !(len(_dollar_dollar.GetAttrs()) == 0) { - _t1702 = _dollar_dollar.GetAttrs() + _t1722 = _dollar_dollar.GetAttrs() } - fields1268 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetBody(), _t1702} - unwrapped_fields1269 := fields1268 + fields1278 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetBody(), _t1722} + unwrapped_fields1279 := fields1278 p.write("(") p.write("assign") p.indentSexp() p.newline() - field1270 := unwrapped_fields1269[0].(*pb.RelationId) - p.pretty_relation_id(field1270) + field1280 := unwrapped_fields1279[0].(*pb.RelationId) + p.pretty_relation_id(field1280) p.newline() - field1271 := unwrapped_fields1269[1].(*pb.Abstraction) - p.pretty_abstraction(field1271) - field1272 := unwrapped_fields1269[2].([]*pb.Attribute) - if field1272 != nil { + field1281 := unwrapped_fields1279[1].(*pb.Abstraction) + p.pretty_abstraction(field1281) + field1282 := unwrapped_fields1279[2].([]*pb.Attribute) + if field1282 != nil { p.newline() - opt_val1273 := field1272 - p.pretty_attrs(opt_val1273) + opt_val1283 := field1282 + p.pretty_attrs(opt_val1283) } p.dedent() p.write(")") @@ -3200,32 +3200,32 @@ func (p *PrettyPrinter) pretty_assign(msg *pb.Assign) interface{} { } func (p *PrettyPrinter) pretty_upsert(msg *pb.Upsert) interface{} { - flat1281 := p.tryFlat(msg, func() { p.pretty_upsert(msg) }) - if flat1281 != nil { - p.write(*flat1281) + flat1291 := p.tryFlat(msg, func() { p.pretty_upsert(msg) }) + if flat1291 != nil { + p.write(*flat1291) return nil } else { _dollar_dollar := msg - var _t1703 []*pb.Attribute + var _t1723 []*pb.Attribute if !(len(_dollar_dollar.GetAttrs()) == 0) { - _t1703 = _dollar_dollar.GetAttrs() + _t1723 = _dollar_dollar.GetAttrs() } - fields1275 := []interface{}{_dollar_dollar.GetName(), []interface{}{_dollar_dollar.GetBody(), _dollar_dollar.GetValueArity()}, _t1703} - unwrapped_fields1276 := fields1275 + fields1285 := []interface{}{_dollar_dollar.GetName(), []interface{}{_dollar_dollar.GetBody(), _dollar_dollar.GetValueArity()}, _t1723} + unwrapped_fields1286 := fields1285 p.write("(") p.write("upsert") p.indentSexp() p.newline() - field1277 := unwrapped_fields1276[0].(*pb.RelationId) - p.pretty_relation_id(field1277) + field1287 := unwrapped_fields1286[0].(*pb.RelationId) + p.pretty_relation_id(field1287) p.newline() - field1278 := unwrapped_fields1276[1].([]interface{}) - p.pretty_abstraction_with_arity(field1278) - field1279 := unwrapped_fields1276[2].([]*pb.Attribute) - if field1279 != nil { + field1288 := unwrapped_fields1286[1].([]interface{}) + p.pretty_abstraction_with_arity(field1288) + field1289 := unwrapped_fields1286[2].([]*pb.Attribute) + if field1289 != nil { p.newline() - opt_val1280 := field1279 - p.pretty_attrs(opt_val1280) + opt_val1290 := field1289 + p.pretty_attrs(opt_val1290) } p.dedent() p.write(")") @@ -3234,22 +3234,22 @@ func (p *PrettyPrinter) pretty_upsert(msg *pb.Upsert) interface{} { } func (p *PrettyPrinter) pretty_abstraction_with_arity(msg []interface{}) interface{} { - flat1286 := p.tryFlat(msg, func() { p.pretty_abstraction_with_arity(msg) }) - if flat1286 != nil { - p.write(*flat1286) + flat1296 := p.tryFlat(msg, func() { p.pretty_abstraction_with_arity(msg) }) + if flat1296 != nil { + p.write(*flat1296) return nil } else { _dollar_dollar := msg - _t1704 := p.deconstruct_bindings_with_arity(_dollar_dollar[0].(*pb.Abstraction), _dollar_dollar[1].(int64)) - fields1282 := []interface{}{_t1704, _dollar_dollar[0].(*pb.Abstraction).GetValue()} - unwrapped_fields1283 := fields1282 + _t1724 := p.deconstruct_bindings_with_arity(_dollar_dollar[0].(*pb.Abstraction), _dollar_dollar[1].(int64)) + fields1292 := []interface{}{_t1724, _dollar_dollar[0].(*pb.Abstraction).GetValue()} + unwrapped_fields1293 := fields1292 p.write("(") p.indent() - field1284 := unwrapped_fields1283[0].([]interface{}) - p.pretty_bindings(field1284) + field1294 := unwrapped_fields1293[0].([]interface{}) + p.pretty_bindings(field1294) p.newline() - field1285 := unwrapped_fields1283[1].(*pb.Formula) - p.pretty_formula(field1285) + field1295 := unwrapped_fields1293[1].(*pb.Formula) + p.pretty_formula(field1295) p.dedent() p.write(")") } @@ -3257,32 +3257,32 @@ func (p *PrettyPrinter) pretty_abstraction_with_arity(msg []interface{}) interfa } func (p *PrettyPrinter) pretty_break(msg *pb.Break) interface{} { - flat1293 := p.tryFlat(msg, func() { p.pretty_break(msg) }) - if flat1293 != nil { - p.write(*flat1293) + flat1303 := p.tryFlat(msg, func() { p.pretty_break(msg) }) + if flat1303 != nil { + p.write(*flat1303) return nil } else { _dollar_dollar := msg - var _t1705 []*pb.Attribute + var _t1725 []*pb.Attribute if !(len(_dollar_dollar.GetAttrs()) == 0) { - _t1705 = _dollar_dollar.GetAttrs() + _t1725 = _dollar_dollar.GetAttrs() } - fields1287 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetBody(), _t1705} - unwrapped_fields1288 := fields1287 + fields1297 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetBody(), _t1725} + unwrapped_fields1298 := fields1297 p.write("(") p.write("break") p.indentSexp() p.newline() - field1289 := unwrapped_fields1288[0].(*pb.RelationId) - p.pretty_relation_id(field1289) + field1299 := unwrapped_fields1298[0].(*pb.RelationId) + p.pretty_relation_id(field1299) p.newline() - field1290 := unwrapped_fields1288[1].(*pb.Abstraction) - p.pretty_abstraction(field1290) - field1291 := unwrapped_fields1288[2].([]*pb.Attribute) - if field1291 != nil { + field1300 := unwrapped_fields1298[1].(*pb.Abstraction) + p.pretty_abstraction(field1300) + field1301 := unwrapped_fields1298[2].([]*pb.Attribute) + if field1301 != nil { p.newline() - opt_val1292 := field1291 - p.pretty_attrs(opt_val1292) + opt_val1302 := field1301 + p.pretty_attrs(opt_val1302) } p.dedent() p.write(")") @@ -3291,35 +3291,35 @@ func (p *PrettyPrinter) pretty_break(msg *pb.Break) interface{} { } func (p *PrettyPrinter) pretty_monoid_def(msg *pb.MonoidDef) interface{} { - flat1301 := p.tryFlat(msg, func() { p.pretty_monoid_def(msg) }) - if flat1301 != nil { - p.write(*flat1301) + flat1311 := p.tryFlat(msg, func() { p.pretty_monoid_def(msg) }) + if flat1311 != nil { + p.write(*flat1311) return nil } else { _dollar_dollar := msg - var _t1706 []*pb.Attribute + var _t1726 []*pb.Attribute if !(len(_dollar_dollar.GetAttrs()) == 0) { - _t1706 = _dollar_dollar.GetAttrs() + _t1726 = _dollar_dollar.GetAttrs() } - fields1294 := []interface{}{_dollar_dollar.GetMonoid(), _dollar_dollar.GetName(), []interface{}{_dollar_dollar.GetBody(), _dollar_dollar.GetValueArity()}, _t1706} - unwrapped_fields1295 := fields1294 + fields1304 := []interface{}{_dollar_dollar.GetMonoid(), _dollar_dollar.GetName(), []interface{}{_dollar_dollar.GetBody(), _dollar_dollar.GetValueArity()}, _t1726} + unwrapped_fields1305 := fields1304 p.write("(") p.write("monoid") p.indentSexp() p.newline() - field1296 := unwrapped_fields1295[0].(*pb.Monoid) - p.pretty_monoid(field1296) + field1306 := unwrapped_fields1305[0].(*pb.Monoid) + p.pretty_monoid(field1306) p.newline() - field1297 := unwrapped_fields1295[1].(*pb.RelationId) - p.pretty_relation_id(field1297) + field1307 := unwrapped_fields1305[1].(*pb.RelationId) + p.pretty_relation_id(field1307) p.newline() - field1298 := unwrapped_fields1295[2].([]interface{}) - p.pretty_abstraction_with_arity(field1298) - field1299 := unwrapped_fields1295[3].([]*pb.Attribute) - if field1299 != nil { + field1308 := unwrapped_fields1305[2].([]interface{}) + p.pretty_abstraction_with_arity(field1308) + field1309 := unwrapped_fields1305[3].([]*pb.Attribute) + if field1309 != nil { p.newline() - opt_val1300 := field1299 - p.pretty_attrs(opt_val1300) + opt_val1310 := field1309 + p.pretty_attrs(opt_val1310) } p.dedent() p.write(")") @@ -3328,50 +3328,50 @@ func (p *PrettyPrinter) pretty_monoid_def(msg *pb.MonoidDef) interface{} { } func (p *PrettyPrinter) pretty_monoid(msg *pb.Monoid) interface{} { - flat1310 := p.tryFlat(msg, func() { p.pretty_monoid(msg) }) - if flat1310 != nil { - p.write(*flat1310) + flat1320 := p.tryFlat(msg, func() { p.pretty_monoid(msg) }) + if flat1320 != nil { + p.write(*flat1320) return nil } else { _dollar_dollar := msg - var _t1707 *pb.OrMonoid + var _t1727 *pb.OrMonoid if hasProtoField(_dollar_dollar, "or_monoid") { - _t1707 = _dollar_dollar.GetOrMonoid() + _t1727 = _dollar_dollar.GetOrMonoid() } - deconstruct_result1308 := _t1707 - if deconstruct_result1308 != nil { - unwrapped1309 := deconstruct_result1308 - p.pretty_or_monoid(unwrapped1309) + deconstruct_result1318 := _t1727 + if deconstruct_result1318 != nil { + unwrapped1319 := deconstruct_result1318 + p.pretty_or_monoid(unwrapped1319) } else { _dollar_dollar := msg - var _t1708 *pb.MinMonoid + var _t1728 *pb.MinMonoid if hasProtoField(_dollar_dollar, "min_monoid") { - _t1708 = _dollar_dollar.GetMinMonoid() + _t1728 = _dollar_dollar.GetMinMonoid() } - deconstruct_result1306 := _t1708 - if deconstruct_result1306 != nil { - unwrapped1307 := deconstruct_result1306 - p.pretty_min_monoid(unwrapped1307) + deconstruct_result1316 := _t1728 + if deconstruct_result1316 != nil { + unwrapped1317 := deconstruct_result1316 + p.pretty_min_monoid(unwrapped1317) } else { _dollar_dollar := msg - var _t1709 *pb.MaxMonoid + var _t1729 *pb.MaxMonoid if hasProtoField(_dollar_dollar, "max_monoid") { - _t1709 = _dollar_dollar.GetMaxMonoid() + _t1729 = _dollar_dollar.GetMaxMonoid() } - deconstruct_result1304 := _t1709 - if deconstruct_result1304 != nil { - unwrapped1305 := deconstruct_result1304 - p.pretty_max_monoid(unwrapped1305) + deconstruct_result1314 := _t1729 + if deconstruct_result1314 != nil { + unwrapped1315 := deconstruct_result1314 + p.pretty_max_monoid(unwrapped1315) } else { _dollar_dollar := msg - var _t1710 *pb.SumMonoid + var _t1730 *pb.SumMonoid if hasProtoField(_dollar_dollar, "sum_monoid") { - _t1710 = _dollar_dollar.GetSumMonoid() + _t1730 = _dollar_dollar.GetSumMonoid() } - deconstruct_result1302 := _t1710 - if deconstruct_result1302 != nil { - unwrapped1303 := deconstruct_result1302 - p.pretty_sum_monoid(unwrapped1303) + deconstruct_result1312 := _t1730 + if deconstruct_result1312 != nil { + unwrapped1313 := deconstruct_result1312 + p.pretty_sum_monoid(unwrapped1313) } else { panic(ParseError{msg: "No matching rule for monoid"}) } @@ -3383,8 +3383,8 @@ func (p *PrettyPrinter) pretty_monoid(msg *pb.Monoid) interface{} { } func (p *PrettyPrinter) pretty_or_monoid(msg *pb.OrMonoid) interface{} { - fields1311 := msg - _ = fields1311 + fields1321 := msg + _ = fields1321 p.write("(") p.write("or") p.write(")") @@ -3392,19 +3392,19 @@ func (p *PrettyPrinter) pretty_or_monoid(msg *pb.OrMonoid) interface{} { } func (p *PrettyPrinter) pretty_min_monoid(msg *pb.MinMonoid) interface{} { - flat1314 := p.tryFlat(msg, func() { p.pretty_min_monoid(msg) }) - if flat1314 != nil { - p.write(*flat1314) + flat1324 := p.tryFlat(msg, func() { p.pretty_min_monoid(msg) }) + if flat1324 != nil { + p.write(*flat1324) return nil } else { _dollar_dollar := msg - fields1312 := _dollar_dollar.GetType() - unwrapped_fields1313 := fields1312 + fields1322 := _dollar_dollar.GetType() + unwrapped_fields1323 := fields1322 p.write("(") p.write("min") p.indentSexp() p.newline() - p.pretty_type(unwrapped_fields1313) + p.pretty_type(unwrapped_fields1323) p.dedent() p.write(")") } @@ -3412,19 +3412,19 @@ func (p *PrettyPrinter) pretty_min_monoid(msg *pb.MinMonoid) interface{} { } func (p *PrettyPrinter) pretty_max_monoid(msg *pb.MaxMonoid) interface{} { - flat1317 := p.tryFlat(msg, func() { p.pretty_max_monoid(msg) }) - if flat1317 != nil { - p.write(*flat1317) + flat1327 := p.tryFlat(msg, func() { p.pretty_max_monoid(msg) }) + if flat1327 != nil { + p.write(*flat1327) return nil } else { _dollar_dollar := msg - fields1315 := _dollar_dollar.GetType() - unwrapped_fields1316 := fields1315 + fields1325 := _dollar_dollar.GetType() + unwrapped_fields1326 := fields1325 p.write("(") p.write("max") p.indentSexp() p.newline() - p.pretty_type(unwrapped_fields1316) + p.pretty_type(unwrapped_fields1326) p.dedent() p.write(")") } @@ -3432,19 +3432,19 @@ func (p *PrettyPrinter) pretty_max_monoid(msg *pb.MaxMonoid) interface{} { } func (p *PrettyPrinter) pretty_sum_monoid(msg *pb.SumMonoid) interface{} { - flat1320 := p.tryFlat(msg, func() { p.pretty_sum_monoid(msg) }) - if flat1320 != nil { - p.write(*flat1320) + flat1330 := p.tryFlat(msg, func() { p.pretty_sum_monoid(msg) }) + if flat1330 != nil { + p.write(*flat1330) return nil } else { _dollar_dollar := msg - fields1318 := _dollar_dollar.GetType() - unwrapped_fields1319 := fields1318 + fields1328 := _dollar_dollar.GetType() + unwrapped_fields1329 := fields1328 p.write("(") p.write("sum") p.indentSexp() p.newline() - p.pretty_type(unwrapped_fields1319) + p.pretty_type(unwrapped_fields1329) p.dedent() p.write(")") } @@ -3452,35 +3452,35 @@ func (p *PrettyPrinter) pretty_sum_monoid(msg *pb.SumMonoid) interface{} { } func (p *PrettyPrinter) pretty_monus_def(msg *pb.MonusDef) interface{} { - flat1328 := p.tryFlat(msg, func() { p.pretty_monus_def(msg) }) - if flat1328 != nil { - p.write(*flat1328) + flat1338 := p.tryFlat(msg, func() { p.pretty_monus_def(msg) }) + if flat1338 != nil { + p.write(*flat1338) return nil } else { _dollar_dollar := msg - var _t1711 []*pb.Attribute + var _t1731 []*pb.Attribute if !(len(_dollar_dollar.GetAttrs()) == 0) { - _t1711 = _dollar_dollar.GetAttrs() + _t1731 = _dollar_dollar.GetAttrs() } - fields1321 := []interface{}{_dollar_dollar.GetMonoid(), _dollar_dollar.GetName(), []interface{}{_dollar_dollar.GetBody(), _dollar_dollar.GetValueArity()}, _t1711} - unwrapped_fields1322 := fields1321 + fields1331 := []interface{}{_dollar_dollar.GetMonoid(), _dollar_dollar.GetName(), []interface{}{_dollar_dollar.GetBody(), _dollar_dollar.GetValueArity()}, _t1731} + unwrapped_fields1332 := fields1331 p.write("(") p.write("monus") p.indentSexp() p.newline() - field1323 := unwrapped_fields1322[0].(*pb.Monoid) - p.pretty_monoid(field1323) + field1333 := unwrapped_fields1332[0].(*pb.Monoid) + p.pretty_monoid(field1333) p.newline() - field1324 := unwrapped_fields1322[1].(*pb.RelationId) - p.pretty_relation_id(field1324) + field1334 := unwrapped_fields1332[1].(*pb.RelationId) + p.pretty_relation_id(field1334) p.newline() - field1325 := unwrapped_fields1322[2].([]interface{}) - p.pretty_abstraction_with_arity(field1325) - field1326 := unwrapped_fields1322[3].([]*pb.Attribute) - if field1326 != nil { + field1335 := unwrapped_fields1332[2].([]interface{}) + p.pretty_abstraction_with_arity(field1335) + field1336 := unwrapped_fields1332[3].([]*pb.Attribute) + if field1336 != nil { p.newline() - opt_val1327 := field1326 - p.pretty_attrs(opt_val1327) + opt_val1337 := field1336 + p.pretty_attrs(opt_val1337) } p.dedent() p.write(")") @@ -3489,29 +3489,29 @@ func (p *PrettyPrinter) pretty_monus_def(msg *pb.MonusDef) interface{} { } func (p *PrettyPrinter) pretty_constraint(msg *pb.Constraint) interface{} { - flat1335 := p.tryFlat(msg, func() { p.pretty_constraint(msg) }) - if flat1335 != nil { - p.write(*flat1335) + flat1345 := p.tryFlat(msg, func() { p.pretty_constraint(msg) }) + if flat1345 != nil { + p.write(*flat1345) return nil } else { _dollar_dollar := msg - fields1329 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetFunctionalDependency().GetGuard(), _dollar_dollar.GetFunctionalDependency().GetKeys(), _dollar_dollar.GetFunctionalDependency().GetValues()} - unwrapped_fields1330 := fields1329 + fields1339 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetFunctionalDependency().GetGuard(), _dollar_dollar.GetFunctionalDependency().GetKeys(), _dollar_dollar.GetFunctionalDependency().GetValues()} + unwrapped_fields1340 := fields1339 p.write("(") p.write("functional_dependency") p.indentSexp() p.newline() - field1331 := unwrapped_fields1330[0].(*pb.RelationId) - p.pretty_relation_id(field1331) + field1341 := unwrapped_fields1340[0].(*pb.RelationId) + p.pretty_relation_id(field1341) p.newline() - field1332 := unwrapped_fields1330[1].(*pb.Abstraction) - p.pretty_abstraction(field1332) + field1342 := unwrapped_fields1340[1].(*pb.Abstraction) + p.pretty_abstraction(field1342) p.newline() - field1333 := unwrapped_fields1330[2].([]*pb.Var) - p.pretty_functional_dependency_keys(field1333) + field1343 := unwrapped_fields1340[2].([]*pb.Var) + p.pretty_functional_dependency_keys(field1343) p.newline() - field1334 := unwrapped_fields1330[3].([]*pb.Var) - p.pretty_functional_dependency_values(field1334) + field1344 := unwrapped_fields1340[3].([]*pb.Var) + p.pretty_functional_dependency_values(field1344) p.dedent() p.write(")") } @@ -3519,22 +3519,22 @@ func (p *PrettyPrinter) pretty_constraint(msg *pb.Constraint) interface{} { } func (p *PrettyPrinter) pretty_functional_dependency_keys(msg []*pb.Var) interface{} { - flat1339 := p.tryFlat(msg, func() { p.pretty_functional_dependency_keys(msg) }) - if flat1339 != nil { - p.write(*flat1339) + flat1349 := p.tryFlat(msg, func() { p.pretty_functional_dependency_keys(msg) }) + if flat1349 != nil { + p.write(*flat1349) return nil } else { - fields1336 := msg + fields1346 := msg p.write("(") p.write("keys") p.indentSexp() - if !(len(fields1336) == 0) { + if !(len(fields1346) == 0) { p.newline() - for i1338, elem1337 := range fields1336 { - if (i1338 > 0) { + for i1348, elem1347 := range fields1346 { + if (i1348 > 0) { p.newline() } - p.pretty_var(elem1337) + p.pretty_var(elem1347) } } p.dedent() @@ -3544,22 +3544,22 @@ func (p *PrettyPrinter) pretty_functional_dependency_keys(msg []*pb.Var) interfa } func (p *PrettyPrinter) pretty_functional_dependency_values(msg []*pb.Var) interface{} { - flat1343 := p.tryFlat(msg, func() { p.pretty_functional_dependency_values(msg) }) - if flat1343 != nil { - p.write(*flat1343) + flat1353 := p.tryFlat(msg, func() { p.pretty_functional_dependency_values(msg) }) + if flat1353 != nil { + p.write(*flat1353) return nil } else { - fields1340 := msg + fields1350 := msg p.write("(") p.write("values") p.indentSexp() - if !(len(fields1340) == 0) { + if !(len(fields1350) == 0) { p.newline() - for i1342, elem1341 := range fields1340 { - if (i1342 > 0) { + for i1352, elem1351 := range fields1350 { + if (i1352 > 0) { p.newline() } - p.pretty_var(elem1341) + p.pretty_var(elem1351) } } p.dedent() @@ -3569,50 +3569,50 @@ func (p *PrettyPrinter) pretty_functional_dependency_values(msg []*pb.Var) inter } func (p *PrettyPrinter) pretty_data(msg *pb.Data) interface{} { - flat1352 := p.tryFlat(msg, func() { p.pretty_data(msg) }) - if flat1352 != nil { - p.write(*flat1352) + flat1362 := p.tryFlat(msg, func() { p.pretty_data(msg) }) + if flat1362 != nil { + p.write(*flat1362) return nil } else { _dollar_dollar := msg - var _t1712 *pb.EDB + var _t1732 *pb.EDB if hasProtoField(_dollar_dollar, "edb") { - _t1712 = _dollar_dollar.GetEdb() + _t1732 = _dollar_dollar.GetEdb() } - deconstruct_result1350 := _t1712 - if deconstruct_result1350 != nil { - unwrapped1351 := deconstruct_result1350 - p.pretty_edb(unwrapped1351) + deconstruct_result1360 := _t1732 + if deconstruct_result1360 != nil { + unwrapped1361 := deconstruct_result1360 + p.pretty_edb(unwrapped1361) } else { _dollar_dollar := msg - var _t1713 *pb.BeTreeRelation + var _t1733 *pb.BeTreeRelation if hasProtoField(_dollar_dollar, "betree_relation") { - _t1713 = _dollar_dollar.GetBetreeRelation() + _t1733 = _dollar_dollar.GetBetreeRelation() } - deconstruct_result1348 := _t1713 - if deconstruct_result1348 != nil { - unwrapped1349 := deconstruct_result1348 - p.pretty_betree_relation(unwrapped1349) + deconstruct_result1358 := _t1733 + if deconstruct_result1358 != nil { + unwrapped1359 := deconstruct_result1358 + p.pretty_betree_relation(unwrapped1359) } else { _dollar_dollar := msg - var _t1714 *pb.CSVData + var _t1734 *pb.CSVData if hasProtoField(_dollar_dollar, "csv_data") { - _t1714 = _dollar_dollar.GetCsvData() + _t1734 = _dollar_dollar.GetCsvData() } - deconstruct_result1346 := _t1714 - if deconstruct_result1346 != nil { - unwrapped1347 := deconstruct_result1346 - p.pretty_csv_data(unwrapped1347) + deconstruct_result1356 := _t1734 + if deconstruct_result1356 != nil { + unwrapped1357 := deconstruct_result1356 + p.pretty_csv_data(unwrapped1357) } else { _dollar_dollar := msg - var _t1715 *pb.IcebergData + var _t1735 *pb.IcebergData if hasProtoField(_dollar_dollar, "iceberg_data") { - _t1715 = _dollar_dollar.GetIcebergData() + _t1735 = _dollar_dollar.GetIcebergData() } - deconstruct_result1344 := _t1715 - if deconstruct_result1344 != nil { - unwrapped1345 := deconstruct_result1344 - p.pretty_iceberg_data(unwrapped1345) + deconstruct_result1354 := _t1735 + if deconstruct_result1354 != nil { + unwrapped1355 := deconstruct_result1354 + p.pretty_iceberg_data(unwrapped1355) } else { panic(ParseError{msg: "No matching rule for data"}) } @@ -3624,26 +3624,26 @@ func (p *PrettyPrinter) pretty_data(msg *pb.Data) interface{} { } func (p *PrettyPrinter) pretty_edb(msg *pb.EDB) interface{} { - flat1358 := p.tryFlat(msg, func() { p.pretty_edb(msg) }) - if flat1358 != nil { - p.write(*flat1358) + flat1368 := p.tryFlat(msg, func() { p.pretty_edb(msg) }) + if flat1368 != nil { + p.write(*flat1368) return nil } else { _dollar_dollar := msg - fields1353 := []interface{}{_dollar_dollar.GetTargetId(), _dollar_dollar.GetPath(), _dollar_dollar.GetTypes()} - unwrapped_fields1354 := fields1353 + fields1363 := []interface{}{_dollar_dollar.GetTargetId(), _dollar_dollar.GetPath(), _dollar_dollar.GetTypes()} + unwrapped_fields1364 := fields1363 p.write("(") p.write("edb") p.indentSexp() p.newline() - field1355 := unwrapped_fields1354[0].(*pb.RelationId) - p.pretty_relation_id(field1355) + field1365 := unwrapped_fields1364[0].(*pb.RelationId) + p.pretty_relation_id(field1365) p.newline() - field1356 := unwrapped_fields1354[1].([]string) - p.pretty_edb_path(field1356) + field1366 := unwrapped_fields1364[1].([]string) + p.pretty_edb_path(field1366) p.newline() - field1357 := unwrapped_fields1354[2].([]*pb.Type) - p.pretty_edb_types(field1357) + field1367 := unwrapped_fields1364[2].([]*pb.Type) + p.pretty_edb_types(field1367) p.dedent() p.write(")") } @@ -3651,19 +3651,19 @@ func (p *PrettyPrinter) pretty_edb(msg *pb.EDB) interface{} { } func (p *PrettyPrinter) pretty_edb_path(msg []string) interface{} { - flat1362 := p.tryFlat(msg, func() { p.pretty_edb_path(msg) }) - if flat1362 != nil { - p.write(*flat1362) + flat1372 := p.tryFlat(msg, func() { p.pretty_edb_path(msg) }) + if flat1372 != nil { + p.write(*flat1372) return nil } else { - fields1359 := msg + fields1369 := msg p.write("[") p.indent() - for i1361, elem1360 := range fields1359 { - if (i1361 > 0) { + for i1371, elem1370 := range fields1369 { + if (i1371 > 0) { p.newline() } - p.write(p.formatStringValue(elem1360)) + p.write(p.formatStringValue(elem1370)) } p.dedent() p.write("]") @@ -3672,19 +3672,19 @@ func (p *PrettyPrinter) pretty_edb_path(msg []string) interface{} { } func (p *PrettyPrinter) pretty_edb_types(msg []*pb.Type) interface{} { - flat1366 := p.tryFlat(msg, func() { p.pretty_edb_types(msg) }) - if flat1366 != nil { - p.write(*flat1366) + flat1376 := p.tryFlat(msg, func() { p.pretty_edb_types(msg) }) + if flat1376 != nil { + p.write(*flat1376) return nil } else { - fields1363 := msg + fields1373 := msg p.write("[") p.indent() - for i1365, elem1364 := range fields1363 { - if (i1365 > 0) { + for i1375, elem1374 := range fields1373 { + if (i1375 > 0) { p.newline() } - p.pretty_type(elem1364) + p.pretty_type(elem1374) } p.dedent() p.write("]") @@ -3693,23 +3693,23 @@ func (p *PrettyPrinter) pretty_edb_types(msg []*pb.Type) interface{} { } func (p *PrettyPrinter) pretty_betree_relation(msg *pb.BeTreeRelation) interface{} { - flat1371 := p.tryFlat(msg, func() { p.pretty_betree_relation(msg) }) - if flat1371 != nil { - p.write(*flat1371) + flat1381 := p.tryFlat(msg, func() { p.pretty_betree_relation(msg) }) + if flat1381 != nil { + p.write(*flat1381) return nil } else { _dollar_dollar := msg - fields1367 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetRelationInfo()} - unwrapped_fields1368 := fields1367 + fields1377 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetRelationInfo()} + unwrapped_fields1378 := fields1377 p.write("(") p.write("betree_relation") p.indentSexp() p.newline() - field1369 := unwrapped_fields1368[0].(*pb.RelationId) - p.pretty_relation_id(field1369) + field1379 := unwrapped_fields1378[0].(*pb.RelationId) + p.pretty_relation_id(field1379) p.newline() - field1370 := unwrapped_fields1368[1].(*pb.BeTreeInfo) - p.pretty_betree_info(field1370) + field1380 := unwrapped_fields1378[1].(*pb.BeTreeInfo) + p.pretty_betree_info(field1380) p.dedent() p.write(")") } @@ -3717,27 +3717,27 @@ func (p *PrettyPrinter) pretty_betree_relation(msg *pb.BeTreeRelation) interface } func (p *PrettyPrinter) pretty_betree_info(msg *pb.BeTreeInfo) interface{} { - flat1377 := p.tryFlat(msg, func() { p.pretty_betree_info(msg) }) - if flat1377 != nil { - p.write(*flat1377) + flat1387 := p.tryFlat(msg, func() { p.pretty_betree_info(msg) }) + if flat1387 != nil { + p.write(*flat1387) return nil } else { _dollar_dollar := msg - _t1716 := p.deconstruct_betree_info_config(_dollar_dollar) - fields1372 := []interface{}{_dollar_dollar.GetKeyTypes(), _dollar_dollar.GetValueTypes(), _t1716} - unwrapped_fields1373 := fields1372 + _t1736 := p.deconstruct_betree_info_config(_dollar_dollar) + fields1382 := []interface{}{_dollar_dollar.GetKeyTypes(), _dollar_dollar.GetValueTypes(), _t1736} + unwrapped_fields1383 := fields1382 p.write("(") p.write("betree_info") p.indentSexp() p.newline() - field1374 := unwrapped_fields1373[0].([]*pb.Type) - p.pretty_betree_info_key_types(field1374) + field1384 := unwrapped_fields1383[0].([]*pb.Type) + p.pretty_betree_info_key_types(field1384) p.newline() - field1375 := unwrapped_fields1373[1].([]*pb.Type) - p.pretty_betree_info_value_types(field1375) + field1385 := unwrapped_fields1383[1].([]*pb.Type) + p.pretty_betree_info_value_types(field1385) p.newline() - field1376 := unwrapped_fields1373[2].([][]interface{}) - p.pretty_config_dict(field1376) + field1386 := unwrapped_fields1383[2].([][]interface{}) + p.pretty_config_dict(field1386) p.dedent() p.write(")") } @@ -3745,22 +3745,22 @@ func (p *PrettyPrinter) pretty_betree_info(msg *pb.BeTreeInfo) interface{} { } func (p *PrettyPrinter) pretty_betree_info_key_types(msg []*pb.Type) interface{} { - flat1381 := p.tryFlat(msg, func() { p.pretty_betree_info_key_types(msg) }) - if flat1381 != nil { - p.write(*flat1381) + flat1391 := p.tryFlat(msg, func() { p.pretty_betree_info_key_types(msg) }) + if flat1391 != nil { + p.write(*flat1391) return nil } else { - fields1378 := msg + fields1388 := msg p.write("(") p.write("key_types") p.indentSexp() - if !(len(fields1378) == 0) { + if !(len(fields1388) == 0) { p.newline() - for i1380, elem1379 := range fields1378 { - if (i1380 > 0) { + for i1390, elem1389 := range fields1388 { + if (i1390 > 0) { p.newline() } - p.pretty_type(elem1379) + p.pretty_type(elem1389) } } p.dedent() @@ -3770,22 +3770,22 @@ func (p *PrettyPrinter) pretty_betree_info_key_types(msg []*pb.Type) interface{} } func (p *PrettyPrinter) pretty_betree_info_value_types(msg []*pb.Type) interface{} { - flat1385 := p.tryFlat(msg, func() { p.pretty_betree_info_value_types(msg) }) - if flat1385 != nil { - p.write(*flat1385) + flat1395 := p.tryFlat(msg, func() { p.pretty_betree_info_value_types(msg) }) + if flat1395 != nil { + p.write(*flat1395) return nil } else { - fields1382 := msg + fields1392 := msg p.write("(") p.write("value_types") p.indentSexp() - if !(len(fields1382) == 0) { + if !(len(fields1392) == 0) { p.newline() - for i1384, elem1383 := range fields1382 { - if (i1384 > 0) { + for i1394, elem1393 := range fields1392 { + if (i1394 > 0) { p.newline() } - p.pretty_type(elem1383) + p.pretty_type(elem1393) } } p.dedent() @@ -3795,29 +3795,29 @@ func (p *PrettyPrinter) pretty_betree_info_value_types(msg []*pb.Type) interface } func (p *PrettyPrinter) pretty_csv_data(msg *pb.CSVData) interface{} { - flat1392 := p.tryFlat(msg, func() { p.pretty_csv_data(msg) }) - if flat1392 != nil { - p.write(*flat1392) + flat1402 := p.tryFlat(msg, func() { p.pretty_csv_data(msg) }) + if flat1402 != nil { + p.write(*flat1402) return nil } else { _dollar_dollar := msg - fields1386 := []interface{}{_dollar_dollar.GetLocator(), _dollar_dollar.GetConfig(), _dollar_dollar.GetColumns(), _dollar_dollar.GetAsof()} - unwrapped_fields1387 := fields1386 + fields1396 := []interface{}{_dollar_dollar.GetLocator(), _dollar_dollar.GetConfig(), _dollar_dollar.GetColumns(), _dollar_dollar.GetAsof()} + unwrapped_fields1397 := fields1396 p.write("(") p.write("csv_data") p.indentSexp() p.newline() - field1388 := unwrapped_fields1387[0].(*pb.CSVLocator) - p.pretty_csvlocator(field1388) + field1398 := unwrapped_fields1397[0].(*pb.CSVLocator) + p.pretty_csvlocator(field1398) p.newline() - field1389 := unwrapped_fields1387[1].(*pb.CSVConfig) - p.pretty_csv_config(field1389) + field1399 := unwrapped_fields1397[1].(*pb.CSVConfig) + p.pretty_csv_config(field1399) p.newline() - field1390 := unwrapped_fields1387[2].([]*pb.GNFColumn) - p.pretty_gnf_columns(field1390) + field1400 := unwrapped_fields1397[2].([]*pb.GNFColumn) + p.pretty_gnf_columns(field1400) p.newline() - field1391 := unwrapped_fields1387[3].(string) - p.pretty_csv_asof(field1391) + field1401 := unwrapped_fields1397[3].(string) + p.pretty_csv_asof(field1401) p.dedent() p.write(")") } @@ -3825,36 +3825,36 @@ func (p *PrettyPrinter) pretty_csv_data(msg *pb.CSVData) interface{} { } func (p *PrettyPrinter) pretty_csvlocator(msg *pb.CSVLocator) interface{} { - flat1399 := p.tryFlat(msg, func() { p.pretty_csvlocator(msg) }) - if flat1399 != nil { - p.write(*flat1399) + flat1409 := p.tryFlat(msg, func() { p.pretty_csvlocator(msg) }) + if flat1409 != nil { + p.write(*flat1409) return nil } else { _dollar_dollar := msg - var _t1717 []string + var _t1737 []string if !(len(_dollar_dollar.GetPaths()) == 0) { - _t1717 = _dollar_dollar.GetPaths() + _t1737 = _dollar_dollar.GetPaths() } - var _t1718 *string + var _t1738 *string if string(_dollar_dollar.GetInlineData()) != "" { - _t1718 = ptr(string(_dollar_dollar.GetInlineData())) + _t1738 = ptr(string(_dollar_dollar.GetInlineData())) } - fields1393 := []interface{}{_t1717, _t1718} - unwrapped_fields1394 := fields1393 + fields1403 := []interface{}{_t1737, _t1738} + unwrapped_fields1404 := fields1403 p.write("(") p.write("csv_locator") p.indentSexp() - field1395 := unwrapped_fields1394[0].([]string) - if field1395 != nil { + field1405 := unwrapped_fields1404[0].([]string) + if field1405 != nil { p.newline() - opt_val1396 := field1395 - p.pretty_csv_locator_paths(opt_val1396) + opt_val1406 := field1405 + p.pretty_csv_locator_paths(opt_val1406) } - field1397 := unwrapped_fields1394[1].(*string) - if field1397 != nil { + field1407 := unwrapped_fields1404[1].(*string) + if field1407 != nil { p.newline() - opt_val1398 := *field1397 - p.pretty_csv_locator_inline_data(opt_val1398) + opt_val1408 := *field1407 + p.pretty_csv_locator_inline_data(opt_val1408) } p.dedent() p.write(")") @@ -3863,22 +3863,22 @@ func (p *PrettyPrinter) pretty_csvlocator(msg *pb.CSVLocator) interface{} { } func (p *PrettyPrinter) pretty_csv_locator_paths(msg []string) interface{} { - flat1403 := p.tryFlat(msg, func() { p.pretty_csv_locator_paths(msg) }) - if flat1403 != nil { - p.write(*flat1403) + flat1413 := p.tryFlat(msg, func() { p.pretty_csv_locator_paths(msg) }) + if flat1413 != nil { + p.write(*flat1413) return nil } else { - fields1400 := msg + fields1410 := msg p.write("(") p.write("paths") p.indentSexp() - if !(len(fields1400) == 0) { + if !(len(fields1410) == 0) { p.newline() - for i1402, elem1401 := range fields1400 { - if (i1402 > 0) { + for i1412, elem1411 := range fields1410 { + if (i1412 > 0) { p.newline() } - p.write(p.formatStringValue(elem1401)) + p.write(p.formatStringValue(elem1411)) } } p.dedent() @@ -3888,17 +3888,17 @@ func (p *PrettyPrinter) pretty_csv_locator_paths(msg []string) interface{} { } func (p *PrettyPrinter) pretty_csv_locator_inline_data(msg string) interface{} { - flat1405 := p.tryFlat(msg, func() { p.pretty_csv_locator_inline_data(msg) }) - if flat1405 != nil { - p.write(*flat1405) + flat1415 := p.tryFlat(msg, func() { p.pretty_csv_locator_inline_data(msg) }) + if flat1415 != nil { + p.write(*flat1415) return nil } else { - fields1404 := msg + fields1414 := msg p.write("(") p.write("inline_data") p.indentSexp() p.newline() - p.write(p.formatStringValue(fields1404)) + p.write(p.formatStringValue(fields1414)) p.dedent() p.write(")") } @@ -3906,27 +3906,27 @@ func (p *PrettyPrinter) pretty_csv_locator_inline_data(msg string) interface{} { } func (p *PrettyPrinter) pretty_csv_config(msg *pb.CSVConfig) interface{} { - flat1411 := p.tryFlat(msg, func() { p.pretty_csv_config(msg) }) - if flat1411 != nil { - p.write(*flat1411) + flat1421 := p.tryFlat(msg, func() { p.pretty_csv_config(msg) }) + if flat1421 != nil { + p.write(*flat1421) return nil } else { _dollar_dollar := msg - _t1719 := p.deconstruct_csv_config(_dollar_dollar) - _t1720 := p.deconstruct_csv_storage_integration_optional(_dollar_dollar) - fields1406 := []interface{}{_t1719, _t1720} - unwrapped_fields1407 := fields1406 + _t1739 := p.deconstruct_csv_config(_dollar_dollar) + _t1740 := p.deconstruct_csv_storage_integration_optional(_dollar_dollar) + fields1416 := []interface{}{_t1739, _t1740} + unwrapped_fields1417 := fields1416 p.write("(") p.write("csv_config") p.indentSexp() p.newline() - field1408 := unwrapped_fields1407[0].([][]interface{}) - p.pretty_config_dict(field1408) - field1409 := unwrapped_fields1407[1].([][]interface{}) - if field1409 != nil { + field1418 := unwrapped_fields1417[0].([][]interface{}) + p.pretty_config_dict(field1418) + field1419 := unwrapped_fields1417[1].([][]interface{}) + if field1419 != nil { p.newline() - opt_val1410 := field1409 - p.pretty__storage_integration(opt_val1410) + opt_val1420 := field1419 + p.pretty__storage_integration(opt_val1420) } p.dedent() p.write(")") @@ -3935,17 +3935,17 @@ func (p *PrettyPrinter) pretty_csv_config(msg *pb.CSVConfig) interface{} { } func (p *PrettyPrinter) pretty__storage_integration(msg [][]interface{}) interface{} { - flat1413 := p.tryFlat(msg, func() { p.pretty__storage_integration(msg) }) - if flat1413 != nil { - p.write(*flat1413) + flat1423 := p.tryFlat(msg, func() { p.pretty__storage_integration(msg) }) + if flat1423 != nil { + p.write(*flat1423) return nil } else { - fields1412 := msg + fields1422 := msg p.write("(") p.write("storage_integration") p.indentSexp() p.newline() - p.pretty_config_dict(fields1412) + p.pretty_config_dict(fields1422) p.dedent() p.write(")") } @@ -3953,22 +3953,22 @@ func (p *PrettyPrinter) pretty__storage_integration(msg [][]interface{}) interfa } func (p *PrettyPrinter) pretty_gnf_columns(msg []*pb.GNFColumn) interface{} { - flat1417 := p.tryFlat(msg, func() { p.pretty_gnf_columns(msg) }) - if flat1417 != nil { - p.write(*flat1417) + flat1427 := p.tryFlat(msg, func() { p.pretty_gnf_columns(msg) }) + if flat1427 != nil { + p.write(*flat1427) return nil } else { - fields1414 := msg + fields1424 := msg p.write("(") p.write("columns") p.indentSexp() - if !(len(fields1414) == 0) { + if !(len(fields1424) == 0) { p.newline() - for i1416, elem1415 := range fields1414 { - if (i1416 > 0) { + for i1426, elem1425 := range fields1424 { + if (i1426 > 0) { p.newline() } - p.pretty_gnf_column(elem1415) + p.pretty_gnf_column(elem1425) } } p.dedent() @@ -3978,38 +3978,38 @@ func (p *PrettyPrinter) pretty_gnf_columns(msg []*pb.GNFColumn) interface{} { } func (p *PrettyPrinter) pretty_gnf_column(msg *pb.GNFColumn) interface{} { - flat1426 := p.tryFlat(msg, func() { p.pretty_gnf_column(msg) }) - if flat1426 != nil { - p.write(*flat1426) + flat1436 := p.tryFlat(msg, func() { p.pretty_gnf_column(msg) }) + if flat1436 != nil { + p.write(*flat1436) return nil } else { _dollar_dollar := msg - var _t1721 *pb.RelationId + var _t1741 *pb.RelationId if hasProtoField(_dollar_dollar, "target_id") { - _t1721 = _dollar_dollar.GetTargetId() + _t1741 = _dollar_dollar.GetTargetId() } - fields1418 := []interface{}{_dollar_dollar.GetColumnPath(), _t1721, _dollar_dollar.GetTypes()} - unwrapped_fields1419 := fields1418 + fields1428 := []interface{}{_dollar_dollar.GetColumnPath(), _t1741, _dollar_dollar.GetTypes()} + unwrapped_fields1429 := fields1428 p.write("(") p.write("column") p.indentSexp() p.newline() - field1420 := unwrapped_fields1419[0].([]string) - p.pretty_gnf_column_path(field1420) - field1421 := unwrapped_fields1419[1].(*pb.RelationId) - if field1421 != nil { + field1430 := unwrapped_fields1429[0].([]string) + p.pretty_gnf_column_path(field1430) + field1431 := unwrapped_fields1429[1].(*pb.RelationId) + if field1431 != nil { p.newline() - opt_val1422 := field1421 - p.pretty_relation_id(opt_val1422) + opt_val1432 := field1431 + p.pretty_relation_id(opt_val1432) } p.newline() p.write("[") - field1423 := unwrapped_fields1419[2].([]*pb.Type) - for i1425, elem1424 := range field1423 { - if (i1425 > 0) { + field1433 := unwrapped_fields1429[2].([]*pb.Type) + for i1435, elem1434 := range field1433 { + if (i1435 > 0) { p.newline() } - p.pretty_type(elem1424) + p.pretty_type(elem1434) } p.write("]") p.dedent() @@ -4019,36 +4019,36 @@ func (p *PrettyPrinter) pretty_gnf_column(msg *pb.GNFColumn) interface{} { } func (p *PrettyPrinter) pretty_gnf_column_path(msg []string) interface{} { - flat1433 := p.tryFlat(msg, func() { p.pretty_gnf_column_path(msg) }) - if flat1433 != nil { - p.write(*flat1433) + flat1443 := p.tryFlat(msg, func() { p.pretty_gnf_column_path(msg) }) + if flat1443 != nil { + p.write(*flat1443) return nil } else { _dollar_dollar := msg - var _t1722 *string + var _t1742 *string if int64(len(_dollar_dollar)) == 1 { - _t1722 = ptr(_dollar_dollar[0]) + _t1742 = ptr(_dollar_dollar[0]) } - deconstruct_result1431 := _t1722 - if deconstruct_result1431 != nil { - unwrapped1432 := *deconstruct_result1431 - p.write(p.formatStringValue(unwrapped1432)) + deconstruct_result1441 := _t1742 + if deconstruct_result1441 != nil { + unwrapped1442 := *deconstruct_result1441 + p.write(p.formatStringValue(unwrapped1442)) } else { _dollar_dollar := msg - var _t1723 []string + var _t1743 []string if int64(len(_dollar_dollar)) != 1 { - _t1723 = _dollar_dollar + _t1743 = _dollar_dollar } - deconstruct_result1427 := _t1723 - if deconstruct_result1427 != nil { - unwrapped1428 := deconstruct_result1427 + deconstruct_result1437 := _t1743 + if deconstruct_result1437 != nil { + unwrapped1438 := deconstruct_result1437 p.write("[") p.indent() - for i1430, elem1429 := range unwrapped1428 { - if (i1430 > 0) { + for i1440, elem1439 := range unwrapped1438 { + if (i1440 > 0) { p.newline() } - p.write(p.formatStringValue(elem1429)) + p.write(p.formatStringValue(elem1439)) } p.dedent() p.write("]") @@ -4061,17 +4061,17 @@ func (p *PrettyPrinter) pretty_gnf_column_path(msg []string) interface{} { } func (p *PrettyPrinter) pretty_csv_asof(msg string) interface{} { - flat1435 := p.tryFlat(msg, func() { p.pretty_csv_asof(msg) }) - if flat1435 != nil { - p.write(*flat1435) + flat1445 := p.tryFlat(msg, func() { p.pretty_csv_asof(msg) }) + if flat1445 != nil { + p.write(*flat1445) return nil } else { - fields1434 := msg + fields1444 := msg p.write("(") p.write("asof") p.indentSexp() p.newline() - p.write(p.formatStringValue(fields1434)) + p.write(p.formatStringValue(fields1444)) p.dedent() p.write(")") } @@ -4079,43 +4079,43 @@ func (p *PrettyPrinter) pretty_csv_asof(msg string) interface{} { } func (p *PrettyPrinter) pretty_iceberg_data(msg *pb.IcebergData) interface{} { - flat1446 := p.tryFlat(msg, func() { p.pretty_iceberg_data(msg) }) - if flat1446 != nil { - p.write(*flat1446) + flat1456 := p.tryFlat(msg, func() { p.pretty_iceberg_data(msg) }) + if flat1456 != nil { + p.write(*flat1456) return nil } else { _dollar_dollar := msg - _t1724 := p.deconstruct_iceberg_data_from_snapshot_optional(_dollar_dollar) - _t1725 := p.deconstruct_iceberg_data_to_snapshot_optional(_dollar_dollar) - fields1436 := []interface{}{_dollar_dollar.GetLocator(), _dollar_dollar.GetConfig(), _dollar_dollar.GetColumns(), _t1724, _t1725, _dollar_dollar.GetReturnsDelta()} - unwrapped_fields1437 := fields1436 + _t1744 := p.deconstruct_iceberg_data_from_snapshot_optional(_dollar_dollar) + _t1745 := p.deconstruct_iceberg_data_to_snapshot_optional(_dollar_dollar) + fields1446 := []interface{}{_dollar_dollar.GetLocator(), _dollar_dollar.GetConfig(), _dollar_dollar.GetColumns(), _t1744, _t1745, _dollar_dollar.GetReturnsDelta()} + unwrapped_fields1447 := fields1446 p.write("(") p.write("iceberg_data") p.indentSexp() p.newline() - field1438 := unwrapped_fields1437[0].(*pb.IcebergLocator) - p.pretty_iceberg_locator(field1438) + field1448 := unwrapped_fields1447[0].(*pb.IcebergLocator) + p.pretty_iceberg_locator(field1448) p.newline() - field1439 := unwrapped_fields1437[1].(*pb.IcebergCatalogConfig) - p.pretty_iceberg_catalog_config(field1439) + field1449 := unwrapped_fields1447[1].(*pb.IcebergCatalogConfig) + p.pretty_iceberg_catalog_config(field1449) p.newline() - field1440 := unwrapped_fields1437[2].([]*pb.GNFColumn) - p.pretty_gnf_columns(field1440) - field1441 := unwrapped_fields1437[3].(*string) - if field1441 != nil { + field1450 := unwrapped_fields1447[2].([]*pb.GNFColumn) + p.pretty_gnf_columns(field1450) + field1451 := unwrapped_fields1447[3].(*string) + if field1451 != nil { p.newline() - opt_val1442 := *field1441 - p.pretty_iceberg_from_snapshot(opt_val1442) + opt_val1452 := *field1451 + p.pretty_iceberg_from_snapshot(opt_val1452) } - field1443 := unwrapped_fields1437[4].(*string) - if field1443 != nil { + field1453 := unwrapped_fields1447[4].(*string) + if field1453 != nil { p.newline() - opt_val1444 := *field1443 - p.pretty_iceberg_to_snapshot(opt_val1444) + opt_val1454 := *field1453 + p.pretty_iceberg_to_snapshot(opt_val1454) } p.newline() - field1445 := unwrapped_fields1437[5].(bool) - p.pretty_boolean_value(field1445) + field1455 := unwrapped_fields1447[5].(bool) + p.pretty_boolean_value(field1455) p.dedent() p.write(")") } @@ -4123,26 +4123,26 @@ func (p *PrettyPrinter) pretty_iceberg_data(msg *pb.IcebergData) interface{} { } func (p *PrettyPrinter) pretty_iceberg_locator(msg *pb.IcebergLocator) interface{} { - flat1452 := p.tryFlat(msg, func() { p.pretty_iceberg_locator(msg) }) - if flat1452 != nil { - p.write(*flat1452) + flat1462 := p.tryFlat(msg, func() { p.pretty_iceberg_locator(msg) }) + if flat1462 != nil { + p.write(*flat1462) return nil } else { _dollar_dollar := msg - fields1447 := []interface{}{_dollar_dollar.GetTableName(), _dollar_dollar.GetNamespace(), _dollar_dollar.GetWarehouse()} - unwrapped_fields1448 := fields1447 + fields1457 := []interface{}{_dollar_dollar.GetTableName(), _dollar_dollar.GetNamespace(), _dollar_dollar.GetWarehouse()} + unwrapped_fields1458 := fields1457 p.write("(") p.write("iceberg_locator") p.indentSexp() p.newline() - field1449 := unwrapped_fields1448[0].(string) - p.pretty_iceberg_locator_table_name(field1449) + field1459 := unwrapped_fields1458[0].(string) + p.pretty_iceberg_locator_table_name(field1459) p.newline() - field1450 := unwrapped_fields1448[1].([]string) - p.pretty_iceberg_locator_namespace(field1450) + field1460 := unwrapped_fields1458[1].([]string) + p.pretty_iceberg_locator_namespace(field1460) p.newline() - field1451 := unwrapped_fields1448[2].(string) - p.pretty_iceberg_locator_warehouse(field1451) + field1461 := unwrapped_fields1458[2].(string) + p.pretty_iceberg_locator_warehouse(field1461) p.dedent() p.write(")") } @@ -4150,17 +4150,17 @@ func (p *PrettyPrinter) pretty_iceberg_locator(msg *pb.IcebergLocator) interface } func (p *PrettyPrinter) pretty_iceberg_locator_table_name(msg string) interface{} { - flat1454 := p.tryFlat(msg, func() { p.pretty_iceberg_locator_table_name(msg) }) - if flat1454 != nil { - p.write(*flat1454) + flat1464 := p.tryFlat(msg, func() { p.pretty_iceberg_locator_table_name(msg) }) + if flat1464 != nil { + p.write(*flat1464) return nil } else { - fields1453 := msg + fields1463 := msg p.write("(") p.write("table_name") p.indentSexp() p.newline() - p.write(p.formatStringValue(fields1453)) + p.write(p.formatStringValue(fields1463)) p.dedent() p.write(")") } @@ -4168,22 +4168,22 @@ func (p *PrettyPrinter) pretty_iceberg_locator_table_name(msg string) interface{ } func (p *PrettyPrinter) pretty_iceberg_locator_namespace(msg []string) interface{} { - flat1458 := p.tryFlat(msg, func() { p.pretty_iceberg_locator_namespace(msg) }) - if flat1458 != nil { - p.write(*flat1458) + flat1468 := p.tryFlat(msg, func() { p.pretty_iceberg_locator_namespace(msg) }) + if flat1468 != nil { + p.write(*flat1468) return nil } else { - fields1455 := msg + fields1465 := msg p.write("(") p.write("namespace") p.indentSexp() - if !(len(fields1455) == 0) { + if !(len(fields1465) == 0) { p.newline() - for i1457, elem1456 := range fields1455 { - if (i1457 > 0) { + for i1467, elem1466 := range fields1465 { + if (i1467 > 0) { p.newline() } - p.write(p.formatStringValue(elem1456)) + p.write(p.formatStringValue(elem1466)) } } p.dedent() @@ -4193,17 +4193,17 @@ func (p *PrettyPrinter) pretty_iceberg_locator_namespace(msg []string) interface } func (p *PrettyPrinter) pretty_iceberg_locator_warehouse(msg string) interface{} { - flat1460 := p.tryFlat(msg, func() { p.pretty_iceberg_locator_warehouse(msg) }) - if flat1460 != nil { - p.write(*flat1460) + flat1470 := p.tryFlat(msg, func() { p.pretty_iceberg_locator_warehouse(msg) }) + if flat1470 != nil { + p.write(*flat1470) return nil } else { - fields1459 := msg + fields1469 := msg p.write("(") p.write("warehouse") p.indentSexp() p.newline() - p.write(p.formatStringValue(fields1459)) + p.write(p.formatStringValue(fields1469)) p.dedent() p.write(")") } @@ -4211,33 +4211,33 @@ func (p *PrettyPrinter) pretty_iceberg_locator_warehouse(msg string) interface{} } func (p *PrettyPrinter) pretty_iceberg_catalog_config(msg *pb.IcebergCatalogConfig) interface{} { - flat1468 := p.tryFlat(msg, func() { p.pretty_iceberg_catalog_config(msg) }) - if flat1468 != nil { - p.write(*flat1468) + flat1478 := p.tryFlat(msg, func() { p.pretty_iceberg_catalog_config(msg) }) + if flat1478 != nil { + p.write(*flat1478) return nil } else { _dollar_dollar := msg - _t1726 := p.deconstruct_iceberg_catalog_config_scope_optional(_dollar_dollar) - fields1461 := []interface{}{_dollar_dollar.GetCatalogUri(), _t1726, dictToPairs(_dollar_dollar.GetProperties()), dictToPairs(_dollar_dollar.GetAuthProperties())} - unwrapped_fields1462 := fields1461 + _t1746 := p.deconstruct_iceberg_catalog_config_scope_optional(_dollar_dollar) + fields1471 := []interface{}{_dollar_dollar.GetCatalogUri(), _t1746, dictToPairs(_dollar_dollar.GetProperties()), dictToPairs(_dollar_dollar.GetAuthProperties())} + unwrapped_fields1472 := fields1471 p.write("(") p.write("iceberg_catalog_config") p.indentSexp() p.newline() - field1463 := unwrapped_fields1462[0].(string) - p.pretty_iceberg_catalog_uri(field1463) - field1464 := unwrapped_fields1462[1].(*string) - if field1464 != nil { + field1473 := unwrapped_fields1472[0].(string) + p.pretty_iceberg_catalog_uri(field1473) + field1474 := unwrapped_fields1472[1].(*string) + if field1474 != nil { p.newline() - opt_val1465 := *field1464 - p.pretty_iceberg_catalog_config_scope(opt_val1465) + opt_val1475 := *field1474 + p.pretty_iceberg_catalog_config_scope(opt_val1475) } p.newline() - field1466 := unwrapped_fields1462[2].([][]interface{}) - p.pretty_iceberg_properties(field1466) + field1476 := unwrapped_fields1472[2].([][]interface{}) + p.pretty_iceberg_properties(field1476) p.newline() - field1467 := unwrapped_fields1462[3].([][]interface{}) - p.pretty_iceberg_auth_properties(field1467) + field1477 := unwrapped_fields1472[3].([][]interface{}) + p.pretty_iceberg_auth_properties(field1477) p.dedent() p.write(")") } @@ -4245,17 +4245,17 @@ func (p *PrettyPrinter) pretty_iceberg_catalog_config(msg *pb.IcebergCatalogConf } func (p *PrettyPrinter) pretty_iceberg_catalog_uri(msg string) interface{} { - flat1470 := p.tryFlat(msg, func() { p.pretty_iceberg_catalog_uri(msg) }) - if flat1470 != nil { - p.write(*flat1470) + flat1480 := p.tryFlat(msg, func() { p.pretty_iceberg_catalog_uri(msg) }) + if flat1480 != nil { + p.write(*flat1480) return nil } else { - fields1469 := msg + fields1479 := msg p.write("(") p.write("catalog_uri") p.indentSexp() p.newline() - p.write(p.formatStringValue(fields1469)) + p.write(p.formatStringValue(fields1479)) p.dedent() p.write(")") } @@ -4263,17 +4263,17 @@ func (p *PrettyPrinter) pretty_iceberg_catalog_uri(msg string) interface{} { } func (p *PrettyPrinter) pretty_iceberg_catalog_config_scope(msg string) interface{} { - flat1472 := p.tryFlat(msg, func() { p.pretty_iceberg_catalog_config_scope(msg) }) - if flat1472 != nil { - p.write(*flat1472) + flat1482 := p.tryFlat(msg, func() { p.pretty_iceberg_catalog_config_scope(msg) }) + if flat1482 != nil { + p.write(*flat1482) return nil } else { - fields1471 := msg + fields1481 := msg p.write("(") p.write("scope") p.indentSexp() p.newline() - p.write(p.formatStringValue(fields1471)) + p.write(p.formatStringValue(fields1481)) p.dedent() p.write(")") } @@ -4281,22 +4281,22 @@ func (p *PrettyPrinter) pretty_iceberg_catalog_config_scope(msg string) interfac } func (p *PrettyPrinter) pretty_iceberg_properties(msg [][]interface{}) interface{} { - flat1476 := p.tryFlat(msg, func() { p.pretty_iceberg_properties(msg) }) - if flat1476 != nil { - p.write(*flat1476) + flat1486 := p.tryFlat(msg, func() { p.pretty_iceberg_properties(msg) }) + if flat1486 != nil { + p.write(*flat1486) return nil } else { - fields1473 := msg + fields1483 := msg p.write("(") p.write("properties") p.indentSexp() - if !(len(fields1473) == 0) { + if !(len(fields1483) == 0) { p.newline() - for i1475, elem1474 := range fields1473 { - if (i1475 > 0) { + for i1485, elem1484 := range fields1483 { + if (i1485 > 0) { p.newline() } - p.pretty_iceberg_property_entry(elem1474) + p.pretty_iceberg_property_entry(elem1484) } } p.dedent() @@ -4306,23 +4306,23 @@ func (p *PrettyPrinter) pretty_iceberg_properties(msg [][]interface{}) interface } func (p *PrettyPrinter) pretty_iceberg_property_entry(msg []interface{}) interface{} { - flat1481 := p.tryFlat(msg, func() { p.pretty_iceberg_property_entry(msg) }) - if flat1481 != nil { - p.write(*flat1481) + flat1491 := p.tryFlat(msg, func() { p.pretty_iceberg_property_entry(msg) }) + if flat1491 != nil { + p.write(*flat1491) return nil } else { _dollar_dollar := msg - fields1477 := []interface{}{_dollar_dollar[0].(string), _dollar_dollar[1].(string)} - unwrapped_fields1478 := fields1477 + fields1487 := []interface{}{_dollar_dollar[0].(string), _dollar_dollar[1].(string)} + unwrapped_fields1488 := fields1487 p.write("(") p.write("prop") p.indentSexp() p.newline() - field1479 := unwrapped_fields1478[0].(string) - p.write(p.formatStringValue(field1479)) + field1489 := unwrapped_fields1488[0].(string) + p.write(p.formatStringValue(field1489)) p.newline() - field1480 := unwrapped_fields1478[1].(string) - p.write(p.formatStringValue(field1480)) + field1490 := unwrapped_fields1488[1].(string) + p.write(p.formatStringValue(field1490)) p.dedent() p.write(")") } @@ -4330,22 +4330,22 @@ func (p *PrettyPrinter) pretty_iceberg_property_entry(msg []interface{}) interfa } func (p *PrettyPrinter) pretty_iceberg_auth_properties(msg [][]interface{}) interface{} { - flat1485 := p.tryFlat(msg, func() { p.pretty_iceberg_auth_properties(msg) }) - if flat1485 != nil { - p.write(*flat1485) + flat1495 := p.tryFlat(msg, func() { p.pretty_iceberg_auth_properties(msg) }) + if flat1495 != nil { + p.write(*flat1495) return nil } else { - fields1482 := msg + fields1492 := msg p.write("(") p.write("auth_properties") p.indentSexp() - if !(len(fields1482) == 0) { + if !(len(fields1492) == 0) { p.newline() - for i1484, elem1483 := range fields1482 { - if (i1484 > 0) { + for i1494, elem1493 := range fields1492 { + if (i1494 > 0) { p.newline() } - p.pretty_iceberg_masked_property_entry(elem1483) + p.pretty_iceberg_masked_property_entry(elem1493) } } p.dedent() @@ -4355,24 +4355,24 @@ func (p *PrettyPrinter) pretty_iceberg_auth_properties(msg [][]interface{}) inte } func (p *PrettyPrinter) pretty_iceberg_masked_property_entry(msg []interface{}) interface{} { - flat1490 := p.tryFlat(msg, func() { p.pretty_iceberg_masked_property_entry(msg) }) - if flat1490 != nil { - p.write(*flat1490) + flat1500 := p.tryFlat(msg, func() { p.pretty_iceberg_masked_property_entry(msg) }) + if flat1500 != nil { + p.write(*flat1500) return nil } else { _dollar_dollar := msg - _t1727 := p.mask_secret_value(_dollar_dollar) - fields1486 := []interface{}{_dollar_dollar[0].(string), _t1727} - unwrapped_fields1487 := fields1486 + _t1747 := p.mask_secret_value(_dollar_dollar) + fields1496 := []interface{}{_dollar_dollar[0].(string), _t1747} + unwrapped_fields1497 := fields1496 p.write("(") p.write("prop") p.indentSexp() p.newline() - field1488 := unwrapped_fields1487[0].(string) - p.write(p.formatStringValue(field1488)) + field1498 := unwrapped_fields1497[0].(string) + p.write(p.formatStringValue(field1498)) p.newline() - field1489 := unwrapped_fields1487[1].(string) - p.write(p.formatStringValue(field1489)) + field1499 := unwrapped_fields1497[1].(string) + p.write(p.formatStringValue(field1499)) p.dedent() p.write(")") } @@ -4380,17 +4380,17 @@ func (p *PrettyPrinter) pretty_iceberg_masked_property_entry(msg []interface{}) } func (p *PrettyPrinter) pretty_iceberg_from_snapshot(msg string) interface{} { - flat1492 := p.tryFlat(msg, func() { p.pretty_iceberg_from_snapshot(msg) }) - if flat1492 != nil { - p.write(*flat1492) + flat1502 := p.tryFlat(msg, func() { p.pretty_iceberg_from_snapshot(msg) }) + if flat1502 != nil { + p.write(*flat1502) return nil } else { - fields1491 := msg + fields1501 := msg p.write("(") p.write("from_snapshot") p.indentSexp() p.newline() - p.write(p.formatStringValue(fields1491)) + p.write(p.formatStringValue(fields1501)) p.dedent() p.write(")") } @@ -4398,17 +4398,17 @@ func (p *PrettyPrinter) pretty_iceberg_from_snapshot(msg string) interface{} { } func (p *PrettyPrinter) pretty_iceberg_to_snapshot(msg string) interface{} { - flat1494 := p.tryFlat(msg, func() { p.pretty_iceberg_to_snapshot(msg) }) - if flat1494 != nil { - p.write(*flat1494) + flat1504 := p.tryFlat(msg, func() { p.pretty_iceberg_to_snapshot(msg) }) + if flat1504 != nil { + p.write(*flat1504) return nil } else { - fields1493 := msg + fields1503 := msg p.write("(") p.write("to_snapshot") p.indentSexp() p.newline() - p.write(p.formatStringValue(fields1493)) + p.write(p.formatStringValue(fields1503)) p.dedent() p.write(")") } @@ -4416,19 +4416,19 @@ func (p *PrettyPrinter) pretty_iceberg_to_snapshot(msg string) interface{} { } func (p *PrettyPrinter) pretty_undefine(msg *pb.Undefine) interface{} { - flat1497 := p.tryFlat(msg, func() { p.pretty_undefine(msg) }) - if flat1497 != nil { - p.write(*flat1497) + flat1507 := p.tryFlat(msg, func() { p.pretty_undefine(msg) }) + if flat1507 != nil { + p.write(*flat1507) return nil } else { _dollar_dollar := msg - fields1495 := _dollar_dollar.GetFragmentId() - unwrapped_fields1496 := fields1495 + fields1505 := _dollar_dollar.GetFragmentId() + unwrapped_fields1506 := fields1505 p.write("(") p.write("undefine") p.indentSexp() p.newline() - p.pretty_fragment_id(unwrapped_fields1496) + p.pretty_fragment_id(unwrapped_fields1506) p.dedent() p.write(")") } @@ -4436,24 +4436,24 @@ func (p *PrettyPrinter) pretty_undefine(msg *pb.Undefine) interface{} { } func (p *PrettyPrinter) pretty_context(msg *pb.Context) interface{} { - flat1502 := p.tryFlat(msg, func() { p.pretty_context(msg) }) - if flat1502 != nil { - p.write(*flat1502) + flat1512 := p.tryFlat(msg, func() { p.pretty_context(msg) }) + if flat1512 != nil { + p.write(*flat1512) return nil } else { _dollar_dollar := msg - fields1498 := _dollar_dollar.GetRelations() - unwrapped_fields1499 := fields1498 + fields1508 := _dollar_dollar.GetRelations() + unwrapped_fields1509 := fields1508 p.write("(") p.write("context") p.indentSexp() - if !(len(unwrapped_fields1499) == 0) { + if !(len(unwrapped_fields1509) == 0) { p.newline() - for i1501, elem1500 := range unwrapped_fields1499 { - if (i1501 > 0) { + for i1511, elem1510 := range unwrapped_fields1509 { + if (i1511 > 0) { p.newline() } - p.pretty_relation_id(elem1500) + p.pretty_relation_id(elem1510) } } p.dedent() @@ -4463,28 +4463,28 @@ func (p *PrettyPrinter) pretty_context(msg *pb.Context) interface{} { } func (p *PrettyPrinter) pretty_snapshot(msg *pb.Snapshot) interface{} { - flat1509 := p.tryFlat(msg, func() { p.pretty_snapshot(msg) }) - if flat1509 != nil { - p.write(*flat1509) + flat1519 := p.tryFlat(msg, func() { p.pretty_snapshot(msg) }) + if flat1519 != nil { + p.write(*flat1519) return nil } else { _dollar_dollar := msg - fields1503 := []interface{}{_dollar_dollar.GetPrefix(), _dollar_dollar.GetMappings()} - unwrapped_fields1504 := fields1503 + fields1513 := []interface{}{_dollar_dollar.GetPrefix(), _dollar_dollar.GetMappings()} + unwrapped_fields1514 := fields1513 p.write("(") p.write("snapshot") p.indentSexp() p.newline() - field1505 := unwrapped_fields1504[0].([]string) - p.pretty_edb_path(field1505) - field1506 := unwrapped_fields1504[1].([]*pb.SnapshotMapping) - if !(len(field1506) == 0) { + field1515 := unwrapped_fields1514[0].([]string) + p.pretty_edb_path(field1515) + field1516 := unwrapped_fields1514[1].([]*pb.SnapshotMapping) + if !(len(field1516) == 0) { p.newline() - for i1508, elem1507 := range field1506 { - if (i1508 > 0) { + for i1518, elem1517 := range field1516 { + if (i1518 > 0) { p.newline() } - p.pretty_snapshot_mapping(elem1507) + p.pretty_snapshot_mapping(elem1517) } } p.dedent() @@ -4494,40 +4494,40 @@ func (p *PrettyPrinter) pretty_snapshot(msg *pb.Snapshot) interface{} { } func (p *PrettyPrinter) pretty_snapshot_mapping(msg *pb.SnapshotMapping) interface{} { - flat1514 := p.tryFlat(msg, func() { p.pretty_snapshot_mapping(msg) }) - if flat1514 != nil { - p.write(*flat1514) + flat1524 := p.tryFlat(msg, func() { p.pretty_snapshot_mapping(msg) }) + if flat1524 != nil { + p.write(*flat1524) return nil } else { _dollar_dollar := msg - fields1510 := []interface{}{_dollar_dollar.GetDestinationPath(), _dollar_dollar.GetSourceRelation()} - unwrapped_fields1511 := fields1510 - field1512 := unwrapped_fields1511[0].([]string) - p.pretty_edb_path(field1512) + fields1520 := []interface{}{_dollar_dollar.GetDestinationPath(), _dollar_dollar.GetSourceRelation()} + unwrapped_fields1521 := fields1520 + field1522 := unwrapped_fields1521[0].([]string) + p.pretty_edb_path(field1522) p.write(" ") - field1513 := unwrapped_fields1511[1].(*pb.RelationId) - p.pretty_relation_id(field1513) + field1523 := unwrapped_fields1521[1].(*pb.RelationId) + p.pretty_relation_id(field1523) } return nil } func (p *PrettyPrinter) pretty_epoch_reads(msg []*pb.Read) interface{} { - flat1518 := p.tryFlat(msg, func() { p.pretty_epoch_reads(msg) }) - if flat1518 != nil { - p.write(*flat1518) + flat1528 := p.tryFlat(msg, func() { p.pretty_epoch_reads(msg) }) + if flat1528 != nil { + p.write(*flat1528) return nil } else { - fields1515 := msg + fields1525 := msg p.write("(") p.write("reads") p.indentSexp() - if !(len(fields1515) == 0) { + if !(len(fields1525) == 0) { p.newline() - for i1517, elem1516 := range fields1515 { - if (i1517 > 0) { + for i1527, elem1526 := range fields1525 { + if (i1527 > 0) { p.newline() } - p.pretty_read(elem1516) + p.pretty_read(elem1526) } } p.dedent() @@ -4537,62 +4537,73 @@ func (p *PrettyPrinter) pretty_epoch_reads(msg []*pb.Read) interface{} { } func (p *PrettyPrinter) pretty_read(msg *pb.Read) interface{} { - flat1529 := p.tryFlat(msg, func() { p.pretty_read(msg) }) - if flat1529 != nil { - p.write(*flat1529) + flat1541 := p.tryFlat(msg, func() { p.pretty_read(msg) }) + if flat1541 != nil { + p.write(*flat1541) return nil } else { _dollar_dollar := msg - var _t1728 *pb.Demand + var _t1748 *pb.Demand if hasProtoField(_dollar_dollar, "demand") { - _t1728 = _dollar_dollar.GetDemand() + _t1748 = _dollar_dollar.GetDemand() } - deconstruct_result1527 := _t1728 - if deconstruct_result1527 != nil { - unwrapped1528 := deconstruct_result1527 - p.pretty_demand(unwrapped1528) + deconstruct_result1539 := _t1748 + if deconstruct_result1539 != nil { + unwrapped1540 := deconstruct_result1539 + p.pretty_demand(unwrapped1540) } else { _dollar_dollar := msg - var _t1729 *pb.Output + var _t1749 *pb.Output if hasProtoField(_dollar_dollar, "output") { - _t1729 = _dollar_dollar.GetOutput() + _t1749 = _dollar_dollar.GetOutput() } - deconstruct_result1525 := _t1729 - if deconstruct_result1525 != nil { - unwrapped1526 := deconstruct_result1525 - p.pretty_output(unwrapped1526) + deconstruct_result1537 := _t1749 + if deconstruct_result1537 != nil { + unwrapped1538 := deconstruct_result1537 + p.pretty_output(unwrapped1538) } else { _dollar_dollar := msg - var _t1730 *pb.WhatIf + var _t1750 *pb.WhatIf if hasProtoField(_dollar_dollar, "what_if") { - _t1730 = _dollar_dollar.GetWhatIf() + _t1750 = _dollar_dollar.GetWhatIf() } - deconstruct_result1523 := _t1730 - if deconstruct_result1523 != nil { - unwrapped1524 := deconstruct_result1523 - p.pretty_what_if(unwrapped1524) + deconstruct_result1535 := _t1750 + if deconstruct_result1535 != nil { + unwrapped1536 := deconstruct_result1535 + p.pretty_what_if(unwrapped1536) } else { _dollar_dollar := msg - var _t1731 *pb.Abort + var _t1751 *pb.Abort if hasProtoField(_dollar_dollar, "abort") { - _t1731 = _dollar_dollar.GetAbort() + _t1751 = _dollar_dollar.GetAbort() } - deconstruct_result1521 := _t1731 - if deconstruct_result1521 != nil { - unwrapped1522 := deconstruct_result1521 - p.pretty_abort(unwrapped1522) + deconstruct_result1533 := _t1751 + if deconstruct_result1533 != nil { + unwrapped1534 := deconstruct_result1533 + p.pretty_abort(unwrapped1534) } else { _dollar_dollar := msg - var _t1732 *pb.Export + var _t1752 *pb.Export if hasProtoField(_dollar_dollar, "export") { - _t1732 = _dollar_dollar.GetExport() + _t1752 = _dollar_dollar.GetExport() } - deconstruct_result1519 := _t1732 - if deconstruct_result1519 != nil { - unwrapped1520 := deconstruct_result1519 - p.pretty_export(unwrapped1520) + deconstruct_result1531 := _t1752 + if deconstruct_result1531 != nil { + unwrapped1532 := deconstruct_result1531 + p.pretty_export(unwrapped1532) } else { - panic(ParseError{msg: "No matching rule for read"}) + _dollar_dollar := msg + var _t1753 *pb.ExportOutput + if hasProtoField(_dollar_dollar, "export_output") { + _t1753 = _dollar_dollar.GetExportOutput() + } + deconstruct_result1529 := _t1753 + if deconstruct_result1529 != nil { + unwrapped1530 := deconstruct_result1529 + p.pretty_export_output(unwrapped1530) + } else { + panic(ParseError{msg: "No matching rule for read"}) + } } } } @@ -4603,19 +4614,19 @@ func (p *PrettyPrinter) pretty_read(msg *pb.Read) interface{} { } func (p *PrettyPrinter) pretty_demand(msg *pb.Demand) interface{} { - flat1532 := p.tryFlat(msg, func() { p.pretty_demand(msg) }) - if flat1532 != nil { - p.write(*flat1532) + flat1544 := p.tryFlat(msg, func() { p.pretty_demand(msg) }) + if flat1544 != nil { + p.write(*flat1544) return nil } else { _dollar_dollar := msg - fields1530 := _dollar_dollar.GetRelationId() - unwrapped_fields1531 := fields1530 + fields1542 := _dollar_dollar.GetRelationId() + unwrapped_fields1543 := fields1542 p.write("(") p.write("demand") p.indentSexp() p.newline() - p.pretty_relation_id(unwrapped_fields1531) + p.pretty_relation_id(unwrapped_fields1543) p.dedent() p.write(")") } @@ -4623,23 +4634,23 @@ func (p *PrettyPrinter) pretty_demand(msg *pb.Demand) interface{} { } func (p *PrettyPrinter) pretty_output(msg *pb.Output) interface{} { - flat1537 := p.tryFlat(msg, func() { p.pretty_output(msg) }) - if flat1537 != nil { - p.write(*flat1537) + flat1549 := p.tryFlat(msg, func() { p.pretty_output(msg) }) + if flat1549 != nil { + p.write(*flat1549) return nil } else { _dollar_dollar := msg - fields1533 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetRelationId()} - unwrapped_fields1534 := fields1533 + fields1545 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetRelationId()} + unwrapped_fields1546 := fields1545 p.write("(") p.write("output") p.indentSexp() p.newline() - field1535 := unwrapped_fields1534[0].(string) - p.pretty_name(field1535) + field1547 := unwrapped_fields1546[0].(string) + p.pretty_name(field1547) p.newline() - field1536 := unwrapped_fields1534[1].(*pb.RelationId) - p.pretty_relation_id(field1536) + field1548 := unwrapped_fields1546[1].(*pb.RelationId) + p.pretty_relation_id(field1548) p.dedent() p.write(")") } @@ -4647,23 +4658,23 @@ func (p *PrettyPrinter) pretty_output(msg *pb.Output) interface{} { } func (p *PrettyPrinter) pretty_what_if(msg *pb.WhatIf) interface{} { - flat1542 := p.tryFlat(msg, func() { p.pretty_what_if(msg) }) - if flat1542 != nil { - p.write(*flat1542) + flat1554 := p.tryFlat(msg, func() { p.pretty_what_if(msg) }) + if flat1554 != nil { + p.write(*flat1554) return nil } else { _dollar_dollar := msg - fields1538 := []interface{}{_dollar_dollar.GetBranch(), _dollar_dollar.GetEpoch()} - unwrapped_fields1539 := fields1538 + fields1550 := []interface{}{_dollar_dollar.GetBranch(), _dollar_dollar.GetEpoch()} + unwrapped_fields1551 := fields1550 p.write("(") p.write("what_if") p.indentSexp() p.newline() - field1540 := unwrapped_fields1539[0].(string) - p.pretty_name(field1540) + field1552 := unwrapped_fields1551[0].(string) + p.pretty_name(field1552) p.newline() - field1541 := unwrapped_fields1539[1].(*pb.Epoch) - p.pretty_epoch(field1541) + field1553 := unwrapped_fields1551[1].(*pb.Epoch) + p.pretty_epoch(field1553) p.dedent() p.write(")") } @@ -4671,30 +4682,30 @@ func (p *PrettyPrinter) pretty_what_if(msg *pb.WhatIf) interface{} { } func (p *PrettyPrinter) pretty_abort(msg *pb.Abort) interface{} { - flat1548 := p.tryFlat(msg, func() { p.pretty_abort(msg) }) - if flat1548 != nil { - p.write(*flat1548) + flat1560 := p.tryFlat(msg, func() { p.pretty_abort(msg) }) + if flat1560 != nil { + p.write(*flat1560) return nil } else { _dollar_dollar := msg - var _t1733 *string + var _t1754 *string if _dollar_dollar.GetName() != "abort" { - _t1733 = ptr(_dollar_dollar.GetName()) + _t1754 = ptr(_dollar_dollar.GetName()) } - fields1543 := []interface{}{_t1733, _dollar_dollar.GetRelationId()} - unwrapped_fields1544 := fields1543 + fields1555 := []interface{}{_t1754, _dollar_dollar.GetRelationId()} + unwrapped_fields1556 := fields1555 p.write("(") p.write("abort") p.indentSexp() - field1545 := unwrapped_fields1544[0].(*string) - if field1545 != nil { + field1557 := unwrapped_fields1556[0].(*string) + if field1557 != nil { p.newline() - opt_val1546 := *field1545 - p.pretty_name(opt_val1546) + opt_val1558 := *field1557 + p.pretty_name(opt_val1558) } p.newline() - field1547 := unwrapped_fields1544[1].(*pb.RelationId) - p.pretty_relation_id(field1547) + field1559 := unwrapped_fields1556[1].(*pb.RelationId) + p.pretty_relation_id(field1559) p.dedent() p.write(")") } @@ -4702,40 +4713,40 @@ func (p *PrettyPrinter) pretty_abort(msg *pb.Abort) interface{} { } func (p *PrettyPrinter) pretty_export(msg *pb.Export) interface{} { - flat1553 := p.tryFlat(msg, func() { p.pretty_export(msg) }) - if flat1553 != nil { - p.write(*flat1553) + flat1565 := p.tryFlat(msg, func() { p.pretty_export(msg) }) + if flat1565 != nil { + p.write(*flat1565) return nil } else { _dollar_dollar := msg - var _t1734 *pb.ExportCSVConfig + var _t1755 *pb.ExportCSVConfig if hasProtoField(_dollar_dollar, "csv_config") { - _t1734 = _dollar_dollar.GetCsvConfig() + _t1755 = _dollar_dollar.GetCsvConfig() } - deconstruct_result1551 := _t1734 - if deconstruct_result1551 != nil { - unwrapped1552 := deconstruct_result1551 + deconstruct_result1563 := _t1755 + if deconstruct_result1563 != nil { + unwrapped1564 := deconstruct_result1563 p.write("(") p.write("export") p.indentSexp() p.newline() - p.pretty_export_csv_config(unwrapped1552) + p.pretty_export_csv_config(unwrapped1564) p.dedent() p.write(")") } else { _dollar_dollar := msg - var _t1735 *pb.ExportIcebergConfig + var _t1756 *pb.ExportIcebergConfig if hasProtoField(_dollar_dollar, "iceberg_config") { - _t1735 = _dollar_dollar.GetIcebergConfig() + _t1756 = _dollar_dollar.GetIcebergConfig() } - deconstruct_result1549 := _t1735 - if deconstruct_result1549 != nil { - unwrapped1550 := deconstruct_result1549 + deconstruct_result1561 := _t1756 + if deconstruct_result1561 != nil { + unwrapped1562 := deconstruct_result1561 p.write("(") p.write("export_iceberg") p.indentSexp() p.newline() - p.pretty_export_iceberg_config(unwrapped1550) + p.pretty_export_iceberg_config(unwrapped1562) p.dedent() p.write(")") } else { @@ -4747,55 +4758,55 @@ func (p *PrettyPrinter) pretty_export(msg *pb.Export) interface{} { } func (p *PrettyPrinter) pretty_export_csv_config(msg *pb.ExportCSVConfig) interface{} { - flat1564 := p.tryFlat(msg, func() { p.pretty_export_csv_config(msg) }) - if flat1564 != nil { - p.write(*flat1564) + flat1576 := p.tryFlat(msg, func() { p.pretty_export_csv_config(msg) }) + if flat1576 != nil { + p.write(*flat1576) return nil } else { _dollar_dollar := msg - var _t1736 []interface{} + var _t1757 []interface{} if int64(len(_dollar_dollar.GetDataColumns())) == 0 { - _t1736 = []interface{}{_dollar_dollar.GetPath(), _dollar_dollar.GetCsvSource(), _dollar_dollar.GetCsvConfig()} + _t1757 = []interface{}{_dollar_dollar.GetPath(), _dollar_dollar.GetCsvSource(), _dollar_dollar.GetCsvConfig()} } - deconstruct_result1559 := _t1736 - if deconstruct_result1559 != nil { - unwrapped1560 := deconstruct_result1559 + deconstruct_result1571 := _t1757 + if deconstruct_result1571 != nil { + unwrapped1572 := deconstruct_result1571 p.write("(") p.write("export_csv_config_v2") p.indentSexp() p.newline() - field1561 := unwrapped1560[0].(string) - p.pretty_export_csv_path(field1561) + field1573 := unwrapped1572[0].(string) + p.pretty_export_csv_path(field1573) p.newline() - field1562 := unwrapped1560[1].(*pb.ExportCSVSource) - p.pretty_export_csv_source(field1562) + field1574 := unwrapped1572[1].(*pb.ExportCSVSource) + p.pretty_export_csv_source(field1574) p.newline() - field1563 := unwrapped1560[2].(*pb.CSVConfig) - p.pretty_csv_config(field1563) + field1575 := unwrapped1572[2].(*pb.CSVConfig) + p.pretty_csv_config(field1575) p.dedent() p.write(")") } else { _dollar_dollar := msg - var _t1737 []interface{} + var _t1758 []interface{} if int64(len(_dollar_dollar.GetDataColumns())) != 0 { - _t1738 := p.deconstruct_export_csv_config(_dollar_dollar) - _t1737 = []interface{}{_dollar_dollar.GetPath(), _dollar_dollar.GetDataColumns(), _t1738} + _t1759 := p.deconstruct_export_csv_config(_dollar_dollar) + _t1758 = []interface{}{_dollar_dollar.GetPath(), _dollar_dollar.GetDataColumns(), _t1759} } - deconstruct_result1554 := _t1737 - if deconstruct_result1554 != nil { - unwrapped1555 := deconstruct_result1554 + deconstruct_result1566 := _t1758 + if deconstruct_result1566 != nil { + unwrapped1567 := deconstruct_result1566 p.write("(") p.write("export_csv_config") p.indentSexp() p.newline() - field1556 := unwrapped1555[0].(string) - p.pretty_export_csv_path(field1556) + field1568 := unwrapped1567[0].(string) + p.pretty_export_csv_path(field1568) p.newline() - field1557 := unwrapped1555[1].([]*pb.ExportCSVColumn) - p.pretty_export_csv_columns_list(field1557) + field1569 := unwrapped1567[1].([]*pb.ExportCSVColumn) + p.pretty_export_csv_columns_list(field1569) p.newline() - field1558 := unwrapped1555[2].([][]interface{}) - p.pretty_config_dict(field1558) + field1570 := unwrapped1567[2].([][]interface{}) + p.pretty_config_dict(field1570) p.dedent() p.write(")") } else { @@ -4807,17 +4818,17 @@ func (p *PrettyPrinter) pretty_export_csv_config(msg *pb.ExportCSVConfig) interf } func (p *PrettyPrinter) pretty_export_csv_path(msg string) interface{} { - flat1566 := p.tryFlat(msg, func() { p.pretty_export_csv_path(msg) }) - if flat1566 != nil { - p.write(*flat1566) + flat1578 := p.tryFlat(msg, func() { p.pretty_export_csv_path(msg) }) + if flat1578 != nil { + p.write(*flat1578) return nil } else { - fields1565 := msg + fields1577 := msg p.write("(") p.write("path") p.indentSexp() p.newline() - p.write(p.formatStringValue(fields1565)) + p.write(p.formatStringValue(fields1577)) p.dedent() p.write(")") } @@ -4825,47 +4836,47 @@ func (p *PrettyPrinter) pretty_export_csv_path(msg string) interface{} { } func (p *PrettyPrinter) pretty_export_csv_source(msg *pb.ExportCSVSource) interface{} { - flat1573 := p.tryFlat(msg, func() { p.pretty_export_csv_source(msg) }) - if flat1573 != nil { - p.write(*flat1573) + flat1585 := p.tryFlat(msg, func() { p.pretty_export_csv_source(msg) }) + if flat1585 != nil { + p.write(*flat1585) return nil } else { _dollar_dollar := msg - var _t1739 []*pb.ExportCSVColumn + var _t1760 []*pb.ExportCSVColumn if hasProtoField(_dollar_dollar, "gnf_columns") { - _t1739 = _dollar_dollar.GetGnfColumns().GetColumns() + _t1760 = _dollar_dollar.GetGnfColumns().GetColumns() } - deconstruct_result1569 := _t1739 - if deconstruct_result1569 != nil { - unwrapped1570 := deconstruct_result1569 + deconstruct_result1581 := _t1760 + if deconstruct_result1581 != nil { + unwrapped1582 := deconstruct_result1581 p.write("(") p.write("gnf_columns") p.indentSexp() - if !(len(unwrapped1570) == 0) { + if !(len(unwrapped1582) == 0) { p.newline() - for i1572, elem1571 := range unwrapped1570 { - if (i1572 > 0) { + for i1584, elem1583 := range unwrapped1582 { + if (i1584 > 0) { p.newline() } - p.pretty_export_csv_column(elem1571) + p.pretty_export_csv_column(elem1583) } } p.dedent() p.write(")") } else { _dollar_dollar := msg - var _t1740 *pb.RelationId + var _t1761 *pb.RelationId if hasProtoField(_dollar_dollar, "table_def") { - _t1740 = _dollar_dollar.GetTableDef() + _t1761 = _dollar_dollar.GetTableDef() } - deconstruct_result1567 := _t1740 - if deconstruct_result1567 != nil { - unwrapped1568 := deconstruct_result1567 + deconstruct_result1579 := _t1761 + if deconstruct_result1579 != nil { + unwrapped1580 := deconstruct_result1579 p.write("(") p.write("table_def") p.indentSexp() p.newline() - p.pretty_relation_id(unwrapped1568) + p.pretty_relation_id(unwrapped1580) p.dedent() p.write(")") } else { @@ -4877,23 +4888,23 @@ func (p *PrettyPrinter) pretty_export_csv_source(msg *pb.ExportCSVSource) interf } func (p *PrettyPrinter) pretty_export_csv_column(msg *pb.ExportCSVColumn) interface{} { - flat1578 := p.tryFlat(msg, func() { p.pretty_export_csv_column(msg) }) - if flat1578 != nil { - p.write(*flat1578) + flat1590 := p.tryFlat(msg, func() { p.pretty_export_csv_column(msg) }) + if flat1590 != nil { + p.write(*flat1590) return nil } else { _dollar_dollar := msg - fields1574 := []interface{}{_dollar_dollar.GetColumnName(), _dollar_dollar.GetColumnData()} - unwrapped_fields1575 := fields1574 + fields1586 := []interface{}{_dollar_dollar.GetColumnName(), _dollar_dollar.GetColumnData()} + unwrapped_fields1587 := fields1586 p.write("(") p.write("column") p.indentSexp() p.newline() - field1576 := unwrapped_fields1575[0].(string) - p.write(p.formatStringValue(field1576)) + field1588 := unwrapped_fields1587[0].(string) + p.write(p.formatStringValue(field1588)) p.newline() - field1577 := unwrapped_fields1575[1].(*pb.RelationId) - p.pretty_relation_id(field1577) + field1589 := unwrapped_fields1587[1].(*pb.RelationId) + p.pretty_relation_id(field1589) p.dedent() p.write(")") } @@ -4901,22 +4912,22 @@ func (p *PrettyPrinter) pretty_export_csv_column(msg *pb.ExportCSVColumn) interf } func (p *PrettyPrinter) pretty_export_csv_columns_list(msg []*pb.ExportCSVColumn) interface{} { - flat1582 := p.tryFlat(msg, func() { p.pretty_export_csv_columns_list(msg) }) - if flat1582 != nil { - p.write(*flat1582) + flat1594 := p.tryFlat(msg, func() { p.pretty_export_csv_columns_list(msg) }) + if flat1594 != nil { + p.write(*flat1594) return nil } else { - fields1579 := msg + fields1591 := msg p.write("(") p.write("columns") p.indentSexp() - if !(len(fields1579) == 0) { + if !(len(fields1591) == 0) { p.newline() - for i1581, elem1580 := range fields1579 { - if (i1581 > 0) { + for i1593, elem1592 := range fields1591 { + if (i1593 > 0) { p.newline() } - p.pretty_export_csv_column(elem1580) + p.pretty_export_csv_column(elem1592) } } p.dedent() @@ -4926,35 +4937,35 @@ func (p *PrettyPrinter) pretty_export_csv_columns_list(msg []*pb.ExportCSVColumn } func (p *PrettyPrinter) pretty_export_iceberg_config(msg *pb.ExportIcebergConfig) interface{} { - flat1591 := p.tryFlat(msg, func() { p.pretty_export_iceberg_config(msg) }) - if flat1591 != nil { - p.write(*flat1591) + flat1603 := p.tryFlat(msg, func() { p.pretty_export_iceberg_config(msg) }) + if flat1603 != nil { + p.write(*flat1603) return nil } else { _dollar_dollar := msg - _t1741 := p.deconstruct_export_iceberg_config_optional(_dollar_dollar) - fields1583 := []interface{}{_dollar_dollar.GetLocator(), _dollar_dollar.GetConfig(), _dollar_dollar.GetTableDef(), dictToPairs(_dollar_dollar.GetTableProperties()), _t1741} - unwrapped_fields1584 := fields1583 + _t1762 := p.deconstruct_export_iceberg_config_optional(_dollar_dollar) + fields1595 := []interface{}{_dollar_dollar.GetLocator(), _dollar_dollar.GetConfig(), _dollar_dollar.GetTableDef(), dictToPairs(_dollar_dollar.GetTableProperties()), _t1762} + unwrapped_fields1596 := fields1595 p.write("(") p.write("export_iceberg_config") p.indentSexp() p.newline() - field1585 := unwrapped_fields1584[0].(*pb.IcebergLocator) - p.pretty_iceberg_locator(field1585) + field1597 := unwrapped_fields1596[0].(*pb.IcebergLocator) + p.pretty_iceberg_locator(field1597) p.newline() - field1586 := unwrapped_fields1584[1].(*pb.IcebergCatalogConfig) - p.pretty_iceberg_catalog_config(field1586) + field1598 := unwrapped_fields1596[1].(*pb.IcebergCatalogConfig) + p.pretty_iceberg_catalog_config(field1598) p.newline() - field1587 := unwrapped_fields1584[2].(*pb.RelationId) - p.pretty_export_iceberg_table_def(field1587) + field1599 := unwrapped_fields1596[2].(*pb.RelationId) + p.pretty_export_iceberg_table_def(field1599) p.newline() - field1588 := unwrapped_fields1584[3].([][]interface{}) - p.pretty_iceberg_table_properties(field1588) - field1589 := unwrapped_fields1584[4].([][]interface{}) - if field1589 != nil { + field1600 := unwrapped_fields1596[3].([][]interface{}) + p.pretty_iceberg_table_properties(field1600) + field1601 := unwrapped_fields1596[4].([][]interface{}) + if field1601 != nil { p.newline() - opt_val1590 := field1589 - p.pretty_config_dict(opt_val1590) + opt_val1602 := field1601 + p.pretty_config_dict(opt_val1602) } p.dedent() p.write(")") @@ -4963,17 +4974,17 @@ func (p *PrettyPrinter) pretty_export_iceberg_config(msg *pb.ExportIcebergConfig } func (p *PrettyPrinter) pretty_export_iceberg_table_def(msg *pb.RelationId) interface{} { - flat1593 := p.tryFlat(msg, func() { p.pretty_export_iceberg_table_def(msg) }) - if flat1593 != nil { - p.write(*flat1593) + flat1605 := p.tryFlat(msg, func() { p.pretty_export_iceberg_table_def(msg) }) + if flat1605 != nil { + p.write(*flat1605) return nil } else { - fields1592 := msg + fields1604 := msg p.write("(") p.write("table_def") p.indentSexp() p.newline() - p.pretty_relation_id(fields1592) + p.pretty_relation_id(fields1604) p.dedent() p.write(")") } @@ -4981,22 +4992,22 @@ func (p *PrettyPrinter) pretty_export_iceberg_table_def(msg *pb.RelationId) inte } func (p *PrettyPrinter) pretty_iceberg_table_properties(msg [][]interface{}) interface{} { - flat1597 := p.tryFlat(msg, func() { p.pretty_iceberg_table_properties(msg) }) - if flat1597 != nil { - p.write(*flat1597) + flat1609 := p.tryFlat(msg, func() { p.pretty_iceberg_table_properties(msg) }) + if flat1609 != nil { + p.write(*flat1609) return nil } else { - fields1594 := msg + fields1606 := msg p.write("(") p.write("table_properties") p.indentSexp() - if !(len(fields1594) == 0) { + if !(len(fields1606) == 0) { p.newline() - for i1596, elem1595 := range fields1594 { - if (i1596 > 0) { + for i1608, elem1607 := range fields1606 { + if (i1608 > 0) { p.newline() } - p.pretty_iceberg_property_entry(elem1595) + p.pretty_iceberg_property_entry(elem1607) } } p.dedent() @@ -5005,6 +5016,54 @@ func (p *PrettyPrinter) pretty_iceberg_table_properties(msg [][]interface{}) int return nil } +func (p *PrettyPrinter) pretty_export_output(msg *pb.ExportOutput) interface{} { + flat1612 := p.tryFlat(msg, func() { p.pretty_export_output(msg) }) + if flat1612 != nil { + p.write(*flat1612) + return nil + } else { + _dollar_dollar := msg + var _t1763 *pb.ExportCSVOutput + if hasProtoField(_dollar_dollar, "csv") { + _t1763 = _dollar_dollar.GetCsv() + } + fields1610 := _t1763 + unwrapped_fields1611 := fields1610 + p.write("(") + p.write("output_export") + p.indentSexp() + p.newline() + p.pretty_export_csv_output(unwrapped_fields1611) + p.dedent() + p.write(")") + } + return nil +} + +func (p *PrettyPrinter) pretty_export_csv_output(msg *pb.ExportCSVOutput) interface{} { + flat1617 := p.tryFlat(msg, func() { p.pretty_export_csv_output(msg) }) + if flat1617 != nil { + p.write(*flat1617) + return nil + } else { + _dollar_dollar := msg + fields1613 := []interface{}{_dollar_dollar.GetCsvSource(), _dollar_dollar.GetCsvConfig()} + unwrapped_fields1614 := fields1613 + p.write("(") + p.write("csv") + p.indentSexp() + p.newline() + field1615 := unwrapped_fields1614[0].(*pb.ExportCSVSource) + p.pretty_export_csv_source(field1615) + p.newline() + field1616 := unwrapped_fields1614[1].(*pb.CSVConfig) + p.pretty_csv_config(field1616) + p.dedent() + p.write(")") + } + return nil +} + // --- Auto-generated printers for uncovered proto types --- @@ -5014,8 +5073,8 @@ func (p *PrettyPrinter) pretty_debug_info(msg *pb.DebugInfo) interface{} { for _idx, _rid := range msg.GetIds() { p.newline() p.write("(") - _t1793 := &pb.UInt128Value{Low: _rid.GetIdLow(), High: _rid.GetIdHigh()} - p.pprintDispatch(_t1793) + _t1815 := &pb.UInt128Value{Low: _rid.GetIdLow(), High: _rid.GetIdHigh()} + p.pprintDispatch(_t1815) p.write(" ") p.write(p.formatStringValue(msg.GetOrigNames()[_idx])) p.write(")") @@ -5407,6 +5466,10 @@ func (p *PrettyPrinter) pprintDispatch(msg interface{}) { p.pretty_export_csv_columns_list(m) case *pb.ExportIcebergConfig: p.pretty_export_iceberg_config(m) + case *pb.ExportOutput: + p.pretty_export_output(m) + case *pb.ExportCSVOutput: + p.pretty_export_csv_output(m) case *pb.DebugInfo: p.pretty_debug_info(m) case *pb.BeTreeConfig: 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..5a3dc774 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 @@ -7,8 +7,8 @@ using ProtoBuf.EnumX: @enumx export ExportIcebergConfig, ExportCSVColumn, Demand, Undefine, MaintenanceLevel, Define export Context, Sync, SnapshotMapping, Abort, Output, ExportCSVColumns, IVMConfig, Snapshot -export ExportCSVSource, Configure, Write, ExportCSVConfig, Export, Epoch, Read, Transaction -export WhatIf +export ExportCSVSource, Configure, Write, ExportCSVOutput, ExportCSVConfig, ExportOutput +export Export, Epoch, Read, Transaction, WhatIf abstract type var"##Abstract#Transaction" end abstract type var"##Abstract#Epoch" end abstract type var"##Abstract#Read" end @@ -629,6 +629,43 @@ function PB._encoded_size(x::Write) return encoded_size end +struct ExportCSVOutput + csv_source::Union{Nothing,ExportCSVSource} + csv_config::Union{Nothing,CSVConfig} +end +ExportCSVOutput(;csv_source = nothing, csv_config = nothing) = ExportCSVOutput(csv_source, csv_config) +PB.default_values(::Type{ExportCSVOutput}) = (;csv_source = nothing, csv_config = nothing) +PB.field_numbers(::Type{ExportCSVOutput}) = (;csv_source = 1, csv_config = 2) + +function PB.decode(d::PB.AbstractProtoDecoder, ::Type{<:ExportCSVOutput}, _endpos::Int=0, _group::Bool=false) + csv_source = Ref{Union{Nothing,ExportCSVSource}}(nothing) + csv_config = Ref{Union{Nothing,CSVConfig}}(nothing) + while !PB.message_done(d, _endpos, _group) + field_number, wire_type = PB.decode_tag(d) + if field_number == 1 + PB.decode!(d, csv_source) + elseif field_number == 2 + PB.decode!(d, csv_config) + else + Base.skip(d, wire_type) + end + end + return ExportCSVOutput(csv_source[], csv_config[]) +end + +function PB.encode(e::PB.AbstractProtoEncoder, x::ExportCSVOutput) + initpos = position(e.io) + !isnothing(x.csv_source) && PB.encode(e, 1, x.csv_source) + !isnothing(x.csv_config) && PB.encode(e, 2, x.csv_config) + return position(e.io) - initpos +end +function PB._encoded_size(x::ExportCSVOutput) + encoded_size = 0 + !isnothing(x.csv_source) && (encoded_size += PB._encoded_size(x.csv_source, 1)) + !isnothing(x.csv_config) && (encoded_size += PB._encoded_size(x.csv_config, 2)) + return encoded_size +end + struct ExportCSVConfig path::String csv_source::Union{Nothing,ExportCSVSource} @@ -720,6 +757,46 @@ function PB._encoded_size(x::ExportCSVConfig) return encoded_size end +struct ExportOutput + export_output::Union{Nothing,OneOf{ExportCSVOutput}} +end +ExportOutput(;export_output = nothing) = ExportOutput(export_output) +PB.oneof_field_types(::Type{ExportOutput}) = (; + export_output = (;csv=ExportCSVOutput), +) +PB.default_values(::Type{ExportOutput}) = (;csv = nothing) +PB.field_numbers(::Type{ExportOutput}) = (;csv = 1) + +function PB.decode(d::PB.AbstractProtoDecoder, ::Type{<:ExportOutput}, _endpos::Int=0, _group::Bool=false) + export_output = nothing + while !PB.message_done(d, _endpos, _group) + field_number, wire_type = PB.decode_tag(d) + if field_number == 1 + export_output = OneOf(:csv, PB.decode(d, Ref{ExportCSVOutput})) + else + Base.skip(d, wire_type) + end + end + return ExportOutput(export_output) +end + +function PB.encode(e::PB.AbstractProtoEncoder, x::ExportOutput) + initpos = position(e.io) + if isnothing(x.export_output); + elseif x.export_output.name === :csv + PB.encode(e, 1, x.export_output[]::ExportCSVOutput) + end + return position(e.io) - initpos +end +function PB._encoded_size(x::ExportOutput) + encoded_size = 0 + if isnothing(x.export_output); + elseif x.export_output.name === :csv + encoded_size += PB._encoded_size(x.export_output[]::ExportCSVOutput, 1) + end + return encoded_size +end + struct Export export_config::Union{Nothing,OneOf{<:Union{ExportCSVConfig,ExportIcebergConfig}}} end @@ -773,7 +850,7 @@ struct var"##Stub#Epoch"{T1<:var"##Abstract#Read"} <: var"##Abstract#Epoch" end struct var"##Stub#Read"{T1<:var"##Abstract#WhatIf"} <: var"##Abstract#Read" - read_type::Union{Nothing,OneOf{<:Union{Demand,Output,T1,Abort,Export}}} + read_type::Union{Nothing,OneOf{<:Union{Demand,Output,T1,Abort,Export,ExportOutput}}} end struct var"##Stub#Transaction"{T1<:var"##Abstract#WhatIf"} <: var"##Abstract#Transaction" @@ -824,10 +901,10 @@ end const Read = var"##Stub#Read"{var"##Stub#WhatIf"} Read(;read_type = nothing) = Read(read_type) PB.oneof_field_types(::Type{Read}) = (; - read_type = (;demand=Demand, output=Output, what_if=WhatIf, abort=Abort, var"#export"=Export), + read_type = (;demand=Demand, output=Output, what_if=WhatIf, abort=Abort, var"#export"=Export, export_output=ExportOutput), ) -PB.default_values(::Type{Read}) = (;demand = nothing, output = nothing, what_if = nothing, abort = nothing, var"#export" = nothing) -PB.field_numbers(::Type{Read}) = (;demand = 1, output = 2, what_if = 3, abort = 4, var"#export" = 5) +PB.default_values(::Type{Read}) = (;demand = nothing, output = nothing, what_if = nothing, abort = nothing, var"#export" = nothing, export_output = nothing) +PB.field_numbers(::Type{Read}) = (;demand = 1, output = 2, what_if = 3, abort = 4, var"#export" = 5, export_output = 6) function PB.decode(d::PB.AbstractProtoDecoder, ::Type{<:Read}, _endpos::Int=0, _group::Bool=false) read_type = nothing @@ -843,6 +920,8 @@ function PB.decode(d::PB.AbstractProtoDecoder, ::Type{<:Read}, _endpos::Int=0, _ read_type = OneOf(:abort, PB.decode(d, Ref{Abort})) elseif field_number == 5 read_type = OneOf(:var"#export", PB.decode(d, Ref{Export})) + elseif field_number == 6 + read_type = OneOf(:export_output, PB.decode(d, Ref{ExportOutput})) else Base.skip(d, wire_type) end @@ -863,6 +942,8 @@ function PB.encode(e::PB.AbstractProtoEncoder, x::Read) PB.encode(e, 4, x.read_type[]::Abort) elseif x.read_type.name === :var"#export" PB.encode(e, 5, x.read_type[]::Export) + elseif x.read_type.name === :export_output + PB.encode(e, 6, x.read_type[]::ExportOutput) end return position(e.io) - initpos end @@ -879,6 +960,8 @@ function PB._encoded_size(x::Read) encoded_size += PB._encoded_size(x.read_type[]::Abort, 4) elseif x.read_type.name === :var"#export" encoded_size += PB._encoded_size(x.read_type[]::Export, 5) + elseif x.read_type.name === :export_output + encoded_size += PB._encoded_size(x.read_type[]::ExportOutput, 6) end return encoded_size end diff --git a/sdks/julia/LogicalQueryProtocol.jl/src/parser.jl b/sdks/julia/LogicalQueryProtocol.jl/src/parser.jl index 3a05e7c1..360e6aa0 100644 --- a/sdks/julia/LogicalQueryProtocol.jl/src/parser.jl +++ b/sdks/julia/LogicalQueryProtocol.jl/src/parser.jl @@ -372,7 +372,7 @@ function _extract_value_int32(parser::ParserState, value::Union{Nothing, Proto.V if (!isnothing(value) && _has_proto_field(value, Symbol("int32_value"))) return _get_oneof_field(value, :int32_value) else - _t2088 = nothing + _t2113 = nothing end return Int32(default) end @@ -381,7 +381,7 @@ function _extract_value_int64(parser::ParserState, value::Union{Nothing, Proto.V if (!isnothing(value) && _has_proto_field(value, Symbol("int_value"))) return _get_oneof_field(value, :int_value) else - _t2089 = nothing + _t2114 = nothing end return default end @@ -390,7 +390,7 @@ function _extract_value_string(parser::ParserState, value::Union{Nothing, Proto. if (!isnothing(value) && _has_proto_field(value, Symbol("string_value"))) return _get_oneof_field(value, :string_value) else - _t2090 = nothing + _t2115 = nothing end return default end @@ -399,7 +399,7 @@ function _extract_value_boolean(parser::ParserState, value::Union{Nothing, Proto if (!isnothing(value) && _has_proto_field(value, Symbol("boolean_value"))) return _get_oneof_field(value, :boolean_value) else - _t2091 = nothing + _t2116 = nothing end return default end @@ -408,7 +408,7 @@ function _extract_value_string_list(parser::ParserState, value::Union{Nothing, P if (!isnothing(value) && _has_proto_field(value, Symbol("string_value"))) return String[_get_oneof_field(value, :string_value)] else - _t2092 = nothing + _t2117 = nothing end return default end @@ -417,7 +417,7 @@ function _try_extract_value_int64(parser::ParserState, value::Union{Nothing, Pro if (!isnothing(value) && _has_proto_field(value, Symbol("int_value"))) return _get_oneof_field(value, :int_value) else - _t2093 = nothing + _t2118 = nothing end return nothing end @@ -426,7 +426,7 @@ function _try_extract_value_float64(parser::ParserState, value::Union{Nothing, P if (!isnothing(value) && _has_proto_field(value, Symbol("float_value"))) return _get_oneof_field(value, :float_value) else - _t2094 = nothing + _t2119 = nothing end return nothing end @@ -435,7 +435,7 @@ function _try_extract_value_bytes(parser::ParserState, value::Union{Nothing, Pro if (!isnothing(value) && _has_proto_field(value, Symbol("string_value"))) return Vector{UInt8}(_get_oneof_field(value, :string_value)) else - _t2095 = nothing + _t2120 = nothing end return nothing end @@ -444,90 +444,90 @@ function _try_extract_value_uint128(parser::ParserState, value::Union{Nothing, P if (!isnothing(value) && _has_proto_field(value, Symbol("uint128_value"))) return _get_oneof_field(value, :uint128_value) else - _t2096 = nothing + _t2121 = nothing end return nothing end function construct_csv_config(parser::ParserState, config_dict::Vector{Tuple{String, Proto.Value}}, storage_integration_opt::Union{Nothing, Vector{Tuple{String, Proto.Value}}})::Proto.CSVConfig config = Dict(config_dict) - _t2097 = _extract_value_int32(parser, get(config, "csv_header_row", nothing), 1) - header_row = _t2097 - _t2098 = _extract_value_int64(parser, get(config, "csv_skip", nothing), 0) - skip = _t2098 - _t2099 = _extract_value_string(parser, get(config, "csv_new_line", nothing), "") - new_line = _t2099 - _t2100 = _extract_value_string(parser, get(config, "csv_delimiter", nothing), ",") - delimiter = _t2100 - _t2101 = _extract_value_string(parser, get(config, "csv_quotechar", nothing), "\"") - quotechar = _t2101 - _t2102 = _extract_value_string(parser, get(config, "csv_escapechar", nothing), "\"") - escapechar = _t2102 - _t2103 = _extract_value_string(parser, get(config, "csv_comment", nothing), "") - comment = _t2103 - _t2104 = _extract_value_string_list(parser, get(config, "csv_missing_strings", nothing), String[]) - missing_strings = _t2104 - _t2105 = _extract_value_string(parser, get(config, "csv_decimal_separator", nothing), ".") - decimal_separator = _t2105 - _t2106 = _extract_value_string(parser, get(config, "csv_encoding", nothing), "utf-8") - encoding = _t2106 - _t2107 = _extract_value_string(parser, get(config, "csv_compression", nothing), "") - compression = _t2107 - _t2108 = _extract_value_int64(parser, get(config, "csv_partition_size_mb", nothing), 0) - partition_size_mb = _t2108 - _t2109 = construct_csv_storage_integration(parser, storage_integration_opt) - storage_integration = _t2109 - _t2110 = Proto.CSVConfig(header_row=header_row, skip=skip, new_line=new_line, delimiter=delimiter, quotechar=quotechar, escapechar=escapechar, comment=comment, missing_strings=missing_strings, decimal_separator=decimal_separator, encoding=encoding, compression=compression, partition_size_mb=partition_size_mb, storage_integration=storage_integration) - return _t2110 + _t2122 = _extract_value_int32(parser, get(config, "csv_header_row", nothing), 1) + header_row = _t2122 + _t2123 = _extract_value_int64(parser, get(config, "csv_skip", nothing), 0) + skip = _t2123 + _t2124 = _extract_value_string(parser, get(config, "csv_new_line", nothing), "") + new_line = _t2124 + _t2125 = _extract_value_string(parser, get(config, "csv_delimiter", nothing), ",") + delimiter = _t2125 + _t2126 = _extract_value_string(parser, get(config, "csv_quotechar", nothing), "\"") + quotechar = _t2126 + _t2127 = _extract_value_string(parser, get(config, "csv_escapechar", nothing), "\"") + escapechar = _t2127 + _t2128 = _extract_value_string(parser, get(config, "csv_comment", nothing), "") + comment = _t2128 + _t2129 = _extract_value_string_list(parser, get(config, "csv_missing_strings", nothing), String[]) + missing_strings = _t2129 + _t2130 = _extract_value_string(parser, get(config, "csv_decimal_separator", nothing), ".") + decimal_separator = _t2130 + _t2131 = _extract_value_string(parser, get(config, "csv_encoding", nothing), "utf-8") + encoding = _t2131 + _t2132 = _extract_value_string(parser, get(config, "csv_compression", nothing), "") + compression = _t2132 + _t2133 = _extract_value_int64(parser, get(config, "csv_partition_size_mb", nothing), 0) + partition_size_mb = _t2133 + _t2134 = construct_csv_storage_integration(parser, storage_integration_opt) + storage_integration = _t2134 + _t2135 = 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 _t2135 end function construct_csv_storage_integration(parser::ParserState, storage_integration_opt::Union{Nothing, Vector{Tuple{String, Proto.Value}}})::Union{Nothing, Proto.StorageIntegration} if isnothing(storage_integration_opt) return nothing else - _t2111 = nothing + _t2136 = nothing end config = Dict(storage_integration_opt) - _t2112 = _extract_value_string(parser, get(config, "provider", nothing), "") - _t2113 = _extract_value_string(parser, get(config, "azure_sas_token", nothing), "") - _t2114 = _extract_value_string(parser, get(config, "s3_region", nothing), "") - _t2115 = _extract_value_string(parser, get(config, "s3_access_key_id", nothing), "") - _t2116 = _extract_value_string(parser, get(config, "s3_secret_access_key", nothing), "") - _t2117 = Proto.StorageIntegration(provider=_t2112, azure_sas_token=_t2113, s3_region=_t2114, s3_access_key_id=_t2115, s3_secret_access_key=_t2116) - return _t2117 + _t2137 = _extract_value_string(parser, get(config, "provider", nothing), "") + _t2138 = _extract_value_string(parser, get(config, "azure_sas_token", nothing), "") + _t2139 = _extract_value_string(parser, get(config, "s3_region", nothing), "") + _t2140 = _extract_value_string(parser, get(config, "s3_access_key_id", nothing), "") + _t2141 = _extract_value_string(parser, get(config, "s3_secret_access_key", nothing), "") + _t2142 = Proto.StorageIntegration(provider=_t2137, azure_sas_token=_t2138, s3_region=_t2139, s3_access_key_id=_t2140, s3_secret_access_key=_t2141) + return _t2142 end function construct_betree_info(parser::ParserState, key_types::Vector{Proto.var"#Type"}, value_types::Vector{Proto.var"#Type"}, config_dict::Vector{Tuple{String, Proto.Value}})::Proto.BeTreeInfo config = Dict(config_dict) - _t2118 = _try_extract_value_float64(parser, get(config, "betree_config_epsilon", nothing)) - epsilon = _t2118 - _t2119 = _try_extract_value_int64(parser, get(config, "betree_config_max_pivots", nothing)) - max_pivots = _t2119 - _t2120 = _try_extract_value_int64(parser, get(config, "betree_config_max_deltas", nothing)) - max_deltas = _t2120 - _t2121 = _try_extract_value_int64(parser, get(config, "betree_config_max_leaf", nothing)) - max_leaf = _t2121 - _t2122 = Proto.BeTreeConfig(epsilon=epsilon, max_pivots=max_pivots, max_deltas=max_deltas, max_leaf=max_leaf) - storage_config = _t2122 - _t2123 = _try_extract_value_uint128(parser, get(config, "betree_locator_root_pageid", nothing)) - root_pageid = _t2123 - _t2124 = _try_extract_value_bytes(parser, get(config, "betree_locator_inline_data", nothing)) - inline_data = _t2124 - _t2125 = _try_extract_value_int64(parser, get(config, "betree_locator_element_count", nothing)) - element_count = _t2125 - _t2126 = _try_extract_value_int64(parser, get(config, "betree_locator_tree_height", nothing)) - tree_height = _t2126 - _t2127 = Proto.BeTreeLocator(location=(!isnothing(root_pageid) ? OneOf(:root_pageid, root_pageid) : (!isnothing(inline_data) ? OneOf(:inline_data, inline_data) : nothing)), element_count=element_count, tree_height=tree_height) - relation_locator = _t2127 - _t2128 = Proto.BeTreeInfo(key_types=key_types, value_types=value_types, storage_config=storage_config, relation_locator=relation_locator) - return _t2128 + _t2143 = _try_extract_value_float64(parser, get(config, "betree_config_epsilon", nothing)) + epsilon = _t2143 + _t2144 = _try_extract_value_int64(parser, get(config, "betree_config_max_pivots", nothing)) + max_pivots = _t2144 + _t2145 = _try_extract_value_int64(parser, get(config, "betree_config_max_deltas", nothing)) + max_deltas = _t2145 + _t2146 = _try_extract_value_int64(parser, get(config, "betree_config_max_leaf", nothing)) + max_leaf = _t2146 + _t2147 = Proto.BeTreeConfig(epsilon=epsilon, max_pivots=max_pivots, max_deltas=max_deltas, max_leaf=max_leaf) + storage_config = _t2147 + _t2148 = _try_extract_value_uint128(parser, get(config, "betree_locator_root_pageid", nothing)) + root_pageid = _t2148 + _t2149 = _try_extract_value_bytes(parser, get(config, "betree_locator_inline_data", nothing)) + inline_data = _t2149 + _t2150 = _try_extract_value_int64(parser, get(config, "betree_locator_element_count", nothing)) + element_count = _t2150 + _t2151 = _try_extract_value_int64(parser, get(config, "betree_locator_tree_height", nothing)) + tree_height = _t2151 + _t2152 = 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 = _t2152 + _t2153 = Proto.BeTreeInfo(key_types=key_types, value_types=value_types, storage_config=storage_config, relation_locator=relation_locator) + return _t2153 end function default_configure(parser::ParserState)::Proto.Configure - _t2129 = Proto.IVMConfig(level=Proto.MaintenanceLevel.MAINTENANCE_LEVEL_OFF) - ivm_config = _t2129 - _t2130 = Proto.Configure(semantics_version=0, ivm_config=ivm_config) - return _t2130 + _t2154 = Proto.IVMConfig(level=Proto.MaintenanceLevel.MAINTENANCE_LEVEL_OFF) + ivm_config = _t2154 + _t2155 = Proto.Configure(semantics_version=0, ivm_config=ivm_config) + return _t2155 end function construct_configure(parser::ParserState, config_dict::Vector{Tuple{String, Proto.Value}})::Proto.Configure @@ -549,3856 +549,3897 @@ function construct_configure(parser::ParserState, config_dict::Vector{Tuple{Stri end end end - _t2131 = Proto.IVMConfig(level=maintenance_level) - ivm_config = _t2131 - _t2132 = _extract_value_int64(parser, get(config, "semantics_version", nothing), 0) - semantics_version = _t2132 - _t2133 = Proto.Configure(semantics_version=semantics_version, ivm_config=ivm_config) - return _t2133 + _t2156 = Proto.IVMConfig(level=maintenance_level) + ivm_config = _t2156 + _t2157 = _extract_value_int64(parser, get(config, "semantics_version", nothing), 0) + semantics_version = _t2157 + _t2158 = Proto.Configure(semantics_version=semantics_version, ivm_config=ivm_config) + return _t2158 end function construct_export_csv_config(parser::ParserState, path::String, columns::Vector{Proto.ExportCSVColumn}, config_dict::Vector{Tuple{String, Proto.Value}})::Proto.ExportCSVConfig config = Dict(config_dict) - _t2134 = _extract_value_int64(parser, get(config, "partition_size", nothing), 0) - partition_size = _t2134 - _t2135 = _extract_value_string(parser, get(config, "compression", nothing), "") - compression = _t2135 - _t2136 = _extract_value_boolean(parser, get(config, "syntax_header_row", nothing), true) - syntax_header_row = _t2136 - _t2137 = _extract_value_string(parser, get(config, "syntax_missing_string", nothing), "") - syntax_missing_string = _t2137 - _t2138 = _extract_value_string(parser, get(config, "syntax_delim", nothing), ",") - syntax_delim = _t2138 - _t2139 = _extract_value_string(parser, get(config, "syntax_quotechar", nothing), "\"") - syntax_quotechar = _t2139 - _t2140 = _extract_value_string(parser, get(config, "syntax_escapechar", nothing), "\\") - syntax_escapechar = _t2140 - _t2141 = Proto.ExportCSVConfig(path=path, data_columns=columns, partition_size=partition_size, compression=compression, syntax_header_row=syntax_header_row, syntax_missing_string=syntax_missing_string, syntax_delim=syntax_delim, syntax_quotechar=syntax_quotechar, syntax_escapechar=syntax_escapechar) - return _t2141 + _t2159 = _extract_value_int64(parser, get(config, "partition_size", nothing), 0) + partition_size = _t2159 + _t2160 = _extract_value_string(parser, get(config, "compression", nothing), "") + compression = _t2160 + _t2161 = _extract_value_boolean(parser, get(config, "syntax_header_row", nothing), true) + syntax_header_row = _t2161 + _t2162 = _extract_value_string(parser, get(config, "syntax_missing_string", nothing), "") + syntax_missing_string = _t2162 + _t2163 = _extract_value_string(parser, get(config, "syntax_delim", nothing), ",") + syntax_delim = _t2163 + _t2164 = _extract_value_string(parser, get(config, "syntax_quotechar", nothing), "\"") + syntax_quotechar = _t2164 + _t2165 = _extract_value_string(parser, get(config, "syntax_escapechar", nothing), "\\") + syntax_escapechar = _t2165 + _t2166 = 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 _t2166 end function construct_export_csv_config_with_source(parser::ParserState, path::String, csv_source::Proto.ExportCSVSource, csv_config::Proto.CSVConfig)::Proto.ExportCSVConfig - _t2142 = Proto.ExportCSVConfig(path=path, csv_source=csv_source, csv_config=csv_config) - return _t2142 + _t2167 = Proto.ExportCSVConfig(path=path, csv_source=csv_source, csv_config=csv_config) + return _t2167 end function construct_iceberg_catalog_config(parser::ParserState, catalog_uri::String, scope_opt::Union{Nothing, String}, property_pairs::Vector{Tuple{String, String}}, auth_property_pairs::Vector{Tuple{String, String}})::Proto.IcebergCatalogConfig props = Dict(property_pairs) auth_props = Dict(auth_property_pairs) - _t2143 = Proto.IcebergCatalogConfig(catalog_uri=catalog_uri, scope=(!isnothing(scope_opt) ? scope_opt : ""), properties=props, auth_properties=auth_props) - return _t2143 + _t2168 = Proto.IcebergCatalogConfig(catalog_uri=catalog_uri, scope=(!isnothing(scope_opt) ? scope_opt : ""), properties=props, auth_properties=auth_props) + return _t2168 end function construct_iceberg_data(parser::ParserState, locator::Proto.IcebergLocator, config::Proto.IcebergCatalogConfig, columns::Vector{Proto.GNFColumn}, from_snapshot_opt::Union{Nothing, String}, to_snapshot_opt::Union{Nothing, String}, returns_delta::Bool)::Proto.IcebergData - _t2144 = Proto.IcebergData(locator=locator, config=config, columns=columns, from_snapshot=(!isnothing(from_snapshot_opt) ? from_snapshot_opt : ""), to_snapshot=(!isnothing(to_snapshot_opt) ? to_snapshot_opt : ""), returns_delta=returns_delta) - return _t2144 + _t2169 = 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 _t2169 end function construct_export_iceberg_config_full(parser::ParserState, locator::Proto.IcebergLocator, config::Proto.IcebergCatalogConfig, table_def::Proto.RelationId, table_property_pairs::Vector{Tuple{String, String}}, config_dict::Union{Nothing, Vector{Tuple{String, Proto.Value}}})::Proto.ExportIcebergConfig cfg = Dict((!isnothing(config_dict) ? config_dict : Tuple{String, Proto.Value}[])) - _t2145 = _extract_value_string(parser, get(cfg, "prefix", nothing), "") - prefix = _t2145 - _t2146 = _extract_value_int64(parser, get(cfg, "target_file_size_bytes", nothing), 0) - target_file_size_bytes = _t2146 - _t2147 = _extract_value_string(parser, get(cfg, "compression", nothing), "") - compression = _t2147 + _t2170 = _extract_value_string(parser, get(cfg, "prefix", nothing), "") + prefix = _t2170 + _t2171 = _extract_value_int64(parser, get(cfg, "target_file_size_bytes", nothing), 0) + target_file_size_bytes = _t2171 + _t2172 = _extract_value_string(parser, get(cfg, "compression", nothing), "") + compression = _t2172 table_props = Dict(table_property_pairs) - _t2148 = Proto.ExportIcebergConfig(locator=locator, config=config, table_def=table_def, prefix=prefix, target_file_size_bytes=target_file_size_bytes, compression=compression, table_properties=table_props) - return _t2148 + _t2173 = 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 _t2173 end # --- Parse functions --- function parse_transaction(parser::ParserState)::Proto.Transaction - span_start673 = span_start(parser) + span_start681 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "transaction") if (match_lookahead_literal(parser, "(", 0) && match_lookahead_literal(parser, "configure", 1)) - _t1335 = parse_configure(parser) - _t1334 = _t1335 + _t1351 = parse_configure(parser) + _t1350 = _t1351 else - _t1334 = nothing + _t1350 = nothing end - configure667 = _t1334 + configure675 = _t1350 if (match_lookahead_literal(parser, "(", 0) && match_lookahead_literal(parser, "sync", 1)) - _t1337 = parse_sync(parser) - _t1336 = _t1337 + _t1353 = parse_sync(parser) + _t1352 = _t1353 else - _t1336 = nothing + _t1352 = nothing end - sync668 = _t1336 - xs669 = Proto.Epoch[] - cond670 = match_lookahead_literal(parser, "(", 0) - while cond670 - _t1338 = parse_epoch(parser) - item671 = _t1338 - push!(xs669, item671) - cond670 = match_lookahead_literal(parser, "(", 0) + sync676 = _t1352 + xs677 = Proto.Epoch[] + cond678 = match_lookahead_literal(parser, "(", 0) + while cond678 + _t1354 = parse_epoch(parser) + item679 = _t1354 + push!(xs677, item679) + cond678 = match_lookahead_literal(parser, "(", 0) end - epochs672 = xs669 + epochs680 = xs677 consume_literal!(parser, ")") - _t1339 = default_configure(parser) - _t1340 = Proto.Transaction(epochs=epochs672, configure=(!isnothing(configure667) ? configure667 : _t1339), sync=sync668) - result674 = _t1340 - record_span!(parser, span_start673, "Transaction") - return result674 + _t1355 = default_configure(parser) + _t1356 = Proto.Transaction(epochs=epochs680, configure=(!isnothing(configure675) ? configure675 : _t1355), sync=sync676) + result682 = _t1356 + record_span!(parser, span_start681, "Transaction") + return result682 end function parse_configure(parser::ParserState)::Proto.Configure - span_start676 = span_start(parser) + span_start684 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "configure") - _t1341 = parse_config_dict(parser) - config_dict675 = _t1341 + _t1357 = parse_config_dict(parser) + config_dict683 = _t1357 consume_literal!(parser, ")") - _t1342 = construct_configure(parser, config_dict675) - result677 = _t1342 - record_span!(parser, span_start676, "Configure") - return result677 + _t1358 = construct_configure(parser, config_dict683) + result685 = _t1358 + record_span!(parser, span_start684, "Configure") + return result685 end function parse_config_dict(parser::ParserState)::Vector{Tuple{String, Proto.Value}} consume_literal!(parser, "{") - xs678 = Tuple{String, Proto.Value}[] - cond679 = match_lookahead_literal(parser, ":", 0) - while cond679 - _t1343 = parse_config_key_value(parser) - item680 = _t1343 - push!(xs678, item680) - cond679 = match_lookahead_literal(parser, ":", 0) + xs686 = Tuple{String, Proto.Value}[] + cond687 = match_lookahead_literal(parser, ":", 0) + while cond687 + _t1359 = parse_config_key_value(parser) + item688 = _t1359 + push!(xs686, item688) + cond687 = match_lookahead_literal(parser, ":", 0) end - config_key_values681 = xs678 + config_key_values689 = xs686 consume_literal!(parser, "}") - return config_key_values681 + return config_key_values689 end function parse_config_key_value(parser::ParserState)::Tuple{String, Proto.Value} consume_literal!(parser, ":") - symbol682 = consume_terminal!(parser, "SYMBOL") - _t1344 = parse_raw_value(parser) - raw_value683 = _t1344 - return (symbol682, raw_value683,) + symbol690 = consume_terminal!(parser, "SYMBOL") + _t1360 = parse_raw_value(parser) + raw_value691 = _t1360 + return (symbol690, raw_value691,) end function parse_raw_value(parser::ParserState)::Proto.Value - span_start697 = span_start(parser) + span_start705 = span_start(parser) if match_lookahead_literal(parser, "true", 0) - _t1345 = 12 + _t1361 = 12 else if match_lookahead_literal(parser, "missing", 0) - _t1346 = 11 + _t1362 = 11 else if match_lookahead_literal(parser, "false", 0) - _t1347 = 12 + _t1363 = 12 else if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "datetime", 1) - _t1349 = 1 + _t1365 = 1 else if match_lookahead_literal(parser, "date", 1) - _t1350 = 0 + _t1366 = 0 else - _t1350 = -1 + _t1366 = -1 end - _t1349 = _t1350 + _t1365 = _t1366 end - _t1348 = _t1349 + _t1364 = _t1365 else if match_lookahead_terminal(parser, "UINT32", 0) - _t1351 = 7 + _t1367 = 7 else if match_lookahead_terminal(parser, "UINT128", 0) - _t1352 = 8 + _t1368 = 8 else if match_lookahead_terminal(parser, "STRING", 0) - _t1353 = 2 + _t1369 = 2 else if match_lookahead_terminal(parser, "INT32", 0) - _t1354 = 3 + _t1370 = 3 else if match_lookahead_terminal(parser, "INT128", 0) - _t1355 = 9 + _t1371 = 9 else if match_lookahead_terminal(parser, "INT", 0) - _t1356 = 4 + _t1372 = 4 else if match_lookahead_terminal(parser, "FLOAT32", 0) - _t1357 = 5 + _t1373 = 5 else if match_lookahead_terminal(parser, "FLOAT", 0) - _t1358 = 6 + _t1374 = 6 else if match_lookahead_terminal(parser, "DECIMAL", 0) - _t1359 = 10 + _t1375 = 10 else - _t1359 = -1 + _t1375 = -1 end - _t1358 = _t1359 + _t1374 = _t1375 end - _t1357 = _t1358 + _t1373 = _t1374 end - _t1356 = _t1357 + _t1372 = _t1373 end - _t1355 = _t1356 + _t1371 = _t1372 end - _t1354 = _t1355 + _t1370 = _t1371 end - _t1353 = _t1354 + _t1369 = _t1370 end - _t1352 = _t1353 + _t1368 = _t1369 end - _t1351 = _t1352 + _t1367 = _t1368 end - _t1348 = _t1351 + _t1364 = _t1367 end - _t1347 = _t1348 + _t1363 = _t1364 end - _t1346 = _t1347 + _t1362 = _t1363 end - _t1345 = _t1346 + _t1361 = _t1362 end - prediction684 = _t1345 - if prediction684 == 12 - _t1361 = parse_boolean_value(parser) - boolean_value696 = _t1361 - _t1362 = Proto.Value(value=OneOf(:boolean_value, boolean_value696)) - _t1360 = _t1362 + prediction692 = _t1361 + if prediction692 == 12 + _t1377 = parse_boolean_value(parser) + boolean_value704 = _t1377 + _t1378 = Proto.Value(value=OneOf(:boolean_value, boolean_value704)) + _t1376 = _t1378 else - if prediction684 == 11 + if prediction692 == 11 consume_literal!(parser, "missing") - _t1364 = Proto.MissingValue() - _t1365 = Proto.Value(value=OneOf(:missing_value, _t1364)) - _t1363 = _t1365 + _t1380 = Proto.MissingValue() + _t1381 = Proto.Value(value=OneOf(:missing_value, _t1380)) + _t1379 = _t1381 else - if prediction684 == 10 - decimal695 = consume_terminal!(parser, "DECIMAL") - _t1367 = Proto.Value(value=OneOf(:decimal_value, decimal695)) - _t1366 = _t1367 + if prediction692 == 10 + decimal703 = consume_terminal!(parser, "DECIMAL") + _t1383 = Proto.Value(value=OneOf(:decimal_value, decimal703)) + _t1382 = _t1383 else - if prediction684 == 9 - int128694 = consume_terminal!(parser, "INT128") - _t1369 = Proto.Value(value=OneOf(:int128_value, int128694)) - _t1368 = _t1369 + if prediction692 == 9 + int128702 = consume_terminal!(parser, "INT128") + _t1385 = Proto.Value(value=OneOf(:int128_value, int128702)) + _t1384 = _t1385 else - if prediction684 == 8 - uint128693 = consume_terminal!(parser, "UINT128") - _t1371 = Proto.Value(value=OneOf(:uint128_value, uint128693)) - _t1370 = _t1371 + if prediction692 == 8 + uint128701 = consume_terminal!(parser, "UINT128") + _t1387 = Proto.Value(value=OneOf(:uint128_value, uint128701)) + _t1386 = _t1387 else - if prediction684 == 7 - uint32692 = consume_terminal!(parser, "UINT32") - _t1373 = Proto.Value(value=OneOf(:uint32_value, uint32692)) - _t1372 = _t1373 + if prediction692 == 7 + uint32700 = consume_terminal!(parser, "UINT32") + _t1389 = Proto.Value(value=OneOf(:uint32_value, uint32700)) + _t1388 = _t1389 else - if prediction684 == 6 - float691 = consume_terminal!(parser, "FLOAT") - _t1375 = Proto.Value(value=OneOf(:float_value, float691)) - _t1374 = _t1375 + if prediction692 == 6 + float699 = consume_terminal!(parser, "FLOAT") + _t1391 = Proto.Value(value=OneOf(:float_value, float699)) + _t1390 = _t1391 else - if prediction684 == 5 - float32690 = consume_terminal!(parser, "FLOAT32") - _t1377 = Proto.Value(value=OneOf(:float32_value, float32690)) - _t1376 = _t1377 + if prediction692 == 5 + float32698 = consume_terminal!(parser, "FLOAT32") + _t1393 = Proto.Value(value=OneOf(:float32_value, float32698)) + _t1392 = _t1393 else - if prediction684 == 4 - int689 = consume_terminal!(parser, "INT") - _t1379 = Proto.Value(value=OneOf(:int_value, int689)) - _t1378 = _t1379 + if prediction692 == 4 + int697 = consume_terminal!(parser, "INT") + _t1395 = Proto.Value(value=OneOf(:int_value, int697)) + _t1394 = _t1395 else - if prediction684 == 3 - int32688 = consume_terminal!(parser, "INT32") - _t1381 = Proto.Value(value=OneOf(:int32_value, int32688)) - _t1380 = _t1381 + if prediction692 == 3 + int32696 = consume_terminal!(parser, "INT32") + _t1397 = Proto.Value(value=OneOf(:int32_value, int32696)) + _t1396 = _t1397 else - if prediction684 == 2 - string687 = consume_terminal!(parser, "STRING") - _t1383 = Proto.Value(value=OneOf(:string_value, string687)) - _t1382 = _t1383 + if prediction692 == 2 + string695 = consume_terminal!(parser, "STRING") + _t1399 = Proto.Value(value=OneOf(:string_value, string695)) + _t1398 = _t1399 else - if prediction684 == 1 - _t1385 = parse_raw_datetime(parser) - raw_datetime686 = _t1385 - _t1386 = Proto.Value(value=OneOf(:datetime_value, raw_datetime686)) - _t1384 = _t1386 + if prediction692 == 1 + _t1401 = parse_raw_datetime(parser) + raw_datetime694 = _t1401 + _t1402 = Proto.Value(value=OneOf(:datetime_value, raw_datetime694)) + _t1400 = _t1402 else - if prediction684 == 0 - _t1388 = parse_raw_date(parser) - raw_date685 = _t1388 - _t1389 = Proto.Value(value=OneOf(:date_value, raw_date685)) - _t1387 = _t1389 + if prediction692 == 0 + _t1404 = parse_raw_date(parser) + raw_date693 = _t1404 + _t1405 = Proto.Value(value=OneOf(:date_value, raw_date693)) + _t1403 = _t1405 else throw(ParseError("Unexpected token in raw_value" * ": " * string(lookahead(parser, 0)))) end - _t1384 = _t1387 + _t1400 = _t1403 end - _t1382 = _t1384 + _t1398 = _t1400 end - _t1380 = _t1382 + _t1396 = _t1398 end - _t1378 = _t1380 + _t1394 = _t1396 end - _t1376 = _t1378 + _t1392 = _t1394 end - _t1374 = _t1376 + _t1390 = _t1392 end - _t1372 = _t1374 + _t1388 = _t1390 end - _t1370 = _t1372 + _t1386 = _t1388 end - _t1368 = _t1370 + _t1384 = _t1386 end - _t1366 = _t1368 + _t1382 = _t1384 end - _t1363 = _t1366 + _t1379 = _t1382 end - _t1360 = _t1363 + _t1376 = _t1379 end - result698 = _t1360 - record_span!(parser, span_start697, "Value") - return result698 + result706 = _t1376 + record_span!(parser, span_start705, "Value") + return result706 end function parse_raw_date(parser::ParserState)::Proto.DateValue - span_start702 = span_start(parser) + span_start710 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "date") - int699 = consume_terminal!(parser, "INT") - int_3700 = consume_terminal!(parser, "INT") - int_4701 = consume_terminal!(parser, "INT") + int707 = consume_terminal!(parser, "INT") + int_3708 = consume_terminal!(parser, "INT") + int_4709 = consume_terminal!(parser, "INT") consume_literal!(parser, ")") - _t1390 = Proto.DateValue(year=Int32(int699), month=Int32(int_3700), day=Int32(int_4701)) - result703 = _t1390 - record_span!(parser, span_start702, "DateValue") - return result703 + _t1406 = Proto.DateValue(year=Int32(int707), month=Int32(int_3708), day=Int32(int_4709)) + result711 = _t1406 + record_span!(parser, span_start710, "DateValue") + return result711 end function parse_raw_datetime(parser::ParserState)::Proto.DateTimeValue - span_start711 = span_start(parser) + span_start719 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "datetime") - int704 = consume_terminal!(parser, "INT") - int_3705 = consume_terminal!(parser, "INT") - int_4706 = consume_terminal!(parser, "INT") - int_5707 = consume_terminal!(parser, "INT") - int_6708 = consume_terminal!(parser, "INT") - int_7709 = consume_terminal!(parser, "INT") + int712 = consume_terminal!(parser, "INT") + int_3713 = consume_terminal!(parser, "INT") + int_4714 = consume_terminal!(parser, "INT") + int_5715 = consume_terminal!(parser, "INT") + int_6716 = consume_terminal!(parser, "INT") + int_7717 = consume_terminal!(parser, "INT") if match_lookahead_terminal(parser, "INT", 0) - _t1391 = consume_terminal!(parser, "INT") + _t1407 = consume_terminal!(parser, "INT") else - _t1391 = nothing + _t1407 = nothing end - int_8710 = _t1391 + int_8718 = _t1407 consume_literal!(parser, ")") - _t1392 = Proto.DateTimeValue(year=Int32(int704), month=Int32(int_3705), day=Int32(int_4706), hour=Int32(int_5707), minute=Int32(int_6708), second=Int32(int_7709), microsecond=Int32((!isnothing(int_8710) ? int_8710 : 0))) - result712 = _t1392 - record_span!(parser, span_start711, "DateTimeValue") - return result712 + _t1408 = Proto.DateTimeValue(year=Int32(int712), month=Int32(int_3713), day=Int32(int_4714), hour=Int32(int_5715), minute=Int32(int_6716), second=Int32(int_7717), microsecond=Int32((!isnothing(int_8718) ? int_8718 : 0))) + result720 = _t1408 + record_span!(parser, span_start719, "DateTimeValue") + return result720 end function parse_boolean_value(parser::ParserState)::Bool if match_lookahead_literal(parser, "true", 0) - _t1393 = 0 + _t1409 = 0 else if match_lookahead_literal(parser, "false", 0) - _t1394 = 1 + _t1410 = 1 else - _t1394 = -1 + _t1410 = -1 end - _t1393 = _t1394 + _t1409 = _t1410 end - prediction713 = _t1393 - if prediction713 == 1 + prediction721 = _t1409 + if prediction721 == 1 consume_literal!(parser, "false") - _t1395 = false + _t1411 = false else - if prediction713 == 0 + if prediction721 == 0 consume_literal!(parser, "true") - _t1396 = true + _t1412 = true else throw(ParseError("Unexpected token in boolean_value" * ": " * string(lookahead(parser, 0)))) end - _t1395 = _t1396 + _t1411 = _t1412 end - return _t1395 + return _t1411 end function parse_sync(parser::ParserState)::Proto.Sync - span_start718 = span_start(parser) + span_start726 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "sync") - xs714 = Proto.FragmentId[] - cond715 = match_lookahead_literal(parser, ":", 0) - while cond715 - _t1397 = parse_fragment_id(parser) - item716 = _t1397 - push!(xs714, item716) - cond715 = match_lookahead_literal(parser, ":", 0) + xs722 = Proto.FragmentId[] + cond723 = match_lookahead_literal(parser, ":", 0) + while cond723 + _t1413 = parse_fragment_id(parser) + item724 = _t1413 + push!(xs722, item724) + cond723 = match_lookahead_literal(parser, ":", 0) end - fragment_ids717 = xs714 + fragment_ids725 = xs722 consume_literal!(parser, ")") - _t1398 = Proto.Sync(fragments=fragment_ids717) - result719 = _t1398 - record_span!(parser, span_start718, "Sync") - return result719 + _t1414 = Proto.Sync(fragments=fragment_ids725) + result727 = _t1414 + record_span!(parser, span_start726, "Sync") + return result727 end function parse_fragment_id(parser::ParserState)::Proto.FragmentId - span_start721 = span_start(parser) + span_start729 = span_start(parser) consume_literal!(parser, ":") - symbol720 = consume_terminal!(parser, "SYMBOL") - result722 = Proto.FragmentId(Vector{UInt8}(symbol720)) - record_span!(parser, span_start721, "FragmentId") - return result722 + symbol728 = consume_terminal!(parser, "SYMBOL") + result730 = Proto.FragmentId(Vector{UInt8}(symbol728)) + record_span!(parser, span_start729, "FragmentId") + return result730 end function parse_epoch(parser::ParserState)::Proto.Epoch - span_start725 = span_start(parser) + span_start733 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "epoch") if (match_lookahead_literal(parser, "(", 0) && match_lookahead_literal(parser, "writes", 1)) - _t1400 = parse_epoch_writes(parser) - _t1399 = _t1400 + _t1416 = parse_epoch_writes(parser) + _t1415 = _t1416 else - _t1399 = nothing + _t1415 = nothing end - epoch_writes723 = _t1399 + epoch_writes731 = _t1415 if match_lookahead_literal(parser, "(", 0) - _t1402 = parse_epoch_reads(parser) - _t1401 = _t1402 + _t1418 = parse_epoch_reads(parser) + _t1417 = _t1418 else - _t1401 = nothing + _t1417 = nothing end - epoch_reads724 = _t1401 + epoch_reads732 = _t1417 consume_literal!(parser, ")") - _t1403 = Proto.Epoch(writes=(!isnothing(epoch_writes723) ? epoch_writes723 : Proto.Write[]), reads=(!isnothing(epoch_reads724) ? epoch_reads724 : Proto.Read[])) - result726 = _t1403 - record_span!(parser, span_start725, "Epoch") - return result726 + _t1419 = Proto.Epoch(writes=(!isnothing(epoch_writes731) ? epoch_writes731 : Proto.Write[]), reads=(!isnothing(epoch_reads732) ? epoch_reads732 : Proto.Read[])) + result734 = _t1419 + record_span!(parser, span_start733, "Epoch") + return result734 end function parse_epoch_writes(parser::ParserState)::Vector{Proto.Write} consume_literal!(parser, "(") consume_literal!(parser, "writes") - xs727 = Proto.Write[] - cond728 = match_lookahead_literal(parser, "(", 0) - while cond728 - _t1404 = parse_write(parser) - item729 = _t1404 - push!(xs727, item729) - cond728 = match_lookahead_literal(parser, "(", 0) + xs735 = Proto.Write[] + cond736 = match_lookahead_literal(parser, "(", 0) + while cond736 + _t1420 = parse_write(parser) + item737 = _t1420 + push!(xs735, item737) + cond736 = match_lookahead_literal(parser, "(", 0) end - writes730 = xs727 + writes738 = xs735 consume_literal!(parser, ")") - return writes730 + return writes738 end function parse_write(parser::ParserState)::Proto.Write - span_start736 = span_start(parser) + span_start744 = span_start(parser) if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "undefine", 1) - _t1406 = 1 + _t1422 = 1 else if match_lookahead_literal(parser, "snapshot", 1) - _t1407 = 3 + _t1423 = 3 else if match_lookahead_literal(parser, "define", 1) - _t1408 = 0 + _t1424 = 0 else if match_lookahead_literal(parser, "context", 1) - _t1409 = 2 + _t1425 = 2 else - _t1409 = -1 + _t1425 = -1 end - _t1408 = _t1409 + _t1424 = _t1425 end - _t1407 = _t1408 + _t1423 = _t1424 end - _t1406 = _t1407 + _t1422 = _t1423 end - _t1405 = _t1406 + _t1421 = _t1422 else - _t1405 = -1 + _t1421 = -1 end - prediction731 = _t1405 - if prediction731 == 3 - _t1411 = parse_snapshot(parser) - snapshot735 = _t1411 - _t1412 = Proto.Write(write_type=OneOf(:snapshot, snapshot735)) - _t1410 = _t1412 + prediction739 = _t1421 + if prediction739 == 3 + _t1427 = parse_snapshot(parser) + snapshot743 = _t1427 + _t1428 = Proto.Write(write_type=OneOf(:snapshot, snapshot743)) + _t1426 = _t1428 else - if prediction731 == 2 - _t1414 = parse_context(parser) - context734 = _t1414 - _t1415 = Proto.Write(write_type=OneOf(:context, context734)) - _t1413 = _t1415 + if prediction739 == 2 + _t1430 = parse_context(parser) + context742 = _t1430 + _t1431 = Proto.Write(write_type=OneOf(:context, context742)) + _t1429 = _t1431 else - if prediction731 == 1 - _t1417 = parse_undefine(parser) - undefine733 = _t1417 - _t1418 = Proto.Write(write_type=OneOf(:undefine, undefine733)) - _t1416 = _t1418 + if prediction739 == 1 + _t1433 = parse_undefine(parser) + undefine741 = _t1433 + _t1434 = Proto.Write(write_type=OneOf(:undefine, undefine741)) + _t1432 = _t1434 else - if prediction731 == 0 - _t1420 = parse_define(parser) - define732 = _t1420 - _t1421 = Proto.Write(write_type=OneOf(:define, define732)) - _t1419 = _t1421 + if prediction739 == 0 + _t1436 = parse_define(parser) + define740 = _t1436 + _t1437 = Proto.Write(write_type=OneOf(:define, define740)) + _t1435 = _t1437 else throw(ParseError("Unexpected token in write" * ": " * string(lookahead(parser, 0)))) end - _t1416 = _t1419 + _t1432 = _t1435 end - _t1413 = _t1416 + _t1429 = _t1432 end - _t1410 = _t1413 + _t1426 = _t1429 end - result737 = _t1410 - record_span!(parser, span_start736, "Write") - return result737 + result745 = _t1426 + record_span!(parser, span_start744, "Write") + return result745 end function parse_define(parser::ParserState)::Proto.Define - span_start739 = span_start(parser) + span_start747 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "define") - _t1422 = parse_fragment(parser) - fragment738 = _t1422 + _t1438 = parse_fragment(parser) + fragment746 = _t1438 consume_literal!(parser, ")") - _t1423 = Proto.Define(fragment=fragment738) - result740 = _t1423 - record_span!(parser, span_start739, "Define") - return result740 + _t1439 = Proto.Define(fragment=fragment746) + result748 = _t1439 + record_span!(parser, span_start747, "Define") + return result748 end function parse_fragment(parser::ParserState)::Proto.Fragment - span_start746 = span_start(parser) + span_start754 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "fragment") - _t1424 = parse_new_fragment_id(parser) - new_fragment_id741 = _t1424 - xs742 = Proto.Declaration[] - cond743 = match_lookahead_literal(parser, "(", 0) - while cond743 - _t1425 = parse_declaration(parser) - item744 = _t1425 - push!(xs742, item744) - cond743 = match_lookahead_literal(parser, "(", 0) + _t1440 = parse_new_fragment_id(parser) + new_fragment_id749 = _t1440 + xs750 = Proto.Declaration[] + cond751 = match_lookahead_literal(parser, "(", 0) + while cond751 + _t1441 = parse_declaration(parser) + item752 = _t1441 + push!(xs750, item752) + cond751 = match_lookahead_literal(parser, "(", 0) end - declarations745 = xs742 + declarations753 = xs750 consume_literal!(parser, ")") - result747 = construct_fragment(parser, new_fragment_id741, declarations745) - record_span!(parser, span_start746, "Fragment") - return result747 + result755 = construct_fragment(parser, new_fragment_id749, declarations753) + record_span!(parser, span_start754, "Fragment") + return result755 end function parse_new_fragment_id(parser::ParserState)::Proto.FragmentId - span_start749 = span_start(parser) - _t1426 = parse_fragment_id(parser) - fragment_id748 = _t1426 - start_fragment!(parser, fragment_id748) - result750 = fragment_id748 - record_span!(parser, span_start749, "FragmentId") - return result750 + span_start757 = span_start(parser) + _t1442 = parse_fragment_id(parser) + fragment_id756 = _t1442 + start_fragment!(parser, fragment_id756) + result758 = fragment_id756 + record_span!(parser, span_start757, "FragmentId") + return result758 end function parse_declaration(parser::ParserState)::Proto.Declaration - span_start756 = span_start(parser) + span_start764 = span_start(parser) if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "iceberg_data", 1) - _t1428 = 3 + _t1444 = 3 else if match_lookahead_literal(parser, "functional_dependency", 1) - _t1429 = 2 + _t1445 = 2 else if match_lookahead_literal(parser, "edb", 1) - _t1430 = 3 + _t1446 = 3 else if match_lookahead_literal(parser, "def", 1) - _t1431 = 0 + _t1447 = 0 else if match_lookahead_literal(parser, "csv_data", 1) - _t1432 = 3 + _t1448 = 3 else if match_lookahead_literal(parser, "betree_relation", 1) - _t1433 = 3 + _t1449 = 3 else if match_lookahead_literal(parser, "algorithm", 1) - _t1434 = 1 + _t1450 = 1 else - _t1434 = -1 + _t1450 = -1 end - _t1433 = _t1434 + _t1449 = _t1450 end - _t1432 = _t1433 + _t1448 = _t1449 end - _t1431 = _t1432 + _t1447 = _t1448 end - _t1430 = _t1431 + _t1446 = _t1447 end - _t1429 = _t1430 + _t1445 = _t1446 end - _t1428 = _t1429 + _t1444 = _t1445 end - _t1427 = _t1428 + _t1443 = _t1444 else - _t1427 = -1 + _t1443 = -1 end - prediction751 = _t1427 - if prediction751 == 3 - _t1436 = parse_data(parser) - data755 = _t1436 - _t1437 = Proto.Declaration(declaration_type=OneOf(:data, data755)) - _t1435 = _t1437 + prediction759 = _t1443 + if prediction759 == 3 + _t1452 = parse_data(parser) + data763 = _t1452 + _t1453 = Proto.Declaration(declaration_type=OneOf(:data, data763)) + _t1451 = _t1453 else - if prediction751 == 2 - _t1439 = parse_constraint(parser) - constraint754 = _t1439 - _t1440 = Proto.Declaration(declaration_type=OneOf(:constraint, constraint754)) - _t1438 = _t1440 + if prediction759 == 2 + _t1455 = parse_constraint(parser) + constraint762 = _t1455 + _t1456 = Proto.Declaration(declaration_type=OneOf(:constraint, constraint762)) + _t1454 = _t1456 else - if prediction751 == 1 - _t1442 = parse_algorithm(parser) - algorithm753 = _t1442 - _t1443 = Proto.Declaration(declaration_type=OneOf(:algorithm, algorithm753)) - _t1441 = _t1443 + if prediction759 == 1 + _t1458 = parse_algorithm(parser) + algorithm761 = _t1458 + _t1459 = Proto.Declaration(declaration_type=OneOf(:algorithm, algorithm761)) + _t1457 = _t1459 else - if prediction751 == 0 - _t1445 = parse_def(parser) - def752 = _t1445 - _t1446 = Proto.Declaration(declaration_type=OneOf(:def, def752)) - _t1444 = _t1446 + if prediction759 == 0 + _t1461 = parse_def(parser) + def760 = _t1461 + _t1462 = Proto.Declaration(declaration_type=OneOf(:def, def760)) + _t1460 = _t1462 else throw(ParseError("Unexpected token in declaration" * ": " * string(lookahead(parser, 0)))) end - _t1441 = _t1444 + _t1457 = _t1460 end - _t1438 = _t1441 + _t1454 = _t1457 end - _t1435 = _t1438 + _t1451 = _t1454 end - result757 = _t1435 - record_span!(parser, span_start756, "Declaration") - return result757 + result765 = _t1451 + record_span!(parser, span_start764, "Declaration") + return result765 end function parse_def(parser::ParserState)::Proto.Def - span_start761 = span_start(parser) + span_start769 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "def") - _t1447 = parse_relation_id(parser) - relation_id758 = _t1447 - _t1448 = parse_abstraction(parser) - abstraction759 = _t1448 + _t1463 = parse_relation_id(parser) + relation_id766 = _t1463 + _t1464 = parse_abstraction(parser) + abstraction767 = _t1464 if match_lookahead_literal(parser, "(", 0) - _t1450 = parse_attrs(parser) - _t1449 = _t1450 + _t1466 = parse_attrs(parser) + _t1465 = _t1466 else - _t1449 = nothing + _t1465 = nothing end - attrs760 = _t1449 + attrs768 = _t1465 consume_literal!(parser, ")") - _t1451 = Proto.Def(name=relation_id758, body=abstraction759, attrs=(!isnothing(attrs760) ? attrs760 : Proto.Attribute[])) - result762 = _t1451 - record_span!(parser, span_start761, "Def") - return result762 + _t1467 = Proto.Def(name=relation_id766, body=abstraction767, attrs=(!isnothing(attrs768) ? attrs768 : Proto.Attribute[])) + result770 = _t1467 + record_span!(parser, span_start769, "Def") + return result770 end function parse_relation_id(parser::ParserState)::Proto.RelationId - span_start766 = span_start(parser) + span_start774 = span_start(parser) if match_lookahead_literal(parser, ":", 0) - _t1452 = 0 + _t1468 = 0 else if match_lookahead_terminal(parser, "UINT128", 0) - _t1453 = 1 + _t1469 = 1 else - _t1453 = -1 + _t1469 = -1 end - _t1452 = _t1453 + _t1468 = _t1469 end - prediction763 = _t1452 - if prediction763 == 1 - uint128765 = consume_terminal!(parser, "UINT128") - _t1454 = Proto.RelationId(uint128765.low, uint128765.high) + prediction771 = _t1468 + if prediction771 == 1 + uint128773 = consume_terminal!(parser, "UINT128") + _t1470 = Proto.RelationId(uint128773.low, uint128773.high) else - if prediction763 == 0 + if prediction771 == 0 consume_literal!(parser, ":") - symbol764 = consume_terminal!(parser, "SYMBOL") - _t1455 = relation_id_from_string(parser, symbol764) + symbol772 = consume_terminal!(parser, "SYMBOL") + _t1471 = relation_id_from_string(parser, symbol772) else throw(ParseError("Unexpected token in relation_id" * ": " * string(lookahead(parser, 0)))) end - _t1454 = _t1455 + _t1470 = _t1471 end - result767 = _t1454 - record_span!(parser, span_start766, "RelationId") - return result767 + result775 = _t1470 + record_span!(parser, span_start774, "RelationId") + return result775 end function parse_abstraction(parser::ParserState)::Proto.Abstraction - span_start770 = span_start(parser) + span_start778 = span_start(parser) consume_literal!(parser, "(") - _t1456 = parse_bindings(parser) - bindings768 = _t1456 - _t1457 = parse_formula(parser) - formula769 = _t1457 + _t1472 = parse_bindings(parser) + bindings776 = _t1472 + _t1473 = parse_formula(parser) + formula777 = _t1473 consume_literal!(parser, ")") - _t1458 = Proto.Abstraction(vars=vcat(bindings768[1], !isnothing(bindings768[2]) ? bindings768[2] : []), value=formula769) - result771 = _t1458 - record_span!(parser, span_start770, "Abstraction") - return result771 + _t1474 = Proto.Abstraction(vars=vcat(bindings776[1], !isnothing(bindings776[2]) ? bindings776[2] : []), value=formula777) + result779 = _t1474 + record_span!(parser, span_start778, "Abstraction") + return result779 end function parse_bindings(parser::ParserState)::Tuple{Vector{Proto.Binding}, Vector{Proto.Binding}} consume_literal!(parser, "[") - xs772 = Proto.Binding[] - cond773 = match_lookahead_terminal(parser, "SYMBOL", 0) - while cond773 - _t1459 = parse_binding(parser) - item774 = _t1459 - push!(xs772, item774) - cond773 = match_lookahead_terminal(parser, "SYMBOL", 0) + xs780 = Proto.Binding[] + cond781 = match_lookahead_terminal(parser, "SYMBOL", 0) + while cond781 + _t1475 = parse_binding(parser) + item782 = _t1475 + push!(xs780, item782) + cond781 = match_lookahead_terminal(parser, "SYMBOL", 0) end - bindings775 = xs772 + bindings783 = xs780 if match_lookahead_literal(parser, "|", 0) - _t1461 = parse_value_bindings(parser) - _t1460 = _t1461 + _t1477 = parse_value_bindings(parser) + _t1476 = _t1477 else - _t1460 = nothing + _t1476 = nothing end - value_bindings776 = _t1460 + value_bindings784 = _t1476 consume_literal!(parser, "]") - return (bindings775, (!isnothing(value_bindings776) ? value_bindings776 : Proto.Binding[]),) + return (bindings783, (!isnothing(value_bindings784) ? value_bindings784 : Proto.Binding[]),) end function parse_binding(parser::ParserState)::Proto.Binding - span_start779 = span_start(parser) - symbol777 = consume_terminal!(parser, "SYMBOL") + span_start787 = span_start(parser) + symbol785 = consume_terminal!(parser, "SYMBOL") consume_literal!(parser, "::") - _t1462 = parse_type(parser) - type778 = _t1462 - _t1463 = Proto.Var(name=symbol777) - _t1464 = Proto.Binding(var=_t1463, var"#type"=type778) - result780 = _t1464 - record_span!(parser, span_start779, "Binding") - return result780 + _t1478 = parse_type(parser) + type786 = _t1478 + _t1479 = Proto.Var(name=symbol785) + _t1480 = Proto.Binding(var=_t1479, var"#type"=type786) + result788 = _t1480 + record_span!(parser, span_start787, "Binding") + return result788 end function parse_type(parser::ParserState)::Proto.var"#Type" - span_start796 = span_start(parser) + span_start804 = span_start(parser) if match_lookahead_literal(parser, "UNKNOWN", 0) - _t1465 = 0 + _t1481 = 0 else if match_lookahead_literal(parser, "UINT32", 0) - _t1466 = 13 + _t1482 = 13 else if match_lookahead_literal(parser, "UINT128", 0) - _t1467 = 4 + _t1483 = 4 else if match_lookahead_literal(parser, "STRING", 0) - _t1468 = 1 + _t1484 = 1 else if match_lookahead_literal(parser, "MISSING", 0) - _t1469 = 8 + _t1485 = 8 else if match_lookahead_literal(parser, "INT32", 0) - _t1470 = 11 + _t1486 = 11 else if match_lookahead_literal(parser, "INT128", 0) - _t1471 = 5 + _t1487 = 5 else if match_lookahead_literal(parser, "INT", 0) - _t1472 = 2 + _t1488 = 2 else if match_lookahead_literal(parser, "FLOAT32", 0) - _t1473 = 12 + _t1489 = 12 else if match_lookahead_literal(parser, "FLOAT", 0) - _t1474 = 3 + _t1490 = 3 else if match_lookahead_literal(parser, "DATETIME", 0) - _t1475 = 7 + _t1491 = 7 else if match_lookahead_literal(parser, "DATE", 0) - _t1476 = 6 + _t1492 = 6 else if match_lookahead_literal(parser, "BOOLEAN", 0) - _t1477 = 10 + _t1493 = 10 else if match_lookahead_literal(parser, "(", 0) - _t1478 = 9 + _t1494 = 9 else - _t1478 = -1 + _t1494 = -1 end - _t1477 = _t1478 + _t1493 = _t1494 end - _t1476 = _t1477 + _t1492 = _t1493 end - _t1475 = _t1476 + _t1491 = _t1492 end - _t1474 = _t1475 + _t1490 = _t1491 end - _t1473 = _t1474 + _t1489 = _t1490 end - _t1472 = _t1473 + _t1488 = _t1489 end - _t1471 = _t1472 + _t1487 = _t1488 end - _t1470 = _t1471 + _t1486 = _t1487 end - _t1469 = _t1470 + _t1485 = _t1486 end - _t1468 = _t1469 + _t1484 = _t1485 end - _t1467 = _t1468 + _t1483 = _t1484 end - _t1466 = _t1467 + _t1482 = _t1483 end - _t1465 = _t1466 + _t1481 = _t1482 end - prediction781 = _t1465 - if prediction781 == 13 - _t1480 = parse_uint32_type(parser) - uint32_type795 = _t1480 - _t1481 = Proto.var"#Type"(var"#type"=OneOf(:uint32_type, uint32_type795)) - _t1479 = _t1481 + prediction789 = _t1481 + if prediction789 == 13 + _t1496 = parse_uint32_type(parser) + uint32_type803 = _t1496 + _t1497 = Proto.var"#Type"(var"#type"=OneOf(:uint32_type, uint32_type803)) + _t1495 = _t1497 else - if prediction781 == 12 - _t1483 = parse_float32_type(parser) - float32_type794 = _t1483 - _t1484 = Proto.var"#Type"(var"#type"=OneOf(:float32_type, float32_type794)) - _t1482 = _t1484 + if prediction789 == 12 + _t1499 = parse_float32_type(parser) + float32_type802 = _t1499 + _t1500 = Proto.var"#Type"(var"#type"=OneOf(:float32_type, float32_type802)) + _t1498 = _t1500 else - if prediction781 == 11 - _t1486 = parse_int32_type(parser) - int32_type793 = _t1486 - _t1487 = Proto.var"#Type"(var"#type"=OneOf(:int32_type, int32_type793)) - _t1485 = _t1487 + if prediction789 == 11 + _t1502 = parse_int32_type(parser) + int32_type801 = _t1502 + _t1503 = Proto.var"#Type"(var"#type"=OneOf(:int32_type, int32_type801)) + _t1501 = _t1503 else - if prediction781 == 10 - _t1489 = parse_boolean_type(parser) - boolean_type792 = _t1489 - _t1490 = Proto.var"#Type"(var"#type"=OneOf(:boolean_type, boolean_type792)) - _t1488 = _t1490 + if prediction789 == 10 + _t1505 = parse_boolean_type(parser) + boolean_type800 = _t1505 + _t1506 = Proto.var"#Type"(var"#type"=OneOf(:boolean_type, boolean_type800)) + _t1504 = _t1506 else - if prediction781 == 9 - _t1492 = parse_decimal_type(parser) - decimal_type791 = _t1492 - _t1493 = Proto.var"#Type"(var"#type"=OneOf(:decimal_type, decimal_type791)) - _t1491 = _t1493 + if prediction789 == 9 + _t1508 = parse_decimal_type(parser) + decimal_type799 = _t1508 + _t1509 = Proto.var"#Type"(var"#type"=OneOf(:decimal_type, decimal_type799)) + _t1507 = _t1509 else - if prediction781 == 8 - _t1495 = parse_missing_type(parser) - missing_type790 = _t1495 - _t1496 = Proto.var"#Type"(var"#type"=OneOf(:missing_type, missing_type790)) - _t1494 = _t1496 + if prediction789 == 8 + _t1511 = parse_missing_type(parser) + missing_type798 = _t1511 + _t1512 = Proto.var"#Type"(var"#type"=OneOf(:missing_type, missing_type798)) + _t1510 = _t1512 else - if prediction781 == 7 - _t1498 = parse_datetime_type(parser) - datetime_type789 = _t1498 - _t1499 = Proto.var"#Type"(var"#type"=OneOf(:datetime_type, datetime_type789)) - _t1497 = _t1499 + if prediction789 == 7 + _t1514 = parse_datetime_type(parser) + datetime_type797 = _t1514 + _t1515 = Proto.var"#Type"(var"#type"=OneOf(:datetime_type, datetime_type797)) + _t1513 = _t1515 else - if prediction781 == 6 - _t1501 = parse_date_type(parser) - date_type788 = _t1501 - _t1502 = Proto.var"#Type"(var"#type"=OneOf(:date_type, date_type788)) - _t1500 = _t1502 + if prediction789 == 6 + _t1517 = parse_date_type(parser) + date_type796 = _t1517 + _t1518 = Proto.var"#Type"(var"#type"=OneOf(:date_type, date_type796)) + _t1516 = _t1518 else - if prediction781 == 5 - _t1504 = parse_int128_type(parser) - int128_type787 = _t1504 - _t1505 = Proto.var"#Type"(var"#type"=OneOf(:int128_type, int128_type787)) - _t1503 = _t1505 + if prediction789 == 5 + _t1520 = parse_int128_type(parser) + int128_type795 = _t1520 + _t1521 = Proto.var"#Type"(var"#type"=OneOf(:int128_type, int128_type795)) + _t1519 = _t1521 else - if prediction781 == 4 - _t1507 = parse_uint128_type(parser) - uint128_type786 = _t1507 - _t1508 = Proto.var"#Type"(var"#type"=OneOf(:uint128_type, uint128_type786)) - _t1506 = _t1508 + if prediction789 == 4 + _t1523 = parse_uint128_type(parser) + uint128_type794 = _t1523 + _t1524 = Proto.var"#Type"(var"#type"=OneOf(:uint128_type, uint128_type794)) + _t1522 = _t1524 else - if prediction781 == 3 - _t1510 = parse_float_type(parser) - float_type785 = _t1510 - _t1511 = Proto.var"#Type"(var"#type"=OneOf(:float_type, float_type785)) - _t1509 = _t1511 + if prediction789 == 3 + _t1526 = parse_float_type(parser) + float_type793 = _t1526 + _t1527 = Proto.var"#Type"(var"#type"=OneOf(:float_type, float_type793)) + _t1525 = _t1527 else - if prediction781 == 2 - _t1513 = parse_int_type(parser) - int_type784 = _t1513 - _t1514 = Proto.var"#Type"(var"#type"=OneOf(:int_type, int_type784)) - _t1512 = _t1514 + if prediction789 == 2 + _t1529 = parse_int_type(parser) + int_type792 = _t1529 + _t1530 = Proto.var"#Type"(var"#type"=OneOf(:int_type, int_type792)) + _t1528 = _t1530 else - if prediction781 == 1 - _t1516 = parse_string_type(parser) - string_type783 = _t1516 - _t1517 = Proto.var"#Type"(var"#type"=OneOf(:string_type, string_type783)) - _t1515 = _t1517 + if prediction789 == 1 + _t1532 = parse_string_type(parser) + string_type791 = _t1532 + _t1533 = Proto.var"#Type"(var"#type"=OneOf(:string_type, string_type791)) + _t1531 = _t1533 else - if prediction781 == 0 - _t1519 = parse_unspecified_type(parser) - unspecified_type782 = _t1519 - _t1520 = Proto.var"#Type"(var"#type"=OneOf(:unspecified_type, unspecified_type782)) - _t1518 = _t1520 + if prediction789 == 0 + _t1535 = parse_unspecified_type(parser) + unspecified_type790 = _t1535 + _t1536 = Proto.var"#Type"(var"#type"=OneOf(:unspecified_type, unspecified_type790)) + _t1534 = _t1536 else throw(ParseError("Unexpected token in type" * ": " * string(lookahead(parser, 0)))) end - _t1515 = _t1518 + _t1531 = _t1534 end - _t1512 = _t1515 + _t1528 = _t1531 end - _t1509 = _t1512 + _t1525 = _t1528 end - _t1506 = _t1509 + _t1522 = _t1525 end - _t1503 = _t1506 + _t1519 = _t1522 end - _t1500 = _t1503 + _t1516 = _t1519 end - _t1497 = _t1500 + _t1513 = _t1516 end - _t1494 = _t1497 + _t1510 = _t1513 end - _t1491 = _t1494 + _t1507 = _t1510 end - _t1488 = _t1491 + _t1504 = _t1507 end - _t1485 = _t1488 + _t1501 = _t1504 end - _t1482 = _t1485 + _t1498 = _t1501 end - _t1479 = _t1482 + _t1495 = _t1498 end - result797 = _t1479 - record_span!(parser, span_start796, "Type") - return result797 + result805 = _t1495 + record_span!(parser, span_start804, "Type") + return result805 end function parse_unspecified_type(parser::ParserState)::Proto.UnspecifiedType - span_start798 = span_start(parser) + span_start806 = span_start(parser) consume_literal!(parser, "UNKNOWN") - _t1521 = Proto.UnspecifiedType() - result799 = _t1521 - record_span!(parser, span_start798, "UnspecifiedType") - return result799 + _t1537 = Proto.UnspecifiedType() + result807 = _t1537 + record_span!(parser, span_start806, "UnspecifiedType") + return result807 end function parse_string_type(parser::ParserState)::Proto.StringType - span_start800 = span_start(parser) + span_start808 = span_start(parser) consume_literal!(parser, "STRING") - _t1522 = Proto.StringType() - result801 = _t1522 - record_span!(parser, span_start800, "StringType") - return result801 + _t1538 = Proto.StringType() + result809 = _t1538 + record_span!(parser, span_start808, "StringType") + return result809 end function parse_int_type(parser::ParserState)::Proto.IntType - span_start802 = span_start(parser) + span_start810 = span_start(parser) consume_literal!(parser, "INT") - _t1523 = Proto.IntType() - result803 = _t1523 - record_span!(parser, span_start802, "IntType") - return result803 + _t1539 = Proto.IntType() + result811 = _t1539 + record_span!(parser, span_start810, "IntType") + return result811 end function parse_float_type(parser::ParserState)::Proto.FloatType - span_start804 = span_start(parser) + span_start812 = span_start(parser) consume_literal!(parser, "FLOAT") - _t1524 = Proto.FloatType() - result805 = _t1524 - record_span!(parser, span_start804, "FloatType") - return result805 + _t1540 = Proto.FloatType() + result813 = _t1540 + record_span!(parser, span_start812, "FloatType") + return result813 end function parse_uint128_type(parser::ParserState)::Proto.UInt128Type - span_start806 = span_start(parser) + span_start814 = span_start(parser) consume_literal!(parser, "UINT128") - _t1525 = Proto.UInt128Type() - result807 = _t1525 - record_span!(parser, span_start806, "UInt128Type") - return result807 + _t1541 = Proto.UInt128Type() + result815 = _t1541 + record_span!(parser, span_start814, "UInt128Type") + return result815 end function parse_int128_type(parser::ParserState)::Proto.Int128Type - span_start808 = span_start(parser) + span_start816 = span_start(parser) consume_literal!(parser, "INT128") - _t1526 = Proto.Int128Type() - result809 = _t1526 - record_span!(parser, span_start808, "Int128Type") - return result809 + _t1542 = Proto.Int128Type() + result817 = _t1542 + record_span!(parser, span_start816, "Int128Type") + return result817 end function parse_date_type(parser::ParserState)::Proto.DateType - span_start810 = span_start(parser) + span_start818 = span_start(parser) consume_literal!(parser, "DATE") - _t1527 = Proto.DateType() - result811 = _t1527 - record_span!(parser, span_start810, "DateType") - return result811 + _t1543 = Proto.DateType() + result819 = _t1543 + record_span!(parser, span_start818, "DateType") + return result819 end function parse_datetime_type(parser::ParserState)::Proto.DateTimeType - span_start812 = span_start(parser) + span_start820 = span_start(parser) consume_literal!(parser, "DATETIME") - _t1528 = Proto.DateTimeType() - result813 = _t1528 - record_span!(parser, span_start812, "DateTimeType") - return result813 + _t1544 = Proto.DateTimeType() + result821 = _t1544 + record_span!(parser, span_start820, "DateTimeType") + return result821 end function parse_missing_type(parser::ParserState)::Proto.MissingType - span_start814 = span_start(parser) + span_start822 = span_start(parser) consume_literal!(parser, "MISSING") - _t1529 = Proto.MissingType() - result815 = _t1529 - record_span!(parser, span_start814, "MissingType") - return result815 + _t1545 = Proto.MissingType() + result823 = _t1545 + record_span!(parser, span_start822, "MissingType") + return result823 end function parse_decimal_type(parser::ParserState)::Proto.DecimalType - span_start818 = span_start(parser) + span_start826 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "DECIMAL") - int816 = consume_terminal!(parser, "INT") - int_3817 = consume_terminal!(parser, "INT") + int824 = consume_terminal!(parser, "INT") + int_3825 = consume_terminal!(parser, "INT") consume_literal!(parser, ")") - _t1530 = Proto.DecimalType(precision=Int32(int816), scale=Int32(int_3817)) - result819 = _t1530 - record_span!(parser, span_start818, "DecimalType") - return result819 + _t1546 = Proto.DecimalType(precision=Int32(int824), scale=Int32(int_3825)) + result827 = _t1546 + record_span!(parser, span_start826, "DecimalType") + return result827 end function parse_boolean_type(parser::ParserState)::Proto.BooleanType - span_start820 = span_start(parser) + span_start828 = span_start(parser) consume_literal!(parser, "BOOLEAN") - _t1531 = Proto.BooleanType() - result821 = _t1531 - record_span!(parser, span_start820, "BooleanType") - return result821 + _t1547 = Proto.BooleanType() + result829 = _t1547 + record_span!(parser, span_start828, "BooleanType") + return result829 end function parse_int32_type(parser::ParserState)::Proto.Int32Type - span_start822 = span_start(parser) + span_start830 = span_start(parser) consume_literal!(parser, "INT32") - _t1532 = Proto.Int32Type() - result823 = _t1532 - record_span!(parser, span_start822, "Int32Type") - return result823 + _t1548 = Proto.Int32Type() + result831 = _t1548 + record_span!(parser, span_start830, "Int32Type") + return result831 end function parse_float32_type(parser::ParserState)::Proto.Float32Type - span_start824 = span_start(parser) + span_start832 = span_start(parser) consume_literal!(parser, "FLOAT32") - _t1533 = Proto.Float32Type() - result825 = _t1533 - record_span!(parser, span_start824, "Float32Type") - return result825 + _t1549 = Proto.Float32Type() + result833 = _t1549 + record_span!(parser, span_start832, "Float32Type") + return result833 end function parse_uint32_type(parser::ParserState)::Proto.UInt32Type - span_start826 = span_start(parser) + span_start834 = span_start(parser) consume_literal!(parser, "UINT32") - _t1534 = Proto.UInt32Type() - result827 = _t1534 - record_span!(parser, span_start826, "UInt32Type") - return result827 + _t1550 = Proto.UInt32Type() + result835 = _t1550 + record_span!(parser, span_start834, "UInt32Type") + return result835 end function parse_value_bindings(parser::ParserState)::Vector{Proto.Binding} consume_literal!(parser, "|") - xs828 = Proto.Binding[] - cond829 = match_lookahead_terminal(parser, "SYMBOL", 0) - while cond829 - _t1535 = parse_binding(parser) - item830 = _t1535 - push!(xs828, item830) - cond829 = match_lookahead_terminal(parser, "SYMBOL", 0) + xs836 = Proto.Binding[] + cond837 = match_lookahead_terminal(parser, "SYMBOL", 0) + while cond837 + _t1551 = parse_binding(parser) + item838 = _t1551 + push!(xs836, item838) + cond837 = match_lookahead_terminal(parser, "SYMBOL", 0) end - bindings831 = xs828 - return bindings831 + bindings839 = xs836 + return bindings839 end function parse_formula(parser::ParserState)::Proto.Formula - span_start846 = span_start(parser) + span_start854 = span_start(parser) if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "true", 1) - _t1537 = 0 + _t1553 = 0 else if match_lookahead_literal(parser, "relatom", 1) - _t1538 = 11 + _t1554 = 11 else if match_lookahead_literal(parser, "reduce", 1) - _t1539 = 3 + _t1555 = 3 else if match_lookahead_literal(parser, "primitive", 1) - _t1540 = 10 + _t1556 = 10 else if match_lookahead_literal(parser, "pragma", 1) - _t1541 = 9 + _t1557 = 9 else if match_lookahead_literal(parser, "or", 1) - _t1542 = 5 + _t1558 = 5 else if match_lookahead_literal(parser, "not", 1) - _t1543 = 6 + _t1559 = 6 else if match_lookahead_literal(parser, "ffi", 1) - _t1544 = 7 + _t1560 = 7 else if match_lookahead_literal(parser, "false", 1) - _t1545 = 1 + _t1561 = 1 else if match_lookahead_literal(parser, "exists", 1) - _t1546 = 2 + _t1562 = 2 else if match_lookahead_literal(parser, "cast", 1) - _t1547 = 12 + _t1563 = 12 else if match_lookahead_literal(parser, "atom", 1) - _t1548 = 8 + _t1564 = 8 else if match_lookahead_literal(parser, "and", 1) - _t1549 = 4 + _t1565 = 4 else if match_lookahead_literal(parser, ">=", 1) - _t1550 = 10 + _t1566 = 10 else if match_lookahead_literal(parser, ">", 1) - _t1551 = 10 + _t1567 = 10 else if match_lookahead_literal(parser, "=", 1) - _t1552 = 10 + _t1568 = 10 else if match_lookahead_literal(parser, "<=", 1) - _t1553 = 10 + _t1569 = 10 else if match_lookahead_literal(parser, "<", 1) - _t1554 = 10 + _t1570 = 10 else if match_lookahead_literal(parser, "/", 1) - _t1555 = 10 + _t1571 = 10 else if match_lookahead_literal(parser, "-", 1) - _t1556 = 10 + _t1572 = 10 else if match_lookahead_literal(parser, "+", 1) - _t1557 = 10 + _t1573 = 10 else if match_lookahead_literal(parser, "*", 1) - _t1558 = 10 + _t1574 = 10 else - _t1558 = -1 + _t1574 = -1 end - _t1557 = _t1558 + _t1573 = _t1574 end - _t1556 = _t1557 + _t1572 = _t1573 end - _t1555 = _t1556 + _t1571 = _t1572 end - _t1554 = _t1555 + _t1570 = _t1571 end - _t1553 = _t1554 + _t1569 = _t1570 end - _t1552 = _t1553 + _t1568 = _t1569 end - _t1551 = _t1552 + _t1567 = _t1568 end - _t1550 = _t1551 + _t1566 = _t1567 end - _t1549 = _t1550 + _t1565 = _t1566 end - _t1548 = _t1549 + _t1564 = _t1565 end - _t1547 = _t1548 + _t1563 = _t1564 end - _t1546 = _t1547 + _t1562 = _t1563 end - _t1545 = _t1546 + _t1561 = _t1562 end - _t1544 = _t1545 + _t1560 = _t1561 end - _t1543 = _t1544 + _t1559 = _t1560 end - _t1542 = _t1543 + _t1558 = _t1559 end - _t1541 = _t1542 + _t1557 = _t1558 end - _t1540 = _t1541 + _t1556 = _t1557 end - _t1539 = _t1540 + _t1555 = _t1556 end - _t1538 = _t1539 + _t1554 = _t1555 end - _t1537 = _t1538 + _t1553 = _t1554 end - _t1536 = _t1537 + _t1552 = _t1553 else - _t1536 = -1 + _t1552 = -1 end - prediction832 = _t1536 - if prediction832 == 12 - _t1560 = parse_cast(parser) - cast845 = _t1560 - _t1561 = Proto.Formula(formula_type=OneOf(:cast, cast845)) - _t1559 = _t1561 + prediction840 = _t1552 + if prediction840 == 12 + _t1576 = parse_cast(parser) + cast853 = _t1576 + _t1577 = Proto.Formula(formula_type=OneOf(:cast, cast853)) + _t1575 = _t1577 else - if prediction832 == 11 - _t1563 = parse_rel_atom(parser) - rel_atom844 = _t1563 - _t1564 = Proto.Formula(formula_type=OneOf(:rel_atom, rel_atom844)) - _t1562 = _t1564 + if prediction840 == 11 + _t1579 = parse_rel_atom(parser) + rel_atom852 = _t1579 + _t1580 = Proto.Formula(formula_type=OneOf(:rel_atom, rel_atom852)) + _t1578 = _t1580 else - if prediction832 == 10 - _t1566 = parse_primitive(parser) - primitive843 = _t1566 - _t1567 = Proto.Formula(formula_type=OneOf(:primitive, primitive843)) - _t1565 = _t1567 + if prediction840 == 10 + _t1582 = parse_primitive(parser) + primitive851 = _t1582 + _t1583 = Proto.Formula(formula_type=OneOf(:primitive, primitive851)) + _t1581 = _t1583 else - if prediction832 == 9 - _t1569 = parse_pragma(parser) - pragma842 = _t1569 - _t1570 = Proto.Formula(formula_type=OneOf(:pragma, pragma842)) - _t1568 = _t1570 + if prediction840 == 9 + _t1585 = parse_pragma(parser) + pragma850 = _t1585 + _t1586 = Proto.Formula(formula_type=OneOf(:pragma, pragma850)) + _t1584 = _t1586 else - if prediction832 == 8 - _t1572 = parse_atom(parser) - atom841 = _t1572 - _t1573 = Proto.Formula(formula_type=OneOf(:atom, atom841)) - _t1571 = _t1573 + if prediction840 == 8 + _t1588 = parse_atom(parser) + atom849 = _t1588 + _t1589 = Proto.Formula(formula_type=OneOf(:atom, atom849)) + _t1587 = _t1589 else - if prediction832 == 7 - _t1575 = parse_ffi(parser) - ffi840 = _t1575 - _t1576 = Proto.Formula(formula_type=OneOf(:ffi, ffi840)) - _t1574 = _t1576 + if prediction840 == 7 + _t1591 = parse_ffi(parser) + ffi848 = _t1591 + _t1592 = Proto.Formula(formula_type=OneOf(:ffi, ffi848)) + _t1590 = _t1592 else - if prediction832 == 6 - _t1578 = parse_not(parser) - not839 = _t1578 - _t1579 = Proto.Formula(formula_type=OneOf(:not, not839)) - _t1577 = _t1579 + if prediction840 == 6 + _t1594 = parse_not(parser) + not847 = _t1594 + _t1595 = Proto.Formula(formula_type=OneOf(:not, not847)) + _t1593 = _t1595 else - if prediction832 == 5 - _t1581 = parse_disjunction(parser) - disjunction838 = _t1581 - _t1582 = Proto.Formula(formula_type=OneOf(:disjunction, disjunction838)) - _t1580 = _t1582 + if prediction840 == 5 + _t1597 = parse_disjunction(parser) + disjunction846 = _t1597 + _t1598 = Proto.Formula(formula_type=OneOf(:disjunction, disjunction846)) + _t1596 = _t1598 else - if prediction832 == 4 - _t1584 = parse_conjunction(parser) - conjunction837 = _t1584 - _t1585 = Proto.Formula(formula_type=OneOf(:conjunction, conjunction837)) - _t1583 = _t1585 + if prediction840 == 4 + _t1600 = parse_conjunction(parser) + conjunction845 = _t1600 + _t1601 = Proto.Formula(formula_type=OneOf(:conjunction, conjunction845)) + _t1599 = _t1601 else - if prediction832 == 3 - _t1587 = parse_reduce(parser) - reduce836 = _t1587 - _t1588 = Proto.Formula(formula_type=OneOf(:reduce, reduce836)) - _t1586 = _t1588 + if prediction840 == 3 + _t1603 = parse_reduce(parser) + reduce844 = _t1603 + _t1604 = Proto.Formula(formula_type=OneOf(:reduce, reduce844)) + _t1602 = _t1604 else - if prediction832 == 2 - _t1590 = parse_exists(parser) - exists835 = _t1590 - _t1591 = Proto.Formula(formula_type=OneOf(:exists, exists835)) - _t1589 = _t1591 + if prediction840 == 2 + _t1606 = parse_exists(parser) + exists843 = _t1606 + _t1607 = Proto.Formula(formula_type=OneOf(:exists, exists843)) + _t1605 = _t1607 else - if prediction832 == 1 - _t1593 = parse_false(parser) - false834 = _t1593 - _t1594 = Proto.Formula(formula_type=OneOf(:disjunction, false834)) - _t1592 = _t1594 + if prediction840 == 1 + _t1609 = parse_false(parser) + false842 = _t1609 + _t1610 = Proto.Formula(formula_type=OneOf(:disjunction, false842)) + _t1608 = _t1610 else - if prediction832 == 0 - _t1596 = parse_true(parser) - true833 = _t1596 - _t1597 = Proto.Formula(formula_type=OneOf(:conjunction, true833)) - _t1595 = _t1597 + if prediction840 == 0 + _t1612 = parse_true(parser) + true841 = _t1612 + _t1613 = Proto.Formula(formula_type=OneOf(:conjunction, true841)) + _t1611 = _t1613 else throw(ParseError("Unexpected token in formula" * ": " * string(lookahead(parser, 0)))) end - _t1592 = _t1595 + _t1608 = _t1611 end - _t1589 = _t1592 + _t1605 = _t1608 end - _t1586 = _t1589 + _t1602 = _t1605 end - _t1583 = _t1586 + _t1599 = _t1602 end - _t1580 = _t1583 + _t1596 = _t1599 end - _t1577 = _t1580 + _t1593 = _t1596 end - _t1574 = _t1577 + _t1590 = _t1593 end - _t1571 = _t1574 + _t1587 = _t1590 end - _t1568 = _t1571 + _t1584 = _t1587 end - _t1565 = _t1568 + _t1581 = _t1584 end - _t1562 = _t1565 + _t1578 = _t1581 end - _t1559 = _t1562 + _t1575 = _t1578 end - result847 = _t1559 - record_span!(parser, span_start846, "Formula") - return result847 + result855 = _t1575 + record_span!(parser, span_start854, "Formula") + return result855 end function parse_true(parser::ParserState)::Proto.Conjunction - span_start848 = span_start(parser) + span_start856 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "true") consume_literal!(parser, ")") - _t1598 = Proto.Conjunction(args=Proto.Formula[]) - result849 = _t1598 - record_span!(parser, span_start848, "Conjunction") - return result849 + _t1614 = Proto.Conjunction(args=Proto.Formula[]) + result857 = _t1614 + record_span!(parser, span_start856, "Conjunction") + return result857 end function parse_false(parser::ParserState)::Proto.Disjunction - span_start850 = span_start(parser) + span_start858 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "false") consume_literal!(parser, ")") - _t1599 = Proto.Disjunction(args=Proto.Formula[]) - result851 = _t1599 - record_span!(parser, span_start850, "Disjunction") - return result851 + _t1615 = Proto.Disjunction(args=Proto.Formula[]) + result859 = _t1615 + record_span!(parser, span_start858, "Disjunction") + return result859 end function parse_exists(parser::ParserState)::Proto.Exists - span_start854 = span_start(parser) + span_start862 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "exists") - _t1600 = parse_bindings(parser) - bindings852 = _t1600 - _t1601 = parse_formula(parser) - formula853 = _t1601 + _t1616 = parse_bindings(parser) + bindings860 = _t1616 + _t1617 = parse_formula(parser) + formula861 = _t1617 consume_literal!(parser, ")") - _t1602 = Proto.Abstraction(vars=vcat(bindings852[1], !isnothing(bindings852[2]) ? bindings852[2] : []), value=formula853) - _t1603 = Proto.Exists(body=_t1602) - result855 = _t1603 - record_span!(parser, span_start854, "Exists") - return result855 + _t1618 = Proto.Abstraction(vars=vcat(bindings860[1], !isnothing(bindings860[2]) ? bindings860[2] : []), value=formula861) + _t1619 = Proto.Exists(body=_t1618) + result863 = _t1619 + record_span!(parser, span_start862, "Exists") + return result863 end function parse_reduce(parser::ParserState)::Proto.Reduce - span_start859 = span_start(parser) + span_start867 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "reduce") - _t1604 = parse_abstraction(parser) - abstraction856 = _t1604 - _t1605 = parse_abstraction(parser) - abstraction_3857 = _t1605 - _t1606 = parse_terms(parser) - terms858 = _t1606 + _t1620 = parse_abstraction(parser) + abstraction864 = _t1620 + _t1621 = parse_abstraction(parser) + abstraction_3865 = _t1621 + _t1622 = parse_terms(parser) + terms866 = _t1622 consume_literal!(parser, ")") - _t1607 = Proto.Reduce(op=abstraction856, body=abstraction_3857, terms=terms858) - result860 = _t1607 - record_span!(parser, span_start859, "Reduce") - return result860 + _t1623 = Proto.Reduce(op=abstraction864, body=abstraction_3865, terms=terms866) + result868 = _t1623 + record_span!(parser, span_start867, "Reduce") + return result868 end function parse_terms(parser::ParserState)::Vector{Proto.Term} consume_literal!(parser, "(") consume_literal!(parser, "terms") - xs861 = Proto.Term[] - cond862 = (((((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "false", 0)) || match_lookahead_literal(parser, "missing", 0)) || match_lookahead_literal(parser, "true", 0)) || match_lookahead_terminal(parser, "DECIMAL", 0)) || match_lookahead_terminal(parser, "FLOAT", 0)) || match_lookahead_terminal(parser, "FLOAT32", 0)) || match_lookahead_terminal(parser, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "INT32", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) || match_lookahead_terminal(parser, "UINT32", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) - while cond862 - _t1608 = parse_term(parser) - item863 = _t1608 - push!(xs861, item863) - cond862 = (((((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "false", 0)) || match_lookahead_literal(parser, "missing", 0)) || match_lookahead_literal(parser, "true", 0)) || match_lookahead_terminal(parser, "DECIMAL", 0)) || match_lookahead_terminal(parser, "FLOAT", 0)) || match_lookahead_terminal(parser, "FLOAT32", 0)) || match_lookahead_terminal(parser, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "INT32", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) || match_lookahead_terminal(parser, "UINT32", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) + xs869 = Proto.Term[] + cond870 = (((((((((((((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 cond870 + _t1624 = parse_term(parser) + item871 = _t1624 + push!(xs869, item871) + cond870 = (((((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "false", 0)) || match_lookahead_literal(parser, "missing", 0)) || match_lookahead_literal(parser, "true", 0)) || match_lookahead_terminal(parser, "DECIMAL", 0)) || match_lookahead_terminal(parser, "FLOAT", 0)) || match_lookahead_terminal(parser, "FLOAT32", 0)) || match_lookahead_terminal(parser, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "INT32", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) || match_lookahead_terminal(parser, "UINT32", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) end - terms864 = xs861 + terms872 = xs869 consume_literal!(parser, ")") - return terms864 + return terms872 end function parse_term(parser::ParserState)::Proto.Term - span_start868 = span_start(parser) + span_start876 = span_start(parser) if match_lookahead_literal(parser, "true", 0) - _t1609 = 1 + _t1625 = 1 else if match_lookahead_literal(parser, "missing", 0) - _t1610 = 1 + _t1626 = 1 else if match_lookahead_literal(parser, "false", 0) - _t1611 = 1 + _t1627 = 1 else if match_lookahead_literal(parser, "(", 0) - _t1612 = 1 + _t1628 = 1 else if match_lookahead_terminal(parser, "SYMBOL", 0) - _t1613 = 0 + _t1629 = 0 else if match_lookahead_terminal(parser, "UINT32", 0) - _t1614 = 1 + _t1630 = 1 else if match_lookahead_terminal(parser, "UINT128", 0) - _t1615 = 1 + _t1631 = 1 else if match_lookahead_terminal(parser, "STRING", 0) - _t1616 = 1 + _t1632 = 1 else if match_lookahead_terminal(parser, "INT32", 0) - _t1617 = 1 + _t1633 = 1 else if match_lookahead_terminal(parser, "INT128", 0) - _t1618 = 1 + _t1634 = 1 else if match_lookahead_terminal(parser, "INT", 0) - _t1619 = 1 + _t1635 = 1 else if match_lookahead_terminal(parser, "FLOAT32", 0) - _t1620 = 1 + _t1636 = 1 else if match_lookahead_terminal(parser, "FLOAT", 0) - _t1621 = 1 + _t1637 = 1 else if match_lookahead_terminal(parser, "DECIMAL", 0) - _t1622 = 1 + _t1638 = 1 else - _t1622 = -1 + _t1638 = -1 end - _t1621 = _t1622 + _t1637 = _t1638 end - _t1620 = _t1621 + _t1636 = _t1637 end - _t1619 = _t1620 + _t1635 = _t1636 end - _t1618 = _t1619 + _t1634 = _t1635 end - _t1617 = _t1618 + _t1633 = _t1634 end - _t1616 = _t1617 + _t1632 = _t1633 end - _t1615 = _t1616 + _t1631 = _t1632 end - _t1614 = _t1615 + _t1630 = _t1631 end - _t1613 = _t1614 + _t1629 = _t1630 end - _t1612 = _t1613 + _t1628 = _t1629 end - _t1611 = _t1612 + _t1627 = _t1628 end - _t1610 = _t1611 + _t1626 = _t1627 end - _t1609 = _t1610 + _t1625 = _t1626 end - prediction865 = _t1609 - if prediction865 == 1 - _t1624 = parse_value(parser) - value867 = _t1624 - _t1625 = Proto.Term(term_type=OneOf(:constant, value867)) - _t1623 = _t1625 + prediction873 = _t1625 + if prediction873 == 1 + _t1640 = parse_value(parser) + value875 = _t1640 + _t1641 = Proto.Term(term_type=OneOf(:constant, value875)) + _t1639 = _t1641 else - if prediction865 == 0 - _t1627 = parse_var(parser) - var866 = _t1627 - _t1628 = Proto.Term(term_type=OneOf(:var, var866)) - _t1626 = _t1628 + if prediction873 == 0 + _t1643 = parse_var(parser) + var874 = _t1643 + _t1644 = Proto.Term(term_type=OneOf(:var, var874)) + _t1642 = _t1644 else throw(ParseError("Unexpected token in term" * ": " * string(lookahead(parser, 0)))) end - _t1623 = _t1626 + _t1639 = _t1642 end - result869 = _t1623 - record_span!(parser, span_start868, "Term") - return result869 + result877 = _t1639 + record_span!(parser, span_start876, "Term") + return result877 end function parse_var(parser::ParserState)::Proto.Var - span_start871 = span_start(parser) - symbol870 = consume_terminal!(parser, "SYMBOL") - _t1629 = Proto.Var(name=symbol870) - result872 = _t1629 - record_span!(parser, span_start871, "Var") - return result872 + span_start879 = span_start(parser) + symbol878 = consume_terminal!(parser, "SYMBOL") + _t1645 = Proto.Var(name=symbol878) + result880 = _t1645 + record_span!(parser, span_start879, "Var") + return result880 end function parse_value(parser::ParserState)::Proto.Value - span_start886 = span_start(parser) + span_start894 = span_start(parser) if match_lookahead_literal(parser, "true", 0) - _t1630 = 12 + _t1646 = 12 else if match_lookahead_literal(parser, "missing", 0) - _t1631 = 11 + _t1647 = 11 else if match_lookahead_literal(parser, "false", 0) - _t1632 = 12 + _t1648 = 12 else if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "datetime", 1) - _t1634 = 1 + _t1650 = 1 else if match_lookahead_literal(parser, "date", 1) - _t1635 = 0 + _t1651 = 0 else - _t1635 = -1 + _t1651 = -1 end - _t1634 = _t1635 + _t1650 = _t1651 end - _t1633 = _t1634 + _t1649 = _t1650 else if match_lookahead_terminal(parser, "UINT32", 0) - _t1636 = 7 + _t1652 = 7 else if match_lookahead_terminal(parser, "UINT128", 0) - _t1637 = 8 + _t1653 = 8 else if match_lookahead_terminal(parser, "STRING", 0) - _t1638 = 2 + _t1654 = 2 else if match_lookahead_terminal(parser, "INT32", 0) - _t1639 = 3 + _t1655 = 3 else if match_lookahead_terminal(parser, "INT128", 0) - _t1640 = 9 + _t1656 = 9 else if match_lookahead_terminal(parser, "INT", 0) - _t1641 = 4 + _t1657 = 4 else if match_lookahead_terminal(parser, "FLOAT32", 0) - _t1642 = 5 + _t1658 = 5 else if match_lookahead_terminal(parser, "FLOAT", 0) - _t1643 = 6 + _t1659 = 6 else if match_lookahead_terminal(parser, "DECIMAL", 0) - _t1644 = 10 + _t1660 = 10 else - _t1644 = -1 + _t1660 = -1 end - _t1643 = _t1644 + _t1659 = _t1660 end - _t1642 = _t1643 + _t1658 = _t1659 end - _t1641 = _t1642 + _t1657 = _t1658 end - _t1640 = _t1641 + _t1656 = _t1657 end - _t1639 = _t1640 + _t1655 = _t1656 end - _t1638 = _t1639 + _t1654 = _t1655 end - _t1637 = _t1638 + _t1653 = _t1654 end - _t1636 = _t1637 + _t1652 = _t1653 end - _t1633 = _t1636 + _t1649 = _t1652 end - _t1632 = _t1633 + _t1648 = _t1649 end - _t1631 = _t1632 + _t1647 = _t1648 end - _t1630 = _t1631 + _t1646 = _t1647 end - prediction873 = _t1630 - if prediction873 == 12 - _t1646 = parse_boolean_value(parser) - boolean_value885 = _t1646 - _t1647 = Proto.Value(value=OneOf(:boolean_value, boolean_value885)) - _t1645 = _t1647 + prediction881 = _t1646 + if prediction881 == 12 + _t1662 = parse_boolean_value(parser) + boolean_value893 = _t1662 + _t1663 = Proto.Value(value=OneOf(:boolean_value, boolean_value893)) + _t1661 = _t1663 else - if prediction873 == 11 + if prediction881 == 11 consume_literal!(parser, "missing") - _t1649 = Proto.MissingValue() - _t1650 = Proto.Value(value=OneOf(:missing_value, _t1649)) - _t1648 = _t1650 + _t1665 = Proto.MissingValue() + _t1666 = Proto.Value(value=OneOf(:missing_value, _t1665)) + _t1664 = _t1666 else - if prediction873 == 10 - formatted_decimal884 = consume_terminal!(parser, "DECIMAL") - _t1652 = Proto.Value(value=OneOf(:decimal_value, formatted_decimal884)) - _t1651 = _t1652 + if prediction881 == 10 + formatted_decimal892 = consume_terminal!(parser, "DECIMAL") + _t1668 = Proto.Value(value=OneOf(:decimal_value, formatted_decimal892)) + _t1667 = _t1668 else - if prediction873 == 9 - formatted_int128883 = consume_terminal!(parser, "INT128") - _t1654 = Proto.Value(value=OneOf(:int128_value, formatted_int128883)) - _t1653 = _t1654 + if prediction881 == 9 + formatted_int128891 = consume_terminal!(parser, "INT128") + _t1670 = Proto.Value(value=OneOf(:int128_value, formatted_int128891)) + _t1669 = _t1670 else - if prediction873 == 8 - formatted_uint128882 = consume_terminal!(parser, "UINT128") - _t1656 = Proto.Value(value=OneOf(:uint128_value, formatted_uint128882)) - _t1655 = _t1656 + if prediction881 == 8 + formatted_uint128890 = consume_terminal!(parser, "UINT128") + _t1672 = Proto.Value(value=OneOf(:uint128_value, formatted_uint128890)) + _t1671 = _t1672 else - if prediction873 == 7 - formatted_uint32881 = consume_terminal!(parser, "UINT32") - _t1658 = Proto.Value(value=OneOf(:uint32_value, formatted_uint32881)) - _t1657 = _t1658 + if prediction881 == 7 + formatted_uint32889 = consume_terminal!(parser, "UINT32") + _t1674 = Proto.Value(value=OneOf(:uint32_value, formatted_uint32889)) + _t1673 = _t1674 else - if prediction873 == 6 - formatted_float880 = consume_terminal!(parser, "FLOAT") - _t1660 = Proto.Value(value=OneOf(:float_value, formatted_float880)) - _t1659 = _t1660 + if prediction881 == 6 + formatted_float888 = consume_terminal!(parser, "FLOAT") + _t1676 = Proto.Value(value=OneOf(:float_value, formatted_float888)) + _t1675 = _t1676 else - if prediction873 == 5 - formatted_float32879 = consume_terminal!(parser, "FLOAT32") - _t1662 = Proto.Value(value=OneOf(:float32_value, formatted_float32879)) - _t1661 = _t1662 + if prediction881 == 5 + formatted_float32887 = consume_terminal!(parser, "FLOAT32") + _t1678 = Proto.Value(value=OneOf(:float32_value, formatted_float32887)) + _t1677 = _t1678 else - if prediction873 == 4 - formatted_int878 = consume_terminal!(parser, "INT") - _t1664 = Proto.Value(value=OneOf(:int_value, formatted_int878)) - _t1663 = _t1664 + if prediction881 == 4 + formatted_int886 = consume_terminal!(parser, "INT") + _t1680 = Proto.Value(value=OneOf(:int_value, formatted_int886)) + _t1679 = _t1680 else - if prediction873 == 3 - formatted_int32877 = consume_terminal!(parser, "INT32") - _t1666 = Proto.Value(value=OneOf(:int32_value, formatted_int32877)) - _t1665 = _t1666 + if prediction881 == 3 + formatted_int32885 = consume_terminal!(parser, "INT32") + _t1682 = Proto.Value(value=OneOf(:int32_value, formatted_int32885)) + _t1681 = _t1682 else - if prediction873 == 2 - formatted_string876 = consume_terminal!(parser, "STRING") - _t1668 = Proto.Value(value=OneOf(:string_value, formatted_string876)) - _t1667 = _t1668 + if prediction881 == 2 + formatted_string884 = consume_terminal!(parser, "STRING") + _t1684 = Proto.Value(value=OneOf(:string_value, formatted_string884)) + _t1683 = _t1684 else - if prediction873 == 1 - _t1670 = parse_datetime(parser) - datetime875 = _t1670 - _t1671 = Proto.Value(value=OneOf(:datetime_value, datetime875)) - _t1669 = _t1671 + if prediction881 == 1 + _t1686 = parse_datetime(parser) + datetime883 = _t1686 + _t1687 = Proto.Value(value=OneOf(:datetime_value, datetime883)) + _t1685 = _t1687 else - if prediction873 == 0 - _t1673 = parse_date(parser) - date874 = _t1673 - _t1674 = Proto.Value(value=OneOf(:date_value, date874)) - _t1672 = _t1674 + if prediction881 == 0 + _t1689 = parse_date(parser) + date882 = _t1689 + _t1690 = Proto.Value(value=OneOf(:date_value, date882)) + _t1688 = _t1690 else throw(ParseError("Unexpected token in value" * ": " * string(lookahead(parser, 0)))) end - _t1669 = _t1672 + _t1685 = _t1688 end - _t1667 = _t1669 + _t1683 = _t1685 end - _t1665 = _t1667 + _t1681 = _t1683 end - _t1663 = _t1665 + _t1679 = _t1681 end - _t1661 = _t1663 + _t1677 = _t1679 end - _t1659 = _t1661 + _t1675 = _t1677 end - _t1657 = _t1659 + _t1673 = _t1675 end - _t1655 = _t1657 + _t1671 = _t1673 end - _t1653 = _t1655 + _t1669 = _t1671 end - _t1651 = _t1653 + _t1667 = _t1669 end - _t1648 = _t1651 + _t1664 = _t1667 end - _t1645 = _t1648 + _t1661 = _t1664 end - result887 = _t1645 - record_span!(parser, span_start886, "Value") - return result887 + result895 = _t1661 + record_span!(parser, span_start894, "Value") + return result895 end function parse_date(parser::ParserState)::Proto.DateValue - span_start891 = span_start(parser) + span_start899 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "date") - formatted_int888 = consume_terminal!(parser, "INT") - formatted_int_3889 = consume_terminal!(parser, "INT") - formatted_int_4890 = consume_terminal!(parser, "INT") + formatted_int896 = consume_terminal!(parser, "INT") + formatted_int_3897 = consume_terminal!(parser, "INT") + formatted_int_4898 = consume_terminal!(parser, "INT") consume_literal!(parser, ")") - _t1675 = Proto.DateValue(year=Int32(formatted_int888), month=Int32(formatted_int_3889), day=Int32(formatted_int_4890)) - result892 = _t1675 - record_span!(parser, span_start891, "DateValue") - return result892 + _t1691 = Proto.DateValue(year=Int32(formatted_int896), month=Int32(formatted_int_3897), day=Int32(formatted_int_4898)) + result900 = _t1691 + record_span!(parser, span_start899, "DateValue") + return result900 end function parse_datetime(parser::ParserState)::Proto.DateTimeValue - span_start900 = span_start(parser) + span_start908 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "datetime") - formatted_int893 = consume_terminal!(parser, "INT") - formatted_int_3894 = consume_terminal!(parser, "INT") - formatted_int_4895 = consume_terminal!(parser, "INT") - formatted_int_5896 = consume_terminal!(parser, "INT") - formatted_int_6897 = consume_terminal!(parser, "INT") - formatted_int_7898 = consume_terminal!(parser, "INT") + formatted_int901 = consume_terminal!(parser, "INT") + formatted_int_3902 = consume_terminal!(parser, "INT") + formatted_int_4903 = consume_terminal!(parser, "INT") + formatted_int_5904 = consume_terminal!(parser, "INT") + formatted_int_6905 = consume_terminal!(parser, "INT") + formatted_int_7906 = consume_terminal!(parser, "INT") if match_lookahead_terminal(parser, "INT", 0) - _t1676 = consume_terminal!(parser, "INT") + _t1692 = consume_terminal!(parser, "INT") else - _t1676 = nothing + _t1692 = nothing end - formatted_int_8899 = _t1676 + formatted_int_8907 = _t1692 consume_literal!(parser, ")") - _t1677 = Proto.DateTimeValue(year=Int32(formatted_int893), month=Int32(formatted_int_3894), day=Int32(formatted_int_4895), hour=Int32(formatted_int_5896), minute=Int32(formatted_int_6897), second=Int32(formatted_int_7898), microsecond=Int32((!isnothing(formatted_int_8899) ? formatted_int_8899 : 0))) - result901 = _t1677 - record_span!(parser, span_start900, "DateTimeValue") - return result901 + _t1693 = Proto.DateTimeValue(year=Int32(formatted_int901), month=Int32(formatted_int_3902), day=Int32(formatted_int_4903), hour=Int32(formatted_int_5904), minute=Int32(formatted_int_6905), second=Int32(formatted_int_7906), microsecond=Int32((!isnothing(formatted_int_8907) ? formatted_int_8907 : 0))) + result909 = _t1693 + record_span!(parser, span_start908, "DateTimeValue") + return result909 end function parse_conjunction(parser::ParserState)::Proto.Conjunction - span_start906 = span_start(parser) + span_start914 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "and") - xs902 = Proto.Formula[] - cond903 = match_lookahead_literal(parser, "(", 0) - while cond903 - _t1678 = parse_formula(parser) - item904 = _t1678 - push!(xs902, item904) - cond903 = match_lookahead_literal(parser, "(", 0) + xs910 = Proto.Formula[] + cond911 = match_lookahead_literal(parser, "(", 0) + while cond911 + _t1694 = parse_formula(parser) + item912 = _t1694 + push!(xs910, item912) + cond911 = match_lookahead_literal(parser, "(", 0) end - formulas905 = xs902 + formulas913 = xs910 consume_literal!(parser, ")") - _t1679 = Proto.Conjunction(args=formulas905) - result907 = _t1679 - record_span!(parser, span_start906, "Conjunction") - return result907 + _t1695 = Proto.Conjunction(args=formulas913) + result915 = _t1695 + record_span!(parser, span_start914, "Conjunction") + return result915 end function parse_disjunction(parser::ParserState)::Proto.Disjunction - span_start912 = span_start(parser) + span_start920 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "or") - xs908 = Proto.Formula[] - cond909 = match_lookahead_literal(parser, "(", 0) - while cond909 - _t1680 = parse_formula(parser) - item910 = _t1680 - push!(xs908, item910) - cond909 = match_lookahead_literal(parser, "(", 0) + xs916 = Proto.Formula[] + cond917 = match_lookahead_literal(parser, "(", 0) + while cond917 + _t1696 = parse_formula(parser) + item918 = _t1696 + push!(xs916, item918) + cond917 = match_lookahead_literal(parser, "(", 0) end - formulas911 = xs908 + formulas919 = xs916 consume_literal!(parser, ")") - _t1681 = Proto.Disjunction(args=formulas911) - result913 = _t1681 - record_span!(parser, span_start912, "Disjunction") - return result913 + _t1697 = Proto.Disjunction(args=formulas919) + result921 = _t1697 + record_span!(parser, span_start920, "Disjunction") + return result921 end function parse_not(parser::ParserState)::Proto.Not - span_start915 = span_start(parser) + span_start923 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "not") - _t1682 = parse_formula(parser) - formula914 = _t1682 + _t1698 = parse_formula(parser) + formula922 = _t1698 consume_literal!(parser, ")") - _t1683 = Proto.Not(arg=formula914) - result916 = _t1683 - record_span!(parser, span_start915, "Not") - return result916 + _t1699 = Proto.Not(arg=formula922) + result924 = _t1699 + record_span!(parser, span_start923, "Not") + return result924 end function parse_ffi(parser::ParserState)::Proto.FFI - span_start920 = span_start(parser) + span_start928 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "ffi") - _t1684 = parse_name(parser) - name917 = _t1684 - _t1685 = parse_ffi_args(parser) - ffi_args918 = _t1685 - _t1686 = parse_terms(parser) - terms919 = _t1686 + _t1700 = parse_name(parser) + name925 = _t1700 + _t1701 = parse_ffi_args(parser) + ffi_args926 = _t1701 + _t1702 = parse_terms(parser) + terms927 = _t1702 consume_literal!(parser, ")") - _t1687 = Proto.FFI(name=name917, args=ffi_args918, terms=terms919) - result921 = _t1687 - record_span!(parser, span_start920, "FFI") - return result921 + _t1703 = Proto.FFI(name=name925, args=ffi_args926, terms=terms927) + result929 = _t1703 + record_span!(parser, span_start928, "FFI") + return result929 end function parse_name(parser::ParserState)::String consume_literal!(parser, ":") - symbol922 = consume_terminal!(parser, "SYMBOL") - return symbol922 + symbol930 = consume_terminal!(parser, "SYMBOL") + return symbol930 end function parse_ffi_args(parser::ParserState)::Vector{Proto.Abstraction} consume_literal!(parser, "(") consume_literal!(parser, "args") - xs923 = Proto.Abstraction[] - cond924 = match_lookahead_literal(parser, "(", 0) - while cond924 - _t1688 = parse_abstraction(parser) - item925 = _t1688 - push!(xs923, item925) - cond924 = match_lookahead_literal(parser, "(", 0) + xs931 = Proto.Abstraction[] + cond932 = match_lookahead_literal(parser, "(", 0) + while cond932 + _t1704 = parse_abstraction(parser) + item933 = _t1704 + push!(xs931, item933) + cond932 = match_lookahead_literal(parser, "(", 0) end - abstractions926 = xs923 + abstractions934 = xs931 consume_literal!(parser, ")") - return abstractions926 + return abstractions934 end function parse_atom(parser::ParserState)::Proto.Atom - span_start932 = span_start(parser) + span_start940 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "atom") - _t1689 = parse_relation_id(parser) - relation_id927 = _t1689 - xs928 = Proto.Term[] - cond929 = (((((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "false", 0)) || match_lookahead_literal(parser, "missing", 0)) || match_lookahead_literal(parser, "true", 0)) || match_lookahead_terminal(parser, "DECIMAL", 0)) || match_lookahead_terminal(parser, "FLOAT", 0)) || match_lookahead_terminal(parser, "FLOAT32", 0)) || match_lookahead_terminal(parser, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "INT32", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) || match_lookahead_terminal(parser, "UINT32", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) - while cond929 - _t1690 = parse_term(parser) - item930 = _t1690 - push!(xs928, item930) - cond929 = (((((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "false", 0)) || match_lookahead_literal(parser, "missing", 0)) || match_lookahead_literal(parser, "true", 0)) || match_lookahead_terminal(parser, "DECIMAL", 0)) || match_lookahead_terminal(parser, "FLOAT", 0)) || match_lookahead_terminal(parser, "FLOAT32", 0)) || match_lookahead_terminal(parser, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "INT32", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) || match_lookahead_terminal(parser, "UINT32", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) + _t1705 = parse_relation_id(parser) + relation_id935 = _t1705 + xs936 = Proto.Term[] + cond937 = (((((((((((((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 cond937 + _t1706 = parse_term(parser) + item938 = _t1706 + push!(xs936, item938) + cond937 = (((((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "false", 0)) || match_lookahead_literal(parser, "missing", 0)) || match_lookahead_literal(parser, "true", 0)) || match_lookahead_terminal(parser, "DECIMAL", 0)) || match_lookahead_terminal(parser, "FLOAT", 0)) || match_lookahead_terminal(parser, "FLOAT32", 0)) || match_lookahead_terminal(parser, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "INT32", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) || match_lookahead_terminal(parser, "UINT32", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) end - terms931 = xs928 + terms939 = xs936 consume_literal!(parser, ")") - _t1691 = Proto.Atom(name=relation_id927, terms=terms931) - result933 = _t1691 - record_span!(parser, span_start932, "Atom") - return result933 + _t1707 = Proto.Atom(name=relation_id935, terms=terms939) + result941 = _t1707 + record_span!(parser, span_start940, "Atom") + return result941 end function parse_pragma(parser::ParserState)::Proto.Pragma - span_start939 = span_start(parser) + span_start947 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "pragma") - _t1692 = parse_name(parser) - name934 = _t1692 - xs935 = Proto.Term[] - cond936 = (((((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "false", 0)) || match_lookahead_literal(parser, "missing", 0)) || match_lookahead_literal(parser, "true", 0)) || match_lookahead_terminal(parser, "DECIMAL", 0)) || match_lookahead_terminal(parser, "FLOAT", 0)) || match_lookahead_terminal(parser, "FLOAT32", 0)) || match_lookahead_terminal(parser, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "INT32", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) || match_lookahead_terminal(parser, "UINT32", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) - while cond936 - _t1693 = parse_term(parser) - item937 = _t1693 - push!(xs935, item937) - cond936 = (((((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "false", 0)) || match_lookahead_literal(parser, "missing", 0)) || match_lookahead_literal(parser, "true", 0)) || match_lookahead_terminal(parser, "DECIMAL", 0)) || match_lookahead_terminal(parser, "FLOAT", 0)) || match_lookahead_terminal(parser, "FLOAT32", 0)) || match_lookahead_terminal(parser, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "INT32", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) || match_lookahead_terminal(parser, "UINT32", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) + _t1708 = parse_name(parser) + name942 = _t1708 + xs943 = Proto.Term[] + cond944 = (((((((((((((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 cond944 + _t1709 = parse_term(parser) + item945 = _t1709 + push!(xs943, item945) + cond944 = (((((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "false", 0)) || match_lookahead_literal(parser, "missing", 0)) || match_lookahead_literal(parser, "true", 0)) || match_lookahead_terminal(parser, "DECIMAL", 0)) || match_lookahead_terminal(parser, "FLOAT", 0)) || match_lookahead_terminal(parser, "FLOAT32", 0)) || match_lookahead_terminal(parser, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "INT32", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) || match_lookahead_terminal(parser, "UINT32", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) end - terms938 = xs935 + terms946 = xs943 consume_literal!(parser, ")") - _t1694 = Proto.Pragma(name=name934, terms=terms938) - result940 = _t1694 - record_span!(parser, span_start939, "Pragma") - return result940 + _t1710 = Proto.Pragma(name=name942, terms=terms946) + result948 = _t1710 + record_span!(parser, span_start947, "Pragma") + return result948 end function parse_primitive(parser::ParserState)::Proto.Primitive - span_start956 = span_start(parser) + span_start964 = span_start(parser) if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "primitive", 1) - _t1696 = 9 + _t1712 = 9 else if match_lookahead_literal(parser, ">=", 1) - _t1697 = 4 + _t1713 = 4 else if match_lookahead_literal(parser, ">", 1) - _t1698 = 3 + _t1714 = 3 else if match_lookahead_literal(parser, "=", 1) - _t1699 = 0 + _t1715 = 0 else if match_lookahead_literal(parser, "<=", 1) - _t1700 = 2 + _t1716 = 2 else if match_lookahead_literal(parser, "<", 1) - _t1701 = 1 + _t1717 = 1 else if match_lookahead_literal(parser, "/", 1) - _t1702 = 8 + _t1718 = 8 else if match_lookahead_literal(parser, "-", 1) - _t1703 = 6 + _t1719 = 6 else if match_lookahead_literal(parser, "+", 1) - _t1704 = 5 + _t1720 = 5 else if match_lookahead_literal(parser, "*", 1) - _t1705 = 7 + _t1721 = 7 else - _t1705 = -1 + _t1721 = -1 end - _t1704 = _t1705 + _t1720 = _t1721 end - _t1703 = _t1704 + _t1719 = _t1720 end - _t1702 = _t1703 + _t1718 = _t1719 end - _t1701 = _t1702 + _t1717 = _t1718 end - _t1700 = _t1701 + _t1716 = _t1717 end - _t1699 = _t1700 + _t1715 = _t1716 end - _t1698 = _t1699 + _t1714 = _t1715 end - _t1697 = _t1698 + _t1713 = _t1714 end - _t1696 = _t1697 + _t1712 = _t1713 end - _t1695 = _t1696 + _t1711 = _t1712 else - _t1695 = -1 + _t1711 = -1 end - prediction941 = _t1695 - if prediction941 == 9 + prediction949 = _t1711 + if prediction949 == 9 consume_literal!(parser, "(") consume_literal!(parser, "primitive") - _t1707 = parse_name(parser) - name951 = _t1707 - xs952 = Proto.RelTerm[] - cond953 = ((((((((((((((match_lookahead_literal(parser, "#", 0) || match_lookahead_literal(parser, "(", 0)) || match_lookahead_literal(parser, "false", 0)) || match_lookahead_literal(parser, "missing", 0)) || match_lookahead_literal(parser, "true", 0)) || match_lookahead_terminal(parser, "DECIMAL", 0)) || match_lookahead_terminal(parser, "FLOAT", 0)) || match_lookahead_terminal(parser, "FLOAT32", 0)) || match_lookahead_terminal(parser, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "INT32", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) || match_lookahead_terminal(parser, "UINT32", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) - while cond953 - _t1708 = parse_rel_term(parser) - item954 = _t1708 - push!(xs952, item954) - cond953 = ((((((((((((((match_lookahead_literal(parser, "#", 0) || match_lookahead_literal(parser, "(", 0)) || match_lookahead_literal(parser, "false", 0)) || match_lookahead_literal(parser, "missing", 0)) || match_lookahead_literal(parser, "true", 0)) || match_lookahead_terminal(parser, "DECIMAL", 0)) || match_lookahead_terminal(parser, "FLOAT", 0)) || match_lookahead_terminal(parser, "FLOAT32", 0)) || match_lookahead_terminal(parser, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "INT32", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) || match_lookahead_terminal(parser, "UINT32", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) + _t1723 = parse_name(parser) + name959 = _t1723 + xs960 = Proto.RelTerm[] + cond961 = ((((((((((((((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 cond961 + _t1724 = parse_rel_term(parser) + item962 = _t1724 + push!(xs960, item962) + cond961 = ((((((((((((((match_lookahead_literal(parser, "#", 0) || match_lookahead_literal(parser, "(", 0)) || match_lookahead_literal(parser, "false", 0)) || match_lookahead_literal(parser, "missing", 0)) || match_lookahead_literal(parser, "true", 0)) || match_lookahead_terminal(parser, "DECIMAL", 0)) || match_lookahead_terminal(parser, "FLOAT", 0)) || match_lookahead_terminal(parser, "FLOAT32", 0)) || match_lookahead_terminal(parser, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "INT32", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) || match_lookahead_terminal(parser, "UINT32", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) end - rel_terms955 = xs952 + rel_terms963 = xs960 consume_literal!(parser, ")") - _t1709 = Proto.Primitive(name=name951, terms=rel_terms955) - _t1706 = _t1709 + _t1725 = Proto.Primitive(name=name959, terms=rel_terms963) + _t1722 = _t1725 else - if prediction941 == 8 - _t1711 = parse_divide(parser) - divide950 = _t1711 - _t1710 = divide950 + if prediction949 == 8 + _t1727 = parse_divide(parser) + divide958 = _t1727 + _t1726 = divide958 else - if prediction941 == 7 - _t1713 = parse_multiply(parser) - multiply949 = _t1713 - _t1712 = multiply949 + if prediction949 == 7 + _t1729 = parse_multiply(parser) + multiply957 = _t1729 + _t1728 = multiply957 else - if prediction941 == 6 - _t1715 = parse_minus(parser) - minus948 = _t1715 - _t1714 = minus948 + if prediction949 == 6 + _t1731 = parse_minus(parser) + minus956 = _t1731 + _t1730 = minus956 else - if prediction941 == 5 - _t1717 = parse_add(parser) - add947 = _t1717 - _t1716 = add947 + if prediction949 == 5 + _t1733 = parse_add(parser) + add955 = _t1733 + _t1732 = add955 else - if prediction941 == 4 - _t1719 = parse_gt_eq(parser) - gt_eq946 = _t1719 - _t1718 = gt_eq946 + if prediction949 == 4 + _t1735 = parse_gt_eq(parser) + gt_eq954 = _t1735 + _t1734 = gt_eq954 else - if prediction941 == 3 - _t1721 = parse_gt(parser) - gt945 = _t1721 - _t1720 = gt945 + if prediction949 == 3 + _t1737 = parse_gt(parser) + gt953 = _t1737 + _t1736 = gt953 else - if prediction941 == 2 - _t1723 = parse_lt_eq(parser) - lt_eq944 = _t1723 - _t1722 = lt_eq944 + if prediction949 == 2 + _t1739 = parse_lt_eq(parser) + lt_eq952 = _t1739 + _t1738 = lt_eq952 else - if prediction941 == 1 - _t1725 = parse_lt(parser) - lt943 = _t1725 - _t1724 = lt943 + if prediction949 == 1 + _t1741 = parse_lt(parser) + lt951 = _t1741 + _t1740 = lt951 else - if prediction941 == 0 - _t1727 = parse_eq(parser) - eq942 = _t1727 - _t1726 = eq942 + if prediction949 == 0 + _t1743 = parse_eq(parser) + eq950 = _t1743 + _t1742 = eq950 else throw(ParseError("Unexpected token in primitive" * ": " * string(lookahead(parser, 0)))) end - _t1724 = _t1726 + _t1740 = _t1742 end - _t1722 = _t1724 + _t1738 = _t1740 end - _t1720 = _t1722 + _t1736 = _t1738 end - _t1718 = _t1720 + _t1734 = _t1736 end - _t1716 = _t1718 + _t1732 = _t1734 end - _t1714 = _t1716 + _t1730 = _t1732 end - _t1712 = _t1714 + _t1728 = _t1730 end - _t1710 = _t1712 + _t1726 = _t1728 end - _t1706 = _t1710 + _t1722 = _t1726 end - result957 = _t1706 - record_span!(parser, span_start956, "Primitive") - return result957 + result965 = _t1722 + record_span!(parser, span_start964, "Primitive") + return result965 end function parse_eq(parser::ParserState)::Proto.Primitive - span_start960 = span_start(parser) + span_start968 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "=") - _t1728 = parse_term(parser) - term958 = _t1728 - _t1729 = parse_term(parser) - term_3959 = _t1729 + _t1744 = parse_term(parser) + term966 = _t1744 + _t1745 = parse_term(parser) + term_3967 = _t1745 consume_literal!(parser, ")") - _t1730 = Proto.RelTerm(rel_term_type=OneOf(:term, term958)) - _t1731 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3959)) - _t1732 = Proto.Primitive(name="rel_primitive_eq", terms=Proto.RelTerm[_t1730, _t1731]) - result961 = _t1732 - record_span!(parser, span_start960, "Primitive") - return result961 + _t1746 = Proto.RelTerm(rel_term_type=OneOf(:term, term966)) + _t1747 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3967)) + _t1748 = Proto.Primitive(name="rel_primitive_eq", terms=Proto.RelTerm[_t1746, _t1747]) + result969 = _t1748 + record_span!(parser, span_start968, "Primitive") + return result969 end function parse_lt(parser::ParserState)::Proto.Primitive - span_start964 = span_start(parser) + span_start972 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "<") - _t1733 = parse_term(parser) - term962 = _t1733 - _t1734 = parse_term(parser) - term_3963 = _t1734 + _t1749 = parse_term(parser) + term970 = _t1749 + _t1750 = parse_term(parser) + term_3971 = _t1750 consume_literal!(parser, ")") - _t1735 = Proto.RelTerm(rel_term_type=OneOf(:term, term962)) - _t1736 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3963)) - _t1737 = Proto.Primitive(name="rel_primitive_lt_monotype", terms=Proto.RelTerm[_t1735, _t1736]) - result965 = _t1737 - record_span!(parser, span_start964, "Primitive") - return result965 + _t1751 = Proto.RelTerm(rel_term_type=OneOf(:term, term970)) + _t1752 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3971)) + _t1753 = Proto.Primitive(name="rel_primitive_lt_monotype", terms=Proto.RelTerm[_t1751, _t1752]) + result973 = _t1753 + record_span!(parser, span_start972, "Primitive") + return result973 end function parse_lt_eq(parser::ParserState)::Proto.Primitive - span_start968 = span_start(parser) + span_start976 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "<=") - _t1738 = parse_term(parser) - term966 = _t1738 - _t1739 = parse_term(parser) - term_3967 = _t1739 + _t1754 = parse_term(parser) + term974 = _t1754 + _t1755 = parse_term(parser) + term_3975 = _t1755 consume_literal!(parser, ")") - _t1740 = Proto.RelTerm(rel_term_type=OneOf(:term, term966)) - _t1741 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3967)) - _t1742 = Proto.Primitive(name="rel_primitive_lt_eq_monotype", terms=Proto.RelTerm[_t1740, _t1741]) - result969 = _t1742 - record_span!(parser, span_start968, "Primitive") - return result969 + _t1756 = Proto.RelTerm(rel_term_type=OneOf(:term, term974)) + _t1757 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3975)) + _t1758 = Proto.Primitive(name="rel_primitive_lt_eq_monotype", terms=Proto.RelTerm[_t1756, _t1757]) + result977 = _t1758 + record_span!(parser, span_start976, "Primitive") + return result977 end function parse_gt(parser::ParserState)::Proto.Primitive - span_start972 = span_start(parser) + span_start980 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, ">") - _t1743 = parse_term(parser) - term970 = _t1743 - _t1744 = parse_term(parser) - term_3971 = _t1744 + _t1759 = parse_term(parser) + term978 = _t1759 + _t1760 = parse_term(parser) + term_3979 = _t1760 consume_literal!(parser, ")") - _t1745 = Proto.RelTerm(rel_term_type=OneOf(:term, term970)) - _t1746 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3971)) - _t1747 = Proto.Primitive(name="rel_primitive_gt_monotype", terms=Proto.RelTerm[_t1745, _t1746]) - result973 = _t1747 - record_span!(parser, span_start972, "Primitive") - return result973 + _t1761 = Proto.RelTerm(rel_term_type=OneOf(:term, term978)) + _t1762 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3979)) + _t1763 = Proto.Primitive(name="rel_primitive_gt_monotype", terms=Proto.RelTerm[_t1761, _t1762]) + result981 = _t1763 + record_span!(parser, span_start980, "Primitive") + return result981 end function parse_gt_eq(parser::ParserState)::Proto.Primitive - span_start976 = span_start(parser) + span_start984 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, ">=") - _t1748 = parse_term(parser) - term974 = _t1748 - _t1749 = parse_term(parser) - term_3975 = _t1749 + _t1764 = parse_term(parser) + term982 = _t1764 + _t1765 = parse_term(parser) + term_3983 = _t1765 consume_literal!(parser, ")") - _t1750 = Proto.RelTerm(rel_term_type=OneOf(:term, term974)) - _t1751 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3975)) - _t1752 = Proto.Primitive(name="rel_primitive_gt_eq_monotype", terms=Proto.RelTerm[_t1750, _t1751]) - result977 = _t1752 - record_span!(parser, span_start976, "Primitive") - return result977 + _t1766 = Proto.RelTerm(rel_term_type=OneOf(:term, term982)) + _t1767 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3983)) + _t1768 = Proto.Primitive(name="rel_primitive_gt_eq_monotype", terms=Proto.RelTerm[_t1766, _t1767]) + result985 = _t1768 + record_span!(parser, span_start984, "Primitive") + return result985 end function parse_add(parser::ParserState)::Proto.Primitive - span_start981 = span_start(parser) + span_start989 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "+") - _t1753 = parse_term(parser) - term978 = _t1753 - _t1754 = parse_term(parser) - term_3979 = _t1754 - _t1755 = parse_term(parser) - term_4980 = _t1755 + _t1769 = parse_term(parser) + term986 = _t1769 + _t1770 = parse_term(parser) + term_3987 = _t1770 + _t1771 = parse_term(parser) + term_4988 = _t1771 consume_literal!(parser, ")") - _t1756 = Proto.RelTerm(rel_term_type=OneOf(:term, term978)) - _t1757 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3979)) - _t1758 = Proto.RelTerm(rel_term_type=OneOf(:term, term_4980)) - _t1759 = Proto.Primitive(name="rel_primitive_add_monotype", terms=Proto.RelTerm[_t1756, _t1757, _t1758]) - result982 = _t1759 - record_span!(parser, span_start981, "Primitive") - return result982 + _t1772 = Proto.RelTerm(rel_term_type=OneOf(:term, term986)) + _t1773 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3987)) + _t1774 = Proto.RelTerm(rel_term_type=OneOf(:term, term_4988)) + _t1775 = Proto.Primitive(name="rel_primitive_add_monotype", terms=Proto.RelTerm[_t1772, _t1773, _t1774]) + result990 = _t1775 + record_span!(parser, span_start989, "Primitive") + return result990 end function parse_minus(parser::ParserState)::Proto.Primitive - span_start986 = span_start(parser) + span_start994 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "-") - _t1760 = parse_term(parser) - term983 = _t1760 - _t1761 = parse_term(parser) - term_3984 = _t1761 - _t1762 = parse_term(parser) - term_4985 = _t1762 + _t1776 = parse_term(parser) + term991 = _t1776 + _t1777 = parse_term(parser) + term_3992 = _t1777 + _t1778 = parse_term(parser) + term_4993 = _t1778 consume_literal!(parser, ")") - _t1763 = Proto.RelTerm(rel_term_type=OneOf(:term, term983)) - _t1764 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3984)) - _t1765 = Proto.RelTerm(rel_term_type=OneOf(:term, term_4985)) - _t1766 = Proto.Primitive(name="rel_primitive_subtract_monotype", terms=Proto.RelTerm[_t1763, _t1764, _t1765]) - result987 = _t1766 - record_span!(parser, span_start986, "Primitive") - return result987 + _t1779 = Proto.RelTerm(rel_term_type=OneOf(:term, term991)) + _t1780 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3992)) + _t1781 = Proto.RelTerm(rel_term_type=OneOf(:term, term_4993)) + _t1782 = Proto.Primitive(name="rel_primitive_subtract_monotype", terms=Proto.RelTerm[_t1779, _t1780, _t1781]) + result995 = _t1782 + record_span!(parser, span_start994, "Primitive") + return result995 end function parse_multiply(parser::ParserState)::Proto.Primitive - span_start991 = span_start(parser) + span_start999 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "*") - _t1767 = parse_term(parser) - term988 = _t1767 - _t1768 = parse_term(parser) - term_3989 = _t1768 - _t1769 = parse_term(parser) - term_4990 = _t1769 + _t1783 = parse_term(parser) + term996 = _t1783 + _t1784 = parse_term(parser) + term_3997 = _t1784 + _t1785 = parse_term(parser) + term_4998 = _t1785 consume_literal!(parser, ")") - _t1770 = Proto.RelTerm(rel_term_type=OneOf(:term, term988)) - _t1771 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3989)) - _t1772 = Proto.RelTerm(rel_term_type=OneOf(:term, term_4990)) - _t1773 = Proto.Primitive(name="rel_primitive_multiply_monotype", terms=Proto.RelTerm[_t1770, _t1771, _t1772]) - result992 = _t1773 - record_span!(parser, span_start991, "Primitive") - return result992 + _t1786 = Proto.RelTerm(rel_term_type=OneOf(:term, term996)) + _t1787 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3997)) + _t1788 = Proto.RelTerm(rel_term_type=OneOf(:term, term_4998)) + _t1789 = Proto.Primitive(name="rel_primitive_multiply_monotype", terms=Proto.RelTerm[_t1786, _t1787, _t1788]) + result1000 = _t1789 + record_span!(parser, span_start999, "Primitive") + return result1000 end function parse_divide(parser::ParserState)::Proto.Primitive - span_start996 = span_start(parser) + span_start1004 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "/") - _t1774 = parse_term(parser) - term993 = _t1774 - _t1775 = parse_term(parser) - term_3994 = _t1775 - _t1776 = parse_term(parser) - term_4995 = _t1776 + _t1790 = parse_term(parser) + term1001 = _t1790 + _t1791 = parse_term(parser) + term_31002 = _t1791 + _t1792 = parse_term(parser) + term_41003 = _t1792 consume_literal!(parser, ")") - _t1777 = Proto.RelTerm(rel_term_type=OneOf(:term, term993)) - _t1778 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3994)) - _t1779 = Proto.RelTerm(rel_term_type=OneOf(:term, term_4995)) - _t1780 = Proto.Primitive(name="rel_primitive_divide_monotype", terms=Proto.RelTerm[_t1777, _t1778, _t1779]) - result997 = _t1780 - record_span!(parser, span_start996, "Primitive") - return result997 + _t1793 = Proto.RelTerm(rel_term_type=OneOf(:term, term1001)) + _t1794 = Proto.RelTerm(rel_term_type=OneOf(:term, term_31002)) + _t1795 = Proto.RelTerm(rel_term_type=OneOf(:term, term_41003)) + _t1796 = Proto.Primitive(name="rel_primitive_divide_monotype", terms=Proto.RelTerm[_t1793, _t1794, _t1795]) + result1005 = _t1796 + record_span!(parser, span_start1004, "Primitive") + return result1005 end function parse_rel_term(parser::ParserState)::Proto.RelTerm - span_start1001 = span_start(parser) + span_start1009 = span_start(parser) if match_lookahead_literal(parser, "true", 0) - _t1781 = 1 + _t1797 = 1 else if match_lookahead_literal(parser, "missing", 0) - _t1782 = 1 + _t1798 = 1 else if match_lookahead_literal(parser, "false", 0) - _t1783 = 1 + _t1799 = 1 else if match_lookahead_literal(parser, "(", 0) - _t1784 = 1 + _t1800 = 1 else if match_lookahead_literal(parser, "#", 0) - _t1785 = 0 + _t1801 = 0 else if match_lookahead_terminal(parser, "SYMBOL", 0) - _t1786 = 1 + _t1802 = 1 else if match_lookahead_terminal(parser, "UINT32", 0) - _t1787 = 1 + _t1803 = 1 else if match_lookahead_terminal(parser, "UINT128", 0) - _t1788 = 1 + _t1804 = 1 else if match_lookahead_terminal(parser, "STRING", 0) - _t1789 = 1 + _t1805 = 1 else if match_lookahead_terminal(parser, "INT32", 0) - _t1790 = 1 + _t1806 = 1 else if match_lookahead_terminal(parser, "INT128", 0) - _t1791 = 1 + _t1807 = 1 else if match_lookahead_terminal(parser, "INT", 0) - _t1792 = 1 + _t1808 = 1 else if match_lookahead_terminal(parser, "FLOAT32", 0) - _t1793 = 1 + _t1809 = 1 else if match_lookahead_terminal(parser, "FLOAT", 0) - _t1794 = 1 + _t1810 = 1 else if match_lookahead_terminal(parser, "DECIMAL", 0) - _t1795 = 1 + _t1811 = 1 else - _t1795 = -1 + _t1811 = -1 end - _t1794 = _t1795 + _t1810 = _t1811 end - _t1793 = _t1794 + _t1809 = _t1810 end - _t1792 = _t1793 + _t1808 = _t1809 end - _t1791 = _t1792 + _t1807 = _t1808 end - _t1790 = _t1791 + _t1806 = _t1807 end - _t1789 = _t1790 + _t1805 = _t1806 end - _t1788 = _t1789 + _t1804 = _t1805 end - _t1787 = _t1788 + _t1803 = _t1804 end - _t1786 = _t1787 + _t1802 = _t1803 end - _t1785 = _t1786 + _t1801 = _t1802 end - _t1784 = _t1785 + _t1800 = _t1801 end - _t1783 = _t1784 + _t1799 = _t1800 end - _t1782 = _t1783 + _t1798 = _t1799 end - _t1781 = _t1782 + _t1797 = _t1798 end - prediction998 = _t1781 - if prediction998 == 1 - _t1797 = parse_term(parser) - term1000 = _t1797 - _t1798 = Proto.RelTerm(rel_term_type=OneOf(:term, term1000)) - _t1796 = _t1798 + prediction1006 = _t1797 + if prediction1006 == 1 + _t1813 = parse_term(parser) + term1008 = _t1813 + _t1814 = Proto.RelTerm(rel_term_type=OneOf(:term, term1008)) + _t1812 = _t1814 else - if prediction998 == 0 - _t1800 = parse_specialized_value(parser) - specialized_value999 = _t1800 - _t1801 = Proto.RelTerm(rel_term_type=OneOf(:specialized_value, specialized_value999)) - _t1799 = _t1801 + if prediction1006 == 0 + _t1816 = parse_specialized_value(parser) + specialized_value1007 = _t1816 + _t1817 = Proto.RelTerm(rel_term_type=OneOf(:specialized_value, specialized_value1007)) + _t1815 = _t1817 else throw(ParseError("Unexpected token in rel_term" * ": " * string(lookahead(parser, 0)))) end - _t1796 = _t1799 + _t1812 = _t1815 end - result1002 = _t1796 - record_span!(parser, span_start1001, "RelTerm") - return result1002 + result1010 = _t1812 + record_span!(parser, span_start1009, "RelTerm") + return result1010 end function parse_specialized_value(parser::ParserState)::Proto.Value - span_start1004 = span_start(parser) + span_start1012 = span_start(parser) consume_literal!(parser, "#") - _t1802 = parse_raw_value(parser) - raw_value1003 = _t1802 - result1005 = raw_value1003 - record_span!(parser, span_start1004, "Value") - return result1005 + _t1818 = parse_raw_value(parser) + raw_value1011 = _t1818 + result1013 = raw_value1011 + record_span!(parser, span_start1012, "Value") + return result1013 end function parse_rel_atom(parser::ParserState)::Proto.RelAtom - span_start1011 = span_start(parser) + span_start1019 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "relatom") - _t1803 = parse_name(parser) - name1006 = _t1803 - xs1007 = Proto.RelTerm[] - cond1008 = ((((((((((((((match_lookahead_literal(parser, "#", 0) || match_lookahead_literal(parser, "(", 0)) || match_lookahead_literal(parser, "false", 0)) || match_lookahead_literal(parser, "missing", 0)) || match_lookahead_literal(parser, "true", 0)) || match_lookahead_terminal(parser, "DECIMAL", 0)) || match_lookahead_terminal(parser, "FLOAT", 0)) || match_lookahead_terminal(parser, "FLOAT32", 0)) || match_lookahead_terminal(parser, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "INT32", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) || match_lookahead_terminal(parser, "UINT32", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) - while cond1008 - _t1804 = parse_rel_term(parser) - item1009 = _t1804 - push!(xs1007, item1009) - cond1008 = ((((((((((((((match_lookahead_literal(parser, "#", 0) || match_lookahead_literal(parser, "(", 0)) || match_lookahead_literal(parser, "false", 0)) || match_lookahead_literal(parser, "missing", 0)) || match_lookahead_literal(parser, "true", 0)) || match_lookahead_terminal(parser, "DECIMAL", 0)) || match_lookahead_terminal(parser, "FLOAT", 0)) || match_lookahead_terminal(parser, "FLOAT32", 0)) || match_lookahead_terminal(parser, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "INT32", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) || match_lookahead_terminal(parser, "UINT32", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) + _t1819 = parse_name(parser) + name1014 = _t1819 + xs1015 = Proto.RelTerm[] + cond1016 = ((((((((((((((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 cond1016 + _t1820 = parse_rel_term(parser) + item1017 = _t1820 + push!(xs1015, item1017) + cond1016 = ((((((((((((((match_lookahead_literal(parser, "#", 0) || match_lookahead_literal(parser, "(", 0)) || match_lookahead_literal(parser, "false", 0)) || match_lookahead_literal(parser, "missing", 0)) || match_lookahead_literal(parser, "true", 0)) || match_lookahead_terminal(parser, "DECIMAL", 0)) || match_lookahead_terminal(parser, "FLOAT", 0)) || match_lookahead_terminal(parser, "FLOAT32", 0)) || match_lookahead_terminal(parser, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "INT32", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) || match_lookahead_terminal(parser, "UINT32", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) end - rel_terms1010 = xs1007 + rel_terms1018 = xs1015 consume_literal!(parser, ")") - _t1805 = Proto.RelAtom(name=name1006, terms=rel_terms1010) - result1012 = _t1805 - record_span!(parser, span_start1011, "RelAtom") - return result1012 + _t1821 = Proto.RelAtom(name=name1014, terms=rel_terms1018) + result1020 = _t1821 + record_span!(parser, span_start1019, "RelAtom") + return result1020 end function parse_cast(parser::ParserState)::Proto.Cast - span_start1015 = span_start(parser) + span_start1023 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "cast") - _t1806 = parse_term(parser) - term1013 = _t1806 - _t1807 = parse_term(parser) - term_31014 = _t1807 + _t1822 = parse_term(parser) + term1021 = _t1822 + _t1823 = parse_term(parser) + term_31022 = _t1823 consume_literal!(parser, ")") - _t1808 = Proto.Cast(input=term1013, result=term_31014) - result1016 = _t1808 - record_span!(parser, span_start1015, "Cast") - return result1016 + _t1824 = Proto.Cast(input=term1021, result=term_31022) + result1024 = _t1824 + record_span!(parser, span_start1023, "Cast") + return result1024 end function parse_attrs(parser::ParserState)::Vector{Proto.Attribute} consume_literal!(parser, "(") consume_literal!(parser, "attrs") - xs1017 = Proto.Attribute[] - cond1018 = match_lookahead_literal(parser, "(", 0) - while cond1018 - _t1809 = parse_attribute(parser) - item1019 = _t1809 - push!(xs1017, item1019) - cond1018 = match_lookahead_literal(parser, "(", 0) + xs1025 = Proto.Attribute[] + cond1026 = match_lookahead_literal(parser, "(", 0) + while cond1026 + _t1825 = parse_attribute(parser) + item1027 = _t1825 + push!(xs1025, item1027) + cond1026 = match_lookahead_literal(parser, "(", 0) end - attributes1020 = xs1017 + attributes1028 = xs1025 consume_literal!(parser, ")") - return attributes1020 + return attributes1028 end function parse_attribute(parser::ParserState)::Proto.Attribute - span_start1026 = span_start(parser) + span_start1034 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "attribute") - _t1810 = parse_name(parser) - name1021 = _t1810 - xs1022 = Proto.Value[] - cond1023 = ((((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "false", 0)) || match_lookahead_literal(parser, "missing", 0)) || match_lookahead_literal(parser, "true", 0)) || match_lookahead_terminal(parser, "DECIMAL", 0)) || match_lookahead_terminal(parser, "FLOAT", 0)) || match_lookahead_terminal(parser, "FLOAT32", 0)) || match_lookahead_terminal(parser, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "INT32", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) || match_lookahead_terminal(parser, "UINT32", 0)) - while cond1023 - _t1811 = parse_raw_value(parser) - item1024 = _t1811 - push!(xs1022, item1024) - cond1023 = ((((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "false", 0)) || match_lookahead_literal(parser, "missing", 0)) || match_lookahead_literal(parser, "true", 0)) || match_lookahead_terminal(parser, "DECIMAL", 0)) || match_lookahead_terminal(parser, "FLOAT", 0)) || match_lookahead_terminal(parser, "FLOAT32", 0)) || match_lookahead_terminal(parser, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "INT32", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) || match_lookahead_terminal(parser, "UINT32", 0)) + _t1826 = parse_name(parser) + name1029 = _t1826 + xs1030 = Proto.Value[] + cond1031 = ((((((((((((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 cond1031 + _t1827 = parse_raw_value(parser) + item1032 = _t1827 + push!(xs1030, item1032) + cond1031 = ((((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "false", 0)) || match_lookahead_literal(parser, "missing", 0)) || match_lookahead_literal(parser, "true", 0)) || match_lookahead_terminal(parser, "DECIMAL", 0)) || match_lookahead_terminal(parser, "FLOAT", 0)) || match_lookahead_terminal(parser, "FLOAT32", 0)) || match_lookahead_terminal(parser, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "INT32", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) || match_lookahead_terminal(parser, "UINT32", 0)) end - raw_values1025 = xs1022 + raw_values1033 = xs1030 consume_literal!(parser, ")") - _t1812 = Proto.Attribute(name=name1021, args=raw_values1025) - result1027 = _t1812 - record_span!(parser, span_start1026, "Attribute") - return result1027 + _t1828 = Proto.Attribute(name=name1029, args=raw_values1033) + result1035 = _t1828 + record_span!(parser, span_start1034, "Attribute") + return result1035 end function parse_algorithm(parser::ParserState)::Proto.Algorithm - span_start1034 = span_start(parser) + span_start1042 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "algorithm") - xs1028 = Proto.RelationId[] - cond1029 = (match_lookahead_literal(parser, ":", 0) || match_lookahead_terminal(parser, "UINT128", 0)) - while cond1029 - _t1813 = parse_relation_id(parser) - item1030 = _t1813 - push!(xs1028, item1030) - cond1029 = (match_lookahead_literal(parser, ":", 0) || match_lookahead_terminal(parser, "UINT128", 0)) + xs1036 = Proto.RelationId[] + cond1037 = (match_lookahead_literal(parser, ":", 0) || match_lookahead_terminal(parser, "UINT128", 0)) + while cond1037 + _t1829 = parse_relation_id(parser) + item1038 = _t1829 + push!(xs1036, item1038) + cond1037 = (match_lookahead_literal(parser, ":", 0) || match_lookahead_terminal(parser, "UINT128", 0)) end - relation_ids1031 = xs1028 - _t1814 = parse_script(parser) - script1032 = _t1814 + relation_ids1039 = xs1036 + _t1830 = parse_script(parser) + script1040 = _t1830 if match_lookahead_literal(parser, "(", 0) - _t1816 = parse_attrs(parser) - _t1815 = _t1816 + _t1832 = parse_attrs(parser) + _t1831 = _t1832 else - _t1815 = nothing + _t1831 = nothing end - attrs1033 = _t1815 + attrs1041 = _t1831 consume_literal!(parser, ")") - _t1817 = Proto.Algorithm(var"#global"=relation_ids1031, body=script1032, attrs=(!isnothing(attrs1033) ? attrs1033 : Proto.Attribute[])) - result1035 = _t1817 - record_span!(parser, span_start1034, "Algorithm") - return result1035 + _t1833 = Proto.Algorithm(var"#global"=relation_ids1039, body=script1040, attrs=(!isnothing(attrs1041) ? attrs1041 : Proto.Attribute[])) + result1043 = _t1833 + record_span!(parser, span_start1042, "Algorithm") + return result1043 end function parse_script(parser::ParserState)::Proto.Script - span_start1040 = span_start(parser) + span_start1048 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "script") - xs1036 = Proto.Construct[] - cond1037 = match_lookahead_literal(parser, "(", 0) - while cond1037 - _t1818 = parse_construct(parser) - item1038 = _t1818 - push!(xs1036, item1038) - cond1037 = match_lookahead_literal(parser, "(", 0) + xs1044 = Proto.Construct[] + cond1045 = match_lookahead_literal(parser, "(", 0) + while cond1045 + _t1834 = parse_construct(parser) + item1046 = _t1834 + push!(xs1044, item1046) + cond1045 = match_lookahead_literal(parser, "(", 0) end - constructs1039 = xs1036 + constructs1047 = xs1044 consume_literal!(parser, ")") - _t1819 = Proto.Script(constructs=constructs1039) - result1041 = _t1819 - record_span!(parser, span_start1040, "Script") - return result1041 + _t1835 = Proto.Script(constructs=constructs1047) + result1049 = _t1835 + record_span!(parser, span_start1048, "Script") + return result1049 end function parse_construct(parser::ParserState)::Proto.Construct - span_start1045 = span_start(parser) + span_start1053 = span_start(parser) if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "upsert", 1) - _t1821 = 1 + _t1837 = 1 else if match_lookahead_literal(parser, "monus", 1) - _t1822 = 1 + _t1838 = 1 else if match_lookahead_literal(parser, "monoid", 1) - _t1823 = 1 + _t1839 = 1 else if match_lookahead_literal(parser, "loop", 1) - _t1824 = 0 + _t1840 = 0 else if match_lookahead_literal(parser, "break", 1) - _t1825 = 1 + _t1841 = 1 else if match_lookahead_literal(parser, "assign", 1) - _t1826 = 1 + _t1842 = 1 else - _t1826 = -1 + _t1842 = -1 end - _t1825 = _t1826 + _t1841 = _t1842 end - _t1824 = _t1825 + _t1840 = _t1841 end - _t1823 = _t1824 + _t1839 = _t1840 end - _t1822 = _t1823 + _t1838 = _t1839 end - _t1821 = _t1822 + _t1837 = _t1838 end - _t1820 = _t1821 + _t1836 = _t1837 else - _t1820 = -1 + _t1836 = -1 end - prediction1042 = _t1820 - if prediction1042 == 1 - _t1828 = parse_instruction(parser) - instruction1044 = _t1828 - _t1829 = Proto.Construct(construct_type=OneOf(:instruction, instruction1044)) - _t1827 = _t1829 + prediction1050 = _t1836 + if prediction1050 == 1 + _t1844 = parse_instruction(parser) + instruction1052 = _t1844 + _t1845 = Proto.Construct(construct_type=OneOf(:instruction, instruction1052)) + _t1843 = _t1845 else - if prediction1042 == 0 - _t1831 = parse_loop(parser) - loop1043 = _t1831 - _t1832 = Proto.Construct(construct_type=OneOf(:loop, loop1043)) - _t1830 = _t1832 + if prediction1050 == 0 + _t1847 = parse_loop(parser) + loop1051 = _t1847 + _t1848 = Proto.Construct(construct_type=OneOf(:loop, loop1051)) + _t1846 = _t1848 else throw(ParseError("Unexpected token in construct" * ": " * string(lookahead(parser, 0)))) end - _t1827 = _t1830 + _t1843 = _t1846 end - result1046 = _t1827 - record_span!(parser, span_start1045, "Construct") - return result1046 + result1054 = _t1843 + record_span!(parser, span_start1053, "Construct") + return result1054 end function parse_loop(parser::ParserState)::Proto.Loop - span_start1050 = span_start(parser) + span_start1058 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "loop") - _t1833 = parse_init(parser) - init1047 = _t1833 - _t1834 = parse_script(parser) - script1048 = _t1834 + _t1849 = parse_init(parser) + init1055 = _t1849 + _t1850 = parse_script(parser) + script1056 = _t1850 if match_lookahead_literal(parser, "(", 0) - _t1836 = parse_attrs(parser) - _t1835 = _t1836 + _t1852 = parse_attrs(parser) + _t1851 = _t1852 else - _t1835 = nothing + _t1851 = nothing end - attrs1049 = _t1835 + attrs1057 = _t1851 consume_literal!(parser, ")") - _t1837 = Proto.Loop(init=init1047, body=script1048, attrs=(!isnothing(attrs1049) ? attrs1049 : Proto.Attribute[])) - result1051 = _t1837 - record_span!(parser, span_start1050, "Loop") - return result1051 + _t1853 = Proto.Loop(init=init1055, body=script1056, attrs=(!isnothing(attrs1057) ? attrs1057 : Proto.Attribute[])) + result1059 = _t1853 + record_span!(parser, span_start1058, "Loop") + return result1059 end function parse_init(parser::ParserState)::Vector{Proto.Instruction} consume_literal!(parser, "(") consume_literal!(parser, "init") - xs1052 = Proto.Instruction[] - cond1053 = match_lookahead_literal(parser, "(", 0) - while cond1053 - _t1838 = parse_instruction(parser) - item1054 = _t1838 - push!(xs1052, item1054) - cond1053 = match_lookahead_literal(parser, "(", 0) + xs1060 = Proto.Instruction[] + cond1061 = match_lookahead_literal(parser, "(", 0) + while cond1061 + _t1854 = parse_instruction(parser) + item1062 = _t1854 + push!(xs1060, item1062) + cond1061 = match_lookahead_literal(parser, "(", 0) end - instructions1055 = xs1052 + instructions1063 = xs1060 consume_literal!(parser, ")") - return instructions1055 + return instructions1063 end function parse_instruction(parser::ParserState)::Proto.Instruction - span_start1062 = span_start(parser) + span_start1070 = span_start(parser) if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "upsert", 1) - _t1840 = 1 + _t1856 = 1 else if match_lookahead_literal(parser, "monus", 1) - _t1841 = 4 + _t1857 = 4 else if match_lookahead_literal(parser, "monoid", 1) - _t1842 = 3 + _t1858 = 3 else if match_lookahead_literal(parser, "break", 1) - _t1843 = 2 + _t1859 = 2 else if match_lookahead_literal(parser, "assign", 1) - _t1844 = 0 + _t1860 = 0 else - _t1844 = -1 + _t1860 = -1 end - _t1843 = _t1844 + _t1859 = _t1860 end - _t1842 = _t1843 + _t1858 = _t1859 end - _t1841 = _t1842 + _t1857 = _t1858 end - _t1840 = _t1841 + _t1856 = _t1857 end - _t1839 = _t1840 + _t1855 = _t1856 else - _t1839 = -1 + _t1855 = -1 end - prediction1056 = _t1839 - if prediction1056 == 4 - _t1846 = parse_monus_def(parser) - monus_def1061 = _t1846 - _t1847 = Proto.Instruction(instr_type=OneOf(:monus_def, monus_def1061)) - _t1845 = _t1847 + prediction1064 = _t1855 + if prediction1064 == 4 + _t1862 = parse_monus_def(parser) + monus_def1069 = _t1862 + _t1863 = Proto.Instruction(instr_type=OneOf(:monus_def, monus_def1069)) + _t1861 = _t1863 else - if prediction1056 == 3 - _t1849 = parse_monoid_def(parser) - monoid_def1060 = _t1849 - _t1850 = Proto.Instruction(instr_type=OneOf(:monoid_def, monoid_def1060)) - _t1848 = _t1850 + if prediction1064 == 3 + _t1865 = parse_monoid_def(parser) + monoid_def1068 = _t1865 + _t1866 = Proto.Instruction(instr_type=OneOf(:monoid_def, monoid_def1068)) + _t1864 = _t1866 else - if prediction1056 == 2 - _t1852 = parse_break(parser) - break1059 = _t1852 - _t1853 = Proto.Instruction(instr_type=OneOf(:var"#break", break1059)) - _t1851 = _t1853 + if prediction1064 == 2 + _t1868 = parse_break(parser) + break1067 = _t1868 + _t1869 = Proto.Instruction(instr_type=OneOf(:var"#break", break1067)) + _t1867 = _t1869 else - if prediction1056 == 1 - _t1855 = parse_upsert(parser) - upsert1058 = _t1855 - _t1856 = Proto.Instruction(instr_type=OneOf(:upsert, upsert1058)) - _t1854 = _t1856 + if prediction1064 == 1 + _t1871 = parse_upsert(parser) + upsert1066 = _t1871 + _t1872 = Proto.Instruction(instr_type=OneOf(:upsert, upsert1066)) + _t1870 = _t1872 else - if prediction1056 == 0 - _t1858 = parse_assign(parser) - assign1057 = _t1858 - _t1859 = Proto.Instruction(instr_type=OneOf(:assign, assign1057)) - _t1857 = _t1859 + if prediction1064 == 0 + _t1874 = parse_assign(parser) + assign1065 = _t1874 + _t1875 = Proto.Instruction(instr_type=OneOf(:assign, assign1065)) + _t1873 = _t1875 else throw(ParseError("Unexpected token in instruction" * ": " * string(lookahead(parser, 0)))) end - _t1854 = _t1857 + _t1870 = _t1873 end - _t1851 = _t1854 + _t1867 = _t1870 end - _t1848 = _t1851 + _t1864 = _t1867 end - _t1845 = _t1848 + _t1861 = _t1864 end - result1063 = _t1845 - record_span!(parser, span_start1062, "Instruction") - return result1063 + result1071 = _t1861 + record_span!(parser, span_start1070, "Instruction") + return result1071 end function parse_assign(parser::ParserState)::Proto.Assign - span_start1067 = span_start(parser) + span_start1075 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "assign") - _t1860 = parse_relation_id(parser) - relation_id1064 = _t1860 - _t1861 = parse_abstraction(parser) - abstraction1065 = _t1861 + _t1876 = parse_relation_id(parser) + relation_id1072 = _t1876 + _t1877 = parse_abstraction(parser) + abstraction1073 = _t1877 if match_lookahead_literal(parser, "(", 0) - _t1863 = parse_attrs(parser) - _t1862 = _t1863 + _t1879 = parse_attrs(parser) + _t1878 = _t1879 else - _t1862 = nothing + _t1878 = nothing end - attrs1066 = _t1862 + attrs1074 = _t1878 consume_literal!(parser, ")") - _t1864 = Proto.Assign(name=relation_id1064, body=abstraction1065, attrs=(!isnothing(attrs1066) ? attrs1066 : Proto.Attribute[])) - result1068 = _t1864 - record_span!(parser, span_start1067, "Assign") - return result1068 + _t1880 = Proto.Assign(name=relation_id1072, body=abstraction1073, attrs=(!isnothing(attrs1074) ? attrs1074 : Proto.Attribute[])) + result1076 = _t1880 + record_span!(parser, span_start1075, "Assign") + return result1076 end function parse_upsert(parser::ParserState)::Proto.Upsert - span_start1072 = span_start(parser) + span_start1080 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "upsert") - _t1865 = parse_relation_id(parser) - relation_id1069 = _t1865 - _t1866 = parse_abstraction_with_arity(parser) - abstraction_with_arity1070 = _t1866 + _t1881 = parse_relation_id(parser) + relation_id1077 = _t1881 + _t1882 = parse_abstraction_with_arity(parser) + abstraction_with_arity1078 = _t1882 if match_lookahead_literal(parser, "(", 0) - _t1868 = parse_attrs(parser) - _t1867 = _t1868 + _t1884 = parse_attrs(parser) + _t1883 = _t1884 else - _t1867 = nothing + _t1883 = nothing end - attrs1071 = _t1867 + attrs1079 = _t1883 consume_literal!(parser, ")") - _t1869 = Proto.Upsert(name=relation_id1069, body=abstraction_with_arity1070[1], attrs=(!isnothing(attrs1071) ? attrs1071 : Proto.Attribute[]), value_arity=abstraction_with_arity1070[2]) - result1073 = _t1869 - record_span!(parser, span_start1072, "Upsert") - return result1073 + _t1885 = Proto.Upsert(name=relation_id1077, body=abstraction_with_arity1078[1], attrs=(!isnothing(attrs1079) ? attrs1079 : Proto.Attribute[]), value_arity=abstraction_with_arity1078[2]) + result1081 = _t1885 + record_span!(parser, span_start1080, "Upsert") + return result1081 end function parse_abstraction_with_arity(parser::ParserState)::Tuple{Proto.Abstraction, Int64} consume_literal!(parser, "(") - _t1870 = parse_bindings(parser) - bindings1074 = _t1870 - _t1871 = parse_formula(parser) - formula1075 = _t1871 + _t1886 = parse_bindings(parser) + bindings1082 = _t1886 + _t1887 = parse_formula(parser) + formula1083 = _t1887 consume_literal!(parser, ")") - _t1872 = Proto.Abstraction(vars=vcat(bindings1074[1], !isnothing(bindings1074[2]) ? bindings1074[2] : []), value=formula1075) - return (_t1872, length(bindings1074[2]),) + _t1888 = Proto.Abstraction(vars=vcat(bindings1082[1], !isnothing(bindings1082[2]) ? bindings1082[2] : []), value=formula1083) + return (_t1888, length(bindings1082[2]),) end function parse_break(parser::ParserState)::Proto.Break - span_start1079 = span_start(parser) + span_start1087 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "break") - _t1873 = parse_relation_id(parser) - relation_id1076 = _t1873 - _t1874 = parse_abstraction(parser) - abstraction1077 = _t1874 + _t1889 = parse_relation_id(parser) + relation_id1084 = _t1889 + _t1890 = parse_abstraction(parser) + abstraction1085 = _t1890 if match_lookahead_literal(parser, "(", 0) - _t1876 = parse_attrs(parser) - _t1875 = _t1876 + _t1892 = parse_attrs(parser) + _t1891 = _t1892 else - _t1875 = nothing + _t1891 = nothing end - attrs1078 = _t1875 + attrs1086 = _t1891 consume_literal!(parser, ")") - _t1877 = Proto.Break(name=relation_id1076, body=abstraction1077, attrs=(!isnothing(attrs1078) ? attrs1078 : Proto.Attribute[])) - result1080 = _t1877 - record_span!(parser, span_start1079, "Break") - return result1080 + _t1893 = Proto.Break(name=relation_id1084, body=abstraction1085, attrs=(!isnothing(attrs1086) ? attrs1086 : Proto.Attribute[])) + result1088 = _t1893 + record_span!(parser, span_start1087, "Break") + return result1088 end function parse_monoid_def(parser::ParserState)::Proto.MonoidDef - span_start1085 = span_start(parser) + span_start1093 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "monoid") - _t1878 = parse_monoid(parser) - monoid1081 = _t1878 - _t1879 = parse_relation_id(parser) - relation_id1082 = _t1879 - _t1880 = parse_abstraction_with_arity(parser) - abstraction_with_arity1083 = _t1880 + _t1894 = parse_monoid(parser) + monoid1089 = _t1894 + _t1895 = parse_relation_id(parser) + relation_id1090 = _t1895 + _t1896 = parse_abstraction_with_arity(parser) + abstraction_with_arity1091 = _t1896 if match_lookahead_literal(parser, "(", 0) - _t1882 = parse_attrs(parser) - _t1881 = _t1882 + _t1898 = parse_attrs(parser) + _t1897 = _t1898 else - _t1881 = nothing + _t1897 = nothing end - attrs1084 = _t1881 + attrs1092 = _t1897 consume_literal!(parser, ")") - _t1883 = Proto.MonoidDef(monoid=monoid1081, name=relation_id1082, body=abstraction_with_arity1083[1], attrs=(!isnothing(attrs1084) ? attrs1084 : Proto.Attribute[]), value_arity=abstraction_with_arity1083[2]) - result1086 = _t1883 - record_span!(parser, span_start1085, "MonoidDef") - return result1086 + _t1899 = Proto.MonoidDef(monoid=monoid1089, name=relation_id1090, body=abstraction_with_arity1091[1], attrs=(!isnothing(attrs1092) ? attrs1092 : Proto.Attribute[]), value_arity=abstraction_with_arity1091[2]) + result1094 = _t1899 + record_span!(parser, span_start1093, "MonoidDef") + return result1094 end function parse_monoid(parser::ParserState)::Proto.Monoid - span_start1092 = span_start(parser) + span_start1100 = span_start(parser) if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "sum", 1) - _t1885 = 3 + _t1901 = 3 else if match_lookahead_literal(parser, "or", 1) - _t1886 = 0 + _t1902 = 0 else if match_lookahead_literal(parser, "min", 1) - _t1887 = 1 + _t1903 = 1 else if match_lookahead_literal(parser, "max", 1) - _t1888 = 2 + _t1904 = 2 else - _t1888 = -1 + _t1904 = -1 end - _t1887 = _t1888 + _t1903 = _t1904 end - _t1886 = _t1887 + _t1902 = _t1903 end - _t1885 = _t1886 + _t1901 = _t1902 end - _t1884 = _t1885 + _t1900 = _t1901 else - _t1884 = -1 + _t1900 = -1 end - prediction1087 = _t1884 - if prediction1087 == 3 - _t1890 = parse_sum_monoid(parser) - sum_monoid1091 = _t1890 - _t1891 = Proto.Monoid(value=OneOf(:sum_monoid, sum_monoid1091)) - _t1889 = _t1891 + prediction1095 = _t1900 + if prediction1095 == 3 + _t1906 = parse_sum_monoid(parser) + sum_monoid1099 = _t1906 + _t1907 = Proto.Monoid(value=OneOf(:sum_monoid, sum_monoid1099)) + _t1905 = _t1907 else - if prediction1087 == 2 - _t1893 = parse_max_monoid(parser) - max_monoid1090 = _t1893 - _t1894 = Proto.Monoid(value=OneOf(:max_monoid, max_monoid1090)) - _t1892 = _t1894 + if prediction1095 == 2 + _t1909 = parse_max_monoid(parser) + max_monoid1098 = _t1909 + _t1910 = Proto.Monoid(value=OneOf(:max_monoid, max_monoid1098)) + _t1908 = _t1910 else - if prediction1087 == 1 - _t1896 = parse_min_monoid(parser) - min_monoid1089 = _t1896 - _t1897 = Proto.Monoid(value=OneOf(:min_monoid, min_monoid1089)) - _t1895 = _t1897 + if prediction1095 == 1 + _t1912 = parse_min_monoid(parser) + min_monoid1097 = _t1912 + _t1913 = Proto.Monoid(value=OneOf(:min_monoid, min_monoid1097)) + _t1911 = _t1913 else - if prediction1087 == 0 - _t1899 = parse_or_monoid(parser) - or_monoid1088 = _t1899 - _t1900 = Proto.Monoid(value=OneOf(:or_monoid, or_monoid1088)) - _t1898 = _t1900 + if prediction1095 == 0 + _t1915 = parse_or_monoid(parser) + or_monoid1096 = _t1915 + _t1916 = Proto.Monoid(value=OneOf(:or_monoid, or_monoid1096)) + _t1914 = _t1916 else throw(ParseError("Unexpected token in monoid" * ": " * string(lookahead(parser, 0)))) end - _t1895 = _t1898 + _t1911 = _t1914 end - _t1892 = _t1895 + _t1908 = _t1911 end - _t1889 = _t1892 + _t1905 = _t1908 end - result1093 = _t1889 - record_span!(parser, span_start1092, "Monoid") - return result1093 + result1101 = _t1905 + record_span!(parser, span_start1100, "Monoid") + return result1101 end function parse_or_monoid(parser::ParserState)::Proto.OrMonoid - span_start1094 = span_start(parser) + span_start1102 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "or") consume_literal!(parser, ")") - _t1901 = Proto.OrMonoid() - result1095 = _t1901 - record_span!(parser, span_start1094, "OrMonoid") - return result1095 + _t1917 = Proto.OrMonoid() + result1103 = _t1917 + record_span!(parser, span_start1102, "OrMonoid") + return result1103 end function parse_min_monoid(parser::ParserState)::Proto.MinMonoid - span_start1097 = span_start(parser) + span_start1105 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "min") - _t1902 = parse_type(parser) - type1096 = _t1902 + _t1918 = parse_type(parser) + type1104 = _t1918 consume_literal!(parser, ")") - _t1903 = Proto.MinMonoid(var"#type"=type1096) - result1098 = _t1903 - record_span!(parser, span_start1097, "MinMonoid") - return result1098 + _t1919 = Proto.MinMonoid(var"#type"=type1104) + result1106 = _t1919 + record_span!(parser, span_start1105, "MinMonoid") + return result1106 end function parse_max_monoid(parser::ParserState)::Proto.MaxMonoid - span_start1100 = span_start(parser) + span_start1108 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "max") - _t1904 = parse_type(parser) - type1099 = _t1904 + _t1920 = parse_type(parser) + type1107 = _t1920 consume_literal!(parser, ")") - _t1905 = Proto.MaxMonoid(var"#type"=type1099) - result1101 = _t1905 - record_span!(parser, span_start1100, "MaxMonoid") - return result1101 + _t1921 = Proto.MaxMonoid(var"#type"=type1107) + result1109 = _t1921 + record_span!(parser, span_start1108, "MaxMonoid") + return result1109 end function parse_sum_monoid(parser::ParserState)::Proto.SumMonoid - span_start1103 = span_start(parser) + span_start1111 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "sum") - _t1906 = parse_type(parser) - type1102 = _t1906 + _t1922 = parse_type(parser) + type1110 = _t1922 consume_literal!(parser, ")") - _t1907 = Proto.SumMonoid(var"#type"=type1102) - result1104 = _t1907 - record_span!(parser, span_start1103, "SumMonoid") - return result1104 + _t1923 = Proto.SumMonoid(var"#type"=type1110) + result1112 = _t1923 + record_span!(parser, span_start1111, "SumMonoid") + return result1112 end function parse_monus_def(parser::ParserState)::Proto.MonusDef - span_start1109 = span_start(parser) + span_start1117 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "monus") - _t1908 = parse_monoid(parser) - monoid1105 = _t1908 - _t1909 = parse_relation_id(parser) - relation_id1106 = _t1909 - _t1910 = parse_abstraction_with_arity(parser) - abstraction_with_arity1107 = _t1910 + _t1924 = parse_monoid(parser) + monoid1113 = _t1924 + _t1925 = parse_relation_id(parser) + relation_id1114 = _t1925 + _t1926 = parse_abstraction_with_arity(parser) + abstraction_with_arity1115 = _t1926 if match_lookahead_literal(parser, "(", 0) - _t1912 = parse_attrs(parser) - _t1911 = _t1912 + _t1928 = parse_attrs(parser) + _t1927 = _t1928 else - _t1911 = nothing + _t1927 = nothing end - attrs1108 = _t1911 + attrs1116 = _t1927 consume_literal!(parser, ")") - _t1913 = Proto.MonusDef(monoid=monoid1105, name=relation_id1106, body=abstraction_with_arity1107[1], attrs=(!isnothing(attrs1108) ? attrs1108 : Proto.Attribute[]), value_arity=abstraction_with_arity1107[2]) - result1110 = _t1913 - record_span!(parser, span_start1109, "MonusDef") - return result1110 + _t1929 = Proto.MonusDef(monoid=monoid1113, name=relation_id1114, body=abstraction_with_arity1115[1], attrs=(!isnothing(attrs1116) ? attrs1116 : Proto.Attribute[]), value_arity=abstraction_with_arity1115[2]) + result1118 = _t1929 + record_span!(parser, span_start1117, "MonusDef") + return result1118 end function parse_constraint(parser::ParserState)::Proto.Constraint - span_start1115 = span_start(parser) + span_start1123 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "functional_dependency") - _t1914 = parse_relation_id(parser) - relation_id1111 = _t1914 - _t1915 = parse_abstraction(parser) - abstraction1112 = _t1915 - _t1916 = parse_functional_dependency_keys(parser) - functional_dependency_keys1113 = _t1916 - _t1917 = parse_functional_dependency_values(parser) - functional_dependency_values1114 = _t1917 + _t1930 = parse_relation_id(parser) + relation_id1119 = _t1930 + _t1931 = parse_abstraction(parser) + abstraction1120 = _t1931 + _t1932 = parse_functional_dependency_keys(parser) + functional_dependency_keys1121 = _t1932 + _t1933 = parse_functional_dependency_values(parser) + functional_dependency_values1122 = _t1933 consume_literal!(parser, ")") - _t1918 = Proto.FunctionalDependency(guard=abstraction1112, keys=functional_dependency_keys1113, values=functional_dependency_values1114) - _t1919 = Proto.Constraint(constraint_type=OneOf(:functional_dependency, _t1918), name=relation_id1111) - result1116 = _t1919 - record_span!(parser, span_start1115, "Constraint") - return result1116 + _t1934 = Proto.FunctionalDependency(guard=abstraction1120, keys=functional_dependency_keys1121, values=functional_dependency_values1122) + _t1935 = Proto.Constraint(constraint_type=OneOf(:functional_dependency, _t1934), name=relation_id1119) + result1124 = _t1935 + record_span!(parser, span_start1123, "Constraint") + return result1124 end function parse_functional_dependency_keys(parser::ParserState)::Vector{Proto.Var} consume_literal!(parser, "(") consume_literal!(parser, "keys") - xs1117 = Proto.Var[] - cond1118 = match_lookahead_terminal(parser, "SYMBOL", 0) - while cond1118 - _t1920 = parse_var(parser) - item1119 = _t1920 - push!(xs1117, item1119) - cond1118 = match_lookahead_terminal(parser, "SYMBOL", 0) + xs1125 = Proto.Var[] + cond1126 = match_lookahead_terminal(parser, "SYMBOL", 0) + while cond1126 + _t1936 = parse_var(parser) + item1127 = _t1936 + push!(xs1125, item1127) + cond1126 = match_lookahead_terminal(parser, "SYMBOL", 0) end - vars1120 = xs1117 + vars1128 = xs1125 consume_literal!(parser, ")") - return vars1120 + return vars1128 end function parse_functional_dependency_values(parser::ParserState)::Vector{Proto.Var} consume_literal!(parser, "(") consume_literal!(parser, "values") - xs1121 = Proto.Var[] - cond1122 = match_lookahead_terminal(parser, "SYMBOL", 0) - while cond1122 - _t1921 = parse_var(parser) - item1123 = _t1921 - push!(xs1121, item1123) - cond1122 = match_lookahead_terminal(parser, "SYMBOL", 0) + xs1129 = Proto.Var[] + cond1130 = match_lookahead_terminal(parser, "SYMBOL", 0) + while cond1130 + _t1937 = parse_var(parser) + item1131 = _t1937 + push!(xs1129, item1131) + cond1130 = match_lookahead_terminal(parser, "SYMBOL", 0) end - vars1124 = xs1121 + vars1132 = xs1129 consume_literal!(parser, ")") - return vars1124 + return vars1132 end function parse_data(parser::ParserState)::Proto.Data - span_start1130 = span_start(parser) + span_start1138 = span_start(parser) if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "iceberg_data", 1) - _t1923 = 3 + _t1939 = 3 else if match_lookahead_literal(parser, "edb", 1) - _t1924 = 0 + _t1940 = 0 else if match_lookahead_literal(parser, "csv_data", 1) - _t1925 = 2 + _t1941 = 2 else if match_lookahead_literal(parser, "betree_relation", 1) - _t1926 = 1 + _t1942 = 1 else - _t1926 = -1 + _t1942 = -1 end - _t1925 = _t1926 + _t1941 = _t1942 end - _t1924 = _t1925 + _t1940 = _t1941 end - _t1923 = _t1924 + _t1939 = _t1940 end - _t1922 = _t1923 + _t1938 = _t1939 else - _t1922 = -1 + _t1938 = -1 end - prediction1125 = _t1922 - if prediction1125 == 3 - _t1928 = parse_iceberg_data(parser) - iceberg_data1129 = _t1928 - _t1929 = Proto.Data(data_type=OneOf(:iceberg_data, iceberg_data1129)) - _t1927 = _t1929 + prediction1133 = _t1938 + if prediction1133 == 3 + _t1944 = parse_iceberg_data(parser) + iceberg_data1137 = _t1944 + _t1945 = Proto.Data(data_type=OneOf(:iceberg_data, iceberg_data1137)) + _t1943 = _t1945 else - if prediction1125 == 2 - _t1931 = parse_csv_data(parser) - csv_data1128 = _t1931 - _t1932 = Proto.Data(data_type=OneOf(:csv_data, csv_data1128)) - _t1930 = _t1932 + if prediction1133 == 2 + _t1947 = parse_csv_data(parser) + csv_data1136 = _t1947 + _t1948 = Proto.Data(data_type=OneOf(:csv_data, csv_data1136)) + _t1946 = _t1948 else - if prediction1125 == 1 - _t1934 = parse_betree_relation(parser) - betree_relation1127 = _t1934 - _t1935 = Proto.Data(data_type=OneOf(:betree_relation, betree_relation1127)) - _t1933 = _t1935 + if prediction1133 == 1 + _t1950 = parse_betree_relation(parser) + betree_relation1135 = _t1950 + _t1951 = Proto.Data(data_type=OneOf(:betree_relation, betree_relation1135)) + _t1949 = _t1951 else - if prediction1125 == 0 - _t1937 = parse_edb(parser) - edb1126 = _t1937 - _t1938 = Proto.Data(data_type=OneOf(:edb, edb1126)) - _t1936 = _t1938 + if prediction1133 == 0 + _t1953 = parse_edb(parser) + edb1134 = _t1953 + _t1954 = Proto.Data(data_type=OneOf(:edb, edb1134)) + _t1952 = _t1954 else throw(ParseError("Unexpected token in data" * ": " * string(lookahead(parser, 0)))) end - _t1933 = _t1936 + _t1949 = _t1952 end - _t1930 = _t1933 + _t1946 = _t1949 end - _t1927 = _t1930 + _t1943 = _t1946 end - result1131 = _t1927 - record_span!(parser, span_start1130, "Data") - return result1131 + result1139 = _t1943 + record_span!(parser, span_start1138, "Data") + return result1139 end function parse_edb(parser::ParserState)::Proto.EDB - span_start1135 = span_start(parser) + span_start1143 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "edb") - _t1939 = parse_relation_id(parser) - relation_id1132 = _t1939 - _t1940 = parse_edb_path(parser) - edb_path1133 = _t1940 - _t1941 = parse_edb_types(parser) - edb_types1134 = _t1941 + _t1955 = parse_relation_id(parser) + relation_id1140 = _t1955 + _t1956 = parse_edb_path(parser) + edb_path1141 = _t1956 + _t1957 = parse_edb_types(parser) + edb_types1142 = _t1957 consume_literal!(parser, ")") - _t1942 = Proto.EDB(target_id=relation_id1132, path=edb_path1133, types=edb_types1134) - result1136 = _t1942 - record_span!(parser, span_start1135, "EDB") - return result1136 + _t1958 = Proto.EDB(target_id=relation_id1140, path=edb_path1141, types=edb_types1142) + result1144 = _t1958 + record_span!(parser, span_start1143, "EDB") + return result1144 end function parse_edb_path(parser::ParserState)::Vector{String} consume_literal!(parser, "[") - xs1137 = String[] - cond1138 = match_lookahead_terminal(parser, "STRING", 0) - while cond1138 - item1139 = consume_terminal!(parser, "STRING") - push!(xs1137, item1139) - cond1138 = match_lookahead_terminal(parser, "STRING", 0) + xs1145 = String[] + cond1146 = match_lookahead_terminal(parser, "STRING", 0) + while cond1146 + item1147 = consume_terminal!(parser, "STRING") + push!(xs1145, item1147) + cond1146 = match_lookahead_terminal(parser, "STRING", 0) end - strings1140 = xs1137 + strings1148 = xs1145 consume_literal!(parser, "]") - return strings1140 + return strings1148 end function parse_edb_types(parser::ParserState)::Vector{Proto.var"#Type"} consume_literal!(parser, "[") - xs1141 = Proto.var"#Type"[] - cond1142 = (((((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "BOOLEAN", 0)) || match_lookahead_literal(parser, "DATE", 0)) || match_lookahead_literal(parser, "DATETIME", 0)) || match_lookahead_literal(parser, "FLOAT", 0)) || match_lookahead_literal(parser, "FLOAT32", 0)) || match_lookahead_literal(parser, "INT", 0)) || match_lookahead_literal(parser, "INT128", 0)) || match_lookahead_literal(parser, "INT32", 0)) || match_lookahead_literal(parser, "MISSING", 0)) || match_lookahead_literal(parser, "STRING", 0)) || match_lookahead_literal(parser, "UINT128", 0)) || match_lookahead_literal(parser, "UINT32", 0)) || match_lookahead_literal(parser, "UNKNOWN", 0)) - while cond1142 - _t1943 = parse_type(parser) - item1143 = _t1943 - push!(xs1141, item1143) - cond1142 = (((((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "BOOLEAN", 0)) || match_lookahead_literal(parser, "DATE", 0)) || match_lookahead_literal(parser, "DATETIME", 0)) || match_lookahead_literal(parser, "FLOAT", 0)) || match_lookahead_literal(parser, "FLOAT32", 0)) || match_lookahead_literal(parser, "INT", 0)) || match_lookahead_literal(parser, "INT128", 0)) || match_lookahead_literal(parser, "INT32", 0)) || match_lookahead_literal(parser, "MISSING", 0)) || match_lookahead_literal(parser, "STRING", 0)) || match_lookahead_literal(parser, "UINT128", 0)) || match_lookahead_literal(parser, "UINT32", 0)) || match_lookahead_literal(parser, "UNKNOWN", 0)) + xs1149 = Proto.var"#Type"[] + cond1150 = (((((((((((((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 cond1150 + _t1959 = parse_type(parser) + item1151 = _t1959 + push!(xs1149, item1151) + cond1150 = (((((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "BOOLEAN", 0)) || match_lookahead_literal(parser, "DATE", 0)) || match_lookahead_literal(parser, "DATETIME", 0)) || match_lookahead_literal(parser, "FLOAT", 0)) || match_lookahead_literal(parser, "FLOAT32", 0)) || match_lookahead_literal(parser, "INT", 0)) || match_lookahead_literal(parser, "INT128", 0)) || match_lookahead_literal(parser, "INT32", 0)) || match_lookahead_literal(parser, "MISSING", 0)) || match_lookahead_literal(parser, "STRING", 0)) || match_lookahead_literal(parser, "UINT128", 0)) || match_lookahead_literal(parser, "UINT32", 0)) || match_lookahead_literal(parser, "UNKNOWN", 0)) end - types1144 = xs1141 + types1152 = xs1149 consume_literal!(parser, "]") - return types1144 + return types1152 end function parse_betree_relation(parser::ParserState)::Proto.BeTreeRelation - span_start1147 = span_start(parser) + span_start1155 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "betree_relation") - _t1944 = parse_relation_id(parser) - relation_id1145 = _t1944 - _t1945 = parse_betree_info(parser) - betree_info1146 = _t1945 + _t1960 = parse_relation_id(parser) + relation_id1153 = _t1960 + _t1961 = parse_betree_info(parser) + betree_info1154 = _t1961 consume_literal!(parser, ")") - _t1946 = Proto.BeTreeRelation(name=relation_id1145, relation_info=betree_info1146) - result1148 = _t1946 - record_span!(parser, span_start1147, "BeTreeRelation") - return result1148 + _t1962 = Proto.BeTreeRelation(name=relation_id1153, relation_info=betree_info1154) + result1156 = _t1962 + record_span!(parser, span_start1155, "BeTreeRelation") + return result1156 end function parse_betree_info(parser::ParserState)::Proto.BeTreeInfo - span_start1152 = span_start(parser) + span_start1160 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "betree_info") - _t1947 = parse_betree_info_key_types(parser) - betree_info_key_types1149 = _t1947 - _t1948 = parse_betree_info_value_types(parser) - betree_info_value_types1150 = _t1948 - _t1949 = parse_config_dict(parser) - config_dict1151 = _t1949 + _t1963 = parse_betree_info_key_types(parser) + betree_info_key_types1157 = _t1963 + _t1964 = parse_betree_info_value_types(parser) + betree_info_value_types1158 = _t1964 + _t1965 = parse_config_dict(parser) + config_dict1159 = _t1965 consume_literal!(parser, ")") - _t1950 = construct_betree_info(parser, betree_info_key_types1149, betree_info_value_types1150, config_dict1151) - result1153 = _t1950 - record_span!(parser, span_start1152, "BeTreeInfo") - return result1153 + _t1966 = construct_betree_info(parser, betree_info_key_types1157, betree_info_value_types1158, config_dict1159) + result1161 = _t1966 + record_span!(parser, span_start1160, "BeTreeInfo") + return result1161 end function parse_betree_info_key_types(parser::ParserState)::Vector{Proto.var"#Type"} consume_literal!(parser, "(") consume_literal!(parser, "key_types") - xs1154 = Proto.var"#Type"[] - cond1155 = (((((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "BOOLEAN", 0)) || match_lookahead_literal(parser, "DATE", 0)) || match_lookahead_literal(parser, "DATETIME", 0)) || match_lookahead_literal(parser, "FLOAT", 0)) || match_lookahead_literal(parser, "FLOAT32", 0)) || match_lookahead_literal(parser, "INT", 0)) || match_lookahead_literal(parser, "INT128", 0)) || match_lookahead_literal(parser, "INT32", 0)) || match_lookahead_literal(parser, "MISSING", 0)) || match_lookahead_literal(parser, "STRING", 0)) || match_lookahead_literal(parser, "UINT128", 0)) || match_lookahead_literal(parser, "UINT32", 0)) || match_lookahead_literal(parser, "UNKNOWN", 0)) - while cond1155 - _t1951 = parse_type(parser) - item1156 = _t1951 - push!(xs1154, item1156) - cond1155 = (((((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "BOOLEAN", 0)) || match_lookahead_literal(parser, "DATE", 0)) || match_lookahead_literal(parser, "DATETIME", 0)) || match_lookahead_literal(parser, "FLOAT", 0)) || match_lookahead_literal(parser, "FLOAT32", 0)) || match_lookahead_literal(parser, "INT", 0)) || match_lookahead_literal(parser, "INT128", 0)) || match_lookahead_literal(parser, "INT32", 0)) || match_lookahead_literal(parser, "MISSING", 0)) || match_lookahead_literal(parser, "STRING", 0)) || match_lookahead_literal(parser, "UINT128", 0)) || match_lookahead_literal(parser, "UINT32", 0)) || match_lookahead_literal(parser, "UNKNOWN", 0)) + xs1162 = Proto.var"#Type"[] + cond1163 = (((((((((((((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 cond1163 + _t1967 = parse_type(parser) + item1164 = _t1967 + push!(xs1162, item1164) + cond1163 = (((((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "BOOLEAN", 0)) || match_lookahead_literal(parser, "DATE", 0)) || match_lookahead_literal(parser, "DATETIME", 0)) || match_lookahead_literal(parser, "FLOAT", 0)) || match_lookahead_literal(parser, "FLOAT32", 0)) || match_lookahead_literal(parser, "INT", 0)) || match_lookahead_literal(parser, "INT128", 0)) || match_lookahead_literal(parser, "INT32", 0)) || match_lookahead_literal(parser, "MISSING", 0)) || match_lookahead_literal(parser, "STRING", 0)) || match_lookahead_literal(parser, "UINT128", 0)) || match_lookahead_literal(parser, "UINT32", 0)) || match_lookahead_literal(parser, "UNKNOWN", 0)) end - types1157 = xs1154 + types1165 = xs1162 consume_literal!(parser, ")") - return types1157 + return types1165 end function parse_betree_info_value_types(parser::ParserState)::Vector{Proto.var"#Type"} consume_literal!(parser, "(") consume_literal!(parser, "value_types") - xs1158 = Proto.var"#Type"[] - cond1159 = (((((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "BOOLEAN", 0)) || match_lookahead_literal(parser, "DATE", 0)) || match_lookahead_literal(parser, "DATETIME", 0)) || match_lookahead_literal(parser, "FLOAT", 0)) || match_lookahead_literal(parser, "FLOAT32", 0)) || match_lookahead_literal(parser, "INT", 0)) || match_lookahead_literal(parser, "INT128", 0)) || match_lookahead_literal(parser, "INT32", 0)) || match_lookahead_literal(parser, "MISSING", 0)) || match_lookahead_literal(parser, "STRING", 0)) || match_lookahead_literal(parser, "UINT128", 0)) || match_lookahead_literal(parser, "UINT32", 0)) || match_lookahead_literal(parser, "UNKNOWN", 0)) - while cond1159 - _t1952 = parse_type(parser) - item1160 = _t1952 - push!(xs1158, item1160) - cond1159 = (((((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "BOOLEAN", 0)) || match_lookahead_literal(parser, "DATE", 0)) || match_lookahead_literal(parser, "DATETIME", 0)) || match_lookahead_literal(parser, "FLOAT", 0)) || match_lookahead_literal(parser, "FLOAT32", 0)) || match_lookahead_literal(parser, "INT", 0)) || match_lookahead_literal(parser, "INT128", 0)) || match_lookahead_literal(parser, "INT32", 0)) || match_lookahead_literal(parser, "MISSING", 0)) || match_lookahead_literal(parser, "STRING", 0)) || match_lookahead_literal(parser, "UINT128", 0)) || match_lookahead_literal(parser, "UINT32", 0)) || match_lookahead_literal(parser, "UNKNOWN", 0)) + xs1166 = Proto.var"#Type"[] + cond1167 = (((((((((((((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 cond1167 + _t1968 = parse_type(parser) + item1168 = _t1968 + push!(xs1166, item1168) + cond1167 = (((((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "BOOLEAN", 0)) || match_lookahead_literal(parser, "DATE", 0)) || match_lookahead_literal(parser, "DATETIME", 0)) || match_lookahead_literal(parser, "FLOAT", 0)) || match_lookahead_literal(parser, "FLOAT32", 0)) || match_lookahead_literal(parser, "INT", 0)) || match_lookahead_literal(parser, "INT128", 0)) || match_lookahead_literal(parser, "INT32", 0)) || match_lookahead_literal(parser, "MISSING", 0)) || match_lookahead_literal(parser, "STRING", 0)) || match_lookahead_literal(parser, "UINT128", 0)) || match_lookahead_literal(parser, "UINT32", 0)) || match_lookahead_literal(parser, "UNKNOWN", 0)) end - types1161 = xs1158 + types1169 = xs1166 consume_literal!(parser, ")") - return types1161 + return types1169 end function parse_csv_data(parser::ParserState)::Proto.CSVData - span_start1166 = span_start(parser) + span_start1174 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "csv_data") - _t1953 = parse_csvlocator(parser) - csvlocator1162 = _t1953 - _t1954 = parse_csv_config(parser) - csv_config1163 = _t1954 - _t1955 = parse_gnf_columns(parser) - gnf_columns1164 = _t1955 - _t1956 = parse_csv_asof(parser) - csv_asof1165 = _t1956 + _t1969 = parse_csvlocator(parser) + csvlocator1170 = _t1969 + _t1970 = parse_csv_config(parser) + csv_config1171 = _t1970 + _t1971 = parse_gnf_columns(parser) + gnf_columns1172 = _t1971 + _t1972 = parse_csv_asof(parser) + csv_asof1173 = _t1972 consume_literal!(parser, ")") - _t1957 = Proto.CSVData(locator=csvlocator1162, config=csv_config1163, columns=gnf_columns1164, asof=csv_asof1165) - result1167 = _t1957 - record_span!(parser, span_start1166, "CSVData") - return result1167 + _t1973 = Proto.CSVData(locator=csvlocator1170, config=csv_config1171, columns=gnf_columns1172, asof=csv_asof1173) + result1175 = _t1973 + record_span!(parser, span_start1174, "CSVData") + return result1175 end function parse_csvlocator(parser::ParserState)::Proto.CSVLocator - span_start1170 = span_start(parser) + span_start1178 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "csv_locator") if (match_lookahead_literal(parser, "(", 0) && match_lookahead_literal(parser, "paths", 1)) - _t1959 = parse_csv_locator_paths(parser) - _t1958 = _t1959 + _t1975 = parse_csv_locator_paths(parser) + _t1974 = _t1975 else - _t1958 = nothing + _t1974 = nothing end - csv_locator_paths1168 = _t1958 + csv_locator_paths1176 = _t1974 if match_lookahead_literal(parser, "(", 0) - _t1961 = parse_csv_locator_inline_data(parser) - _t1960 = _t1961 + _t1977 = parse_csv_locator_inline_data(parser) + _t1976 = _t1977 else - _t1960 = nothing + _t1976 = nothing end - csv_locator_inline_data1169 = _t1960 + csv_locator_inline_data1177 = _t1976 consume_literal!(parser, ")") - _t1962 = Proto.CSVLocator(paths=(!isnothing(csv_locator_paths1168) ? csv_locator_paths1168 : String[]), inline_data=Vector{UInt8}((!isnothing(csv_locator_inline_data1169) ? csv_locator_inline_data1169 : ""))) - result1171 = _t1962 - record_span!(parser, span_start1170, "CSVLocator") - return result1171 + _t1978 = Proto.CSVLocator(paths=(!isnothing(csv_locator_paths1176) ? csv_locator_paths1176 : String[]), inline_data=Vector{UInt8}((!isnothing(csv_locator_inline_data1177) ? csv_locator_inline_data1177 : ""))) + result1179 = _t1978 + record_span!(parser, span_start1178, "CSVLocator") + return result1179 end function parse_csv_locator_paths(parser::ParserState)::Vector{String} consume_literal!(parser, "(") consume_literal!(parser, "paths") - xs1172 = String[] - cond1173 = match_lookahead_terminal(parser, "STRING", 0) - while cond1173 - item1174 = consume_terminal!(parser, "STRING") - push!(xs1172, item1174) - cond1173 = match_lookahead_terminal(parser, "STRING", 0) + xs1180 = String[] + cond1181 = match_lookahead_terminal(parser, "STRING", 0) + while cond1181 + item1182 = consume_terminal!(parser, "STRING") + push!(xs1180, item1182) + cond1181 = match_lookahead_terminal(parser, "STRING", 0) end - strings1175 = xs1172 + strings1183 = xs1180 consume_literal!(parser, ")") - return strings1175 + return strings1183 end function parse_csv_locator_inline_data(parser::ParserState)::String consume_literal!(parser, "(") consume_literal!(parser, "inline_data") - formatted_string1176 = consume_terminal!(parser, "STRING") + formatted_string1184 = consume_terminal!(parser, "STRING") consume_literal!(parser, ")") - return formatted_string1176 + return formatted_string1184 end function parse_csv_config(parser::ParserState)::Proto.CSVConfig - span_start1179 = span_start(parser) + span_start1187 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "csv_config") - _t1963 = parse_config_dict(parser) - config_dict1177 = _t1963 + _t1979 = parse_config_dict(parser) + config_dict1185 = _t1979 if match_lookahead_literal(parser, "(", 0) - _t1965 = parse__storage_integration(parser) - _t1964 = _t1965 + _t1981 = parse__storage_integration(parser) + _t1980 = _t1981 else - _t1964 = nothing + _t1980 = nothing end - _storage_integration1178 = _t1964 + _storage_integration1186 = _t1980 consume_literal!(parser, ")") - _t1966 = construct_csv_config(parser, config_dict1177, _storage_integration1178) - result1180 = _t1966 - record_span!(parser, span_start1179, "CSVConfig") - return result1180 + _t1982 = construct_csv_config(parser, config_dict1185, _storage_integration1186) + result1188 = _t1982 + record_span!(parser, span_start1187, "CSVConfig") + return result1188 end function parse__storage_integration(parser::ParserState)::Vector{Tuple{String, Proto.Value}} consume_literal!(parser, "(") consume_literal!(parser, "storage_integration") - _t1967 = parse_config_dict(parser) - config_dict1181 = _t1967 + _t1983 = parse_config_dict(parser) + config_dict1189 = _t1983 consume_literal!(parser, ")") - return config_dict1181 + return config_dict1189 end function parse_gnf_columns(parser::ParserState)::Vector{Proto.GNFColumn} consume_literal!(parser, "(") consume_literal!(parser, "columns") - xs1182 = Proto.GNFColumn[] - cond1183 = match_lookahead_literal(parser, "(", 0) - while cond1183 - _t1968 = parse_gnf_column(parser) - item1184 = _t1968 - push!(xs1182, item1184) - cond1183 = match_lookahead_literal(parser, "(", 0) + xs1190 = Proto.GNFColumn[] + cond1191 = match_lookahead_literal(parser, "(", 0) + while cond1191 + _t1984 = parse_gnf_column(parser) + item1192 = _t1984 + push!(xs1190, item1192) + cond1191 = match_lookahead_literal(parser, "(", 0) end - gnf_columns1185 = xs1182 + gnf_columns1193 = xs1190 consume_literal!(parser, ")") - return gnf_columns1185 + return gnf_columns1193 end function parse_gnf_column(parser::ParserState)::Proto.GNFColumn - span_start1192 = span_start(parser) + span_start1200 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "column") - _t1969 = parse_gnf_column_path(parser) - gnf_column_path1186 = _t1969 + _t1985 = parse_gnf_column_path(parser) + gnf_column_path1194 = _t1985 if (match_lookahead_literal(parser, ":", 0) || match_lookahead_terminal(parser, "UINT128", 0)) - _t1971 = parse_relation_id(parser) - _t1970 = _t1971 + _t1987 = parse_relation_id(parser) + _t1986 = _t1987 else - _t1970 = nothing + _t1986 = nothing end - relation_id1187 = _t1970 + relation_id1195 = _t1986 consume_literal!(parser, "[") - xs1188 = Proto.var"#Type"[] - cond1189 = (((((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "BOOLEAN", 0)) || match_lookahead_literal(parser, "DATE", 0)) || match_lookahead_literal(parser, "DATETIME", 0)) || match_lookahead_literal(parser, "FLOAT", 0)) || match_lookahead_literal(parser, "FLOAT32", 0)) || match_lookahead_literal(parser, "INT", 0)) || match_lookahead_literal(parser, "INT128", 0)) || match_lookahead_literal(parser, "INT32", 0)) || match_lookahead_literal(parser, "MISSING", 0)) || match_lookahead_literal(parser, "STRING", 0)) || match_lookahead_literal(parser, "UINT128", 0)) || match_lookahead_literal(parser, "UINT32", 0)) || match_lookahead_literal(parser, "UNKNOWN", 0)) - while cond1189 - _t1972 = parse_type(parser) - item1190 = _t1972 - push!(xs1188, item1190) - cond1189 = (((((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "BOOLEAN", 0)) || match_lookahead_literal(parser, "DATE", 0)) || match_lookahead_literal(parser, "DATETIME", 0)) || match_lookahead_literal(parser, "FLOAT", 0)) || match_lookahead_literal(parser, "FLOAT32", 0)) || match_lookahead_literal(parser, "INT", 0)) || match_lookahead_literal(parser, "INT128", 0)) || match_lookahead_literal(parser, "INT32", 0)) || match_lookahead_literal(parser, "MISSING", 0)) || match_lookahead_literal(parser, "STRING", 0)) || match_lookahead_literal(parser, "UINT128", 0)) || match_lookahead_literal(parser, "UINT32", 0)) || match_lookahead_literal(parser, "UNKNOWN", 0)) + xs1196 = Proto.var"#Type"[] + cond1197 = (((((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "BOOLEAN", 0)) || match_lookahead_literal(parser, "DATE", 0)) || match_lookahead_literal(parser, "DATETIME", 0)) || match_lookahead_literal(parser, "FLOAT", 0)) || match_lookahead_literal(parser, "FLOAT32", 0)) || match_lookahead_literal(parser, "INT", 0)) || match_lookahead_literal(parser, "INT128", 0)) || match_lookahead_literal(parser, "INT32", 0)) || match_lookahead_literal(parser, "MISSING", 0)) || match_lookahead_literal(parser, "STRING", 0)) || match_lookahead_literal(parser, "UINT128", 0)) || match_lookahead_literal(parser, "UINT32", 0)) || match_lookahead_literal(parser, "UNKNOWN", 0)) + while cond1197 + _t1988 = parse_type(parser) + item1198 = _t1988 + push!(xs1196, item1198) + cond1197 = (((((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "BOOLEAN", 0)) || match_lookahead_literal(parser, "DATE", 0)) || match_lookahead_literal(parser, "DATETIME", 0)) || match_lookahead_literal(parser, "FLOAT", 0)) || match_lookahead_literal(parser, "FLOAT32", 0)) || match_lookahead_literal(parser, "INT", 0)) || match_lookahead_literal(parser, "INT128", 0)) || match_lookahead_literal(parser, "INT32", 0)) || match_lookahead_literal(parser, "MISSING", 0)) || match_lookahead_literal(parser, "STRING", 0)) || match_lookahead_literal(parser, "UINT128", 0)) || match_lookahead_literal(parser, "UINT32", 0)) || match_lookahead_literal(parser, "UNKNOWN", 0)) end - types1191 = xs1188 + types1199 = xs1196 consume_literal!(parser, "]") consume_literal!(parser, ")") - _t1973 = Proto.GNFColumn(column_path=gnf_column_path1186, target_id=relation_id1187, types=types1191) - result1193 = _t1973 - record_span!(parser, span_start1192, "GNFColumn") - return result1193 + _t1989 = Proto.GNFColumn(column_path=gnf_column_path1194, target_id=relation_id1195, types=types1199) + result1201 = _t1989 + record_span!(parser, span_start1200, "GNFColumn") + return result1201 end function parse_gnf_column_path(parser::ParserState)::Vector{String} if match_lookahead_literal(parser, "[", 0) - _t1974 = 1 + _t1990 = 1 else if match_lookahead_terminal(parser, "STRING", 0) - _t1975 = 0 + _t1991 = 0 else - _t1975 = -1 + _t1991 = -1 end - _t1974 = _t1975 + _t1990 = _t1991 end - prediction1194 = _t1974 - if prediction1194 == 1 + prediction1202 = _t1990 + if prediction1202 == 1 consume_literal!(parser, "[") - xs1196 = String[] - cond1197 = match_lookahead_terminal(parser, "STRING", 0) - while cond1197 - item1198 = consume_terminal!(parser, "STRING") - push!(xs1196, item1198) - cond1197 = match_lookahead_terminal(parser, "STRING", 0) + xs1204 = String[] + cond1205 = match_lookahead_terminal(parser, "STRING", 0) + while cond1205 + item1206 = consume_terminal!(parser, "STRING") + push!(xs1204, item1206) + cond1205 = match_lookahead_terminal(parser, "STRING", 0) end - strings1199 = xs1196 + strings1207 = xs1204 consume_literal!(parser, "]") - _t1976 = strings1199 + _t1992 = strings1207 else - if prediction1194 == 0 - string1195 = consume_terminal!(parser, "STRING") - _t1977 = String[string1195] + if prediction1202 == 0 + string1203 = consume_terminal!(parser, "STRING") + _t1993 = String[string1203] else throw(ParseError("Unexpected token in gnf_column_path" * ": " * string(lookahead(parser, 0)))) end - _t1976 = _t1977 + _t1992 = _t1993 end - return _t1976 + return _t1992 end function parse_csv_asof(parser::ParserState)::String consume_literal!(parser, "(") consume_literal!(parser, "asof") - string1200 = consume_terminal!(parser, "STRING") + string1208 = consume_terminal!(parser, "STRING") consume_literal!(parser, ")") - return string1200 + return string1208 end function parse_iceberg_data(parser::ParserState)::Proto.IcebergData - span_start1207 = span_start(parser) + span_start1215 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "iceberg_data") - _t1978 = parse_iceberg_locator(parser) - iceberg_locator1201 = _t1978 - _t1979 = parse_iceberg_catalog_config(parser) - iceberg_catalog_config1202 = _t1979 - _t1980 = parse_gnf_columns(parser) - gnf_columns1203 = _t1980 + _t1994 = parse_iceberg_locator(parser) + iceberg_locator1209 = _t1994 + _t1995 = parse_iceberg_catalog_config(parser) + iceberg_catalog_config1210 = _t1995 + _t1996 = parse_gnf_columns(parser) + gnf_columns1211 = _t1996 if (match_lookahead_literal(parser, "(", 0) && match_lookahead_literal(parser, "from_snapshot", 1)) - _t1982 = parse_iceberg_from_snapshot(parser) - _t1981 = _t1982 + _t1998 = parse_iceberg_from_snapshot(parser) + _t1997 = _t1998 else - _t1981 = nothing + _t1997 = nothing end - iceberg_from_snapshot1204 = _t1981 + iceberg_from_snapshot1212 = _t1997 if match_lookahead_literal(parser, "(", 0) - _t1984 = parse_iceberg_to_snapshot(parser) - _t1983 = _t1984 + _t2000 = parse_iceberg_to_snapshot(parser) + _t1999 = _t2000 else - _t1983 = nothing + _t1999 = nothing end - iceberg_to_snapshot1205 = _t1983 - _t1985 = parse_boolean_value(parser) - boolean_value1206 = _t1985 + iceberg_to_snapshot1213 = _t1999 + _t2001 = parse_boolean_value(parser) + boolean_value1214 = _t2001 consume_literal!(parser, ")") - _t1986 = construct_iceberg_data(parser, iceberg_locator1201, iceberg_catalog_config1202, gnf_columns1203, iceberg_from_snapshot1204, iceberg_to_snapshot1205, boolean_value1206) - result1208 = _t1986 - record_span!(parser, span_start1207, "IcebergData") - return result1208 + _t2002 = construct_iceberg_data(parser, iceberg_locator1209, iceberg_catalog_config1210, gnf_columns1211, iceberg_from_snapshot1212, iceberg_to_snapshot1213, boolean_value1214) + result1216 = _t2002 + record_span!(parser, span_start1215, "IcebergData") + return result1216 end function parse_iceberg_locator(parser::ParserState)::Proto.IcebergLocator - span_start1212 = span_start(parser) + span_start1220 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "iceberg_locator") - _t1987 = parse_iceberg_locator_table_name(parser) - iceberg_locator_table_name1209 = _t1987 - _t1988 = parse_iceberg_locator_namespace(parser) - iceberg_locator_namespace1210 = _t1988 - _t1989 = parse_iceberg_locator_warehouse(parser) - iceberg_locator_warehouse1211 = _t1989 + _t2003 = parse_iceberg_locator_table_name(parser) + iceberg_locator_table_name1217 = _t2003 + _t2004 = parse_iceberg_locator_namespace(parser) + iceberg_locator_namespace1218 = _t2004 + _t2005 = parse_iceberg_locator_warehouse(parser) + iceberg_locator_warehouse1219 = _t2005 consume_literal!(parser, ")") - _t1990 = Proto.IcebergLocator(table_name=iceberg_locator_table_name1209, namespace=iceberg_locator_namespace1210, warehouse=iceberg_locator_warehouse1211) - result1213 = _t1990 - record_span!(parser, span_start1212, "IcebergLocator") - return result1213 + _t2006 = Proto.IcebergLocator(table_name=iceberg_locator_table_name1217, namespace=iceberg_locator_namespace1218, warehouse=iceberg_locator_warehouse1219) + result1221 = _t2006 + record_span!(parser, span_start1220, "IcebergLocator") + return result1221 end function parse_iceberg_locator_table_name(parser::ParserState)::String consume_literal!(parser, "(") consume_literal!(parser, "table_name") - string1214 = consume_terminal!(parser, "STRING") + string1222 = consume_terminal!(parser, "STRING") consume_literal!(parser, ")") - return string1214 + return string1222 end function parse_iceberg_locator_namespace(parser::ParserState)::Vector{String} consume_literal!(parser, "(") consume_literal!(parser, "namespace") - xs1215 = String[] - cond1216 = match_lookahead_terminal(parser, "STRING", 0) - while cond1216 - item1217 = consume_terminal!(parser, "STRING") - push!(xs1215, item1217) - cond1216 = match_lookahead_terminal(parser, "STRING", 0) + xs1223 = String[] + cond1224 = match_lookahead_terminal(parser, "STRING", 0) + while cond1224 + item1225 = consume_terminal!(parser, "STRING") + push!(xs1223, item1225) + cond1224 = match_lookahead_terminal(parser, "STRING", 0) end - strings1218 = xs1215 + strings1226 = xs1223 consume_literal!(parser, ")") - return strings1218 + return strings1226 end function parse_iceberg_locator_warehouse(parser::ParserState)::String consume_literal!(parser, "(") consume_literal!(parser, "warehouse") - string1219 = consume_terminal!(parser, "STRING") + string1227 = consume_terminal!(parser, "STRING") consume_literal!(parser, ")") - return string1219 + return string1227 end function parse_iceberg_catalog_config(parser::ParserState)::Proto.IcebergCatalogConfig - span_start1224 = span_start(parser) + span_start1232 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "iceberg_catalog_config") - _t1991 = parse_iceberg_catalog_uri(parser) - iceberg_catalog_uri1220 = _t1991 + _t2007 = parse_iceberg_catalog_uri(parser) + iceberg_catalog_uri1228 = _t2007 if (match_lookahead_literal(parser, "(", 0) && match_lookahead_literal(parser, "scope", 1)) - _t1993 = parse_iceberg_catalog_config_scope(parser) - _t1992 = _t1993 + _t2009 = parse_iceberg_catalog_config_scope(parser) + _t2008 = _t2009 else - _t1992 = nothing + _t2008 = nothing end - iceberg_catalog_config_scope1221 = _t1992 - _t1994 = parse_iceberg_properties(parser) - iceberg_properties1222 = _t1994 - _t1995 = parse_iceberg_auth_properties(parser) - iceberg_auth_properties1223 = _t1995 + iceberg_catalog_config_scope1229 = _t2008 + _t2010 = parse_iceberg_properties(parser) + iceberg_properties1230 = _t2010 + _t2011 = parse_iceberg_auth_properties(parser) + iceberg_auth_properties1231 = _t2011 consume_literal!(parser, ")") - _t1996 = construct_iceberg_catalog_config(parser, iceberg_catalog_uri1220, iceberg_catalog_config_scope1221, iceberg_properties1222, iceberg_auth_properties1223) - result1225 = _t1996 - record_span!(parser, span_start1224, "IcebergCatalogConfig") - return result1225 + _t2012 = construct_iceberg_catalog_config(parser, iceberg_catalog_uri1228, iceberg_catalog_config_scope1229, iceberg_properties1230, iceberg_auth_properties1231) + result1233 = _t2012 + record_span!(parser, span_start1232, "IcebergCatalogConfig") + return result1233 end function parse_iceberg_catalog_uri(parser::ParserState)::String consume_literal!(parser, "(") consume_literal!(parser, "catalog_uri") - string1226 = consume_terminal!(parser, "STRING") + string1234 = consume_terminal!(parser, "STRING") consume_literal!(parser, ")") - return string1226 + return string1234 end function parse_iceberg_catalog_config_scope(parser::ParserState)::String consume_literal!(parser, "(") consume_literal!(parser, "scope") - string1227 = consume_terminal!(parser, "STRING") + string1235 = consume_terminal!(parser, "STRING") consume_literal!(parser, ")") - return string1227 + return string1235 end function parse_iceberg_properties(parser::ParserState)::Vector{Tuple{String, String}} consume_literal!(parser, "(") consume_literal!(parser, "properties") - xs1228 = Tuple{String, String}[] - cond1229 = match_lookahead_literal(parser, "(", 0) - while cond1229 - _t1997 = parse_iceberg_property_entry(parser) - item1230 = _t1997 - push!(xs1228, item1230) - cond1229 = match_lookahead_literal(parser, "(", 0) + xs1236 = Tuple{String, String}[] + cond1237 = match_lookahead_literal(parser, "(", 0) + while cond1237 + _t2013 = parse_iceberg_property_entry(parser) + item1238 = _t2013 + push!(xs1236, item1238) + cond1237 = match_lookahead_literal(parser, "(", 0) end - iceberg_property_entrys1231 = xs1228 + iceberg_property_entrys1239 = xs1236 consume_literal!(parser, ")") - return iceberg_property_entrys1231 + return iceberg_property_entrys1239 end function parse_iceberg_property_entry(parser::ParserState)::Tuple{String, String} consume_literal!(parser, "(") consume_literal!(parser, "prop") - string1232 = consume_terminal!(parser, "STRING") - string_31233 = consume_terminal!(parser, "STRING") + string1240 = consume_terminal!(parser, "STRING") + string_31241 = consume_terminal!(parser, "STRING") consume_literal!(parser, ")") - return (string1232, string_31233,) + return (string1240, string_31241,) end function parse_iceberg_auth_properties(parser::ParserState)::Vector{Tuple{String, String}} consume_literal!(parser, "(") consume_literal!(parser, "auth_properties") - xs1234 = Tuple{String, String}[] - cond1235 = match_lookahead_literal(parser, "(", 0) - while cond1235 - _t1998 = parse_iceberg_masked_property_entry(parser) - item1236 = _t1998 - push!(xs1234, item1236) - cond1235 = match_lookahead_literal(parser, "(", 0) + xs1242 = Tuple{String, String}[] + cond1243 = match_lookahead_literal(parser, "(", 0) + while cond1243 + _t2014 = parse_iceberg_masked_property_entry(parser) + item1244 = _t2014 + push!(xs1242, item1244) + cond1243 = match_lookahead_literal(parser, "(", 0) end - iceberg_masked_property_entrys1237 = xs1234 + iceberg_masked_property_entrys1245 = xs1242 consume_literal!(parser, ")") - return iceberg_masked_property_entrys1237 + return iceberg_masked_property_entrys1245 end function parse_iceberg_masked_property_entry(parser::ParserState)::Tuple{String, String} consume_literal!(parser, "(") consume_literal!(parser, "prop") - string1238 = consume_terminal!(parser, "STRING") - string_31239 = consume_terminal!(parser, "STRING") + string1246 = consume_terminal!(parser, "STRING") + string_31247 = consume_terminal!(parser, "STRING") consume_literal!(parser, ")") - return (string1238, string_31239,) + return (string1246, string_31247,) end function parse_iceberg_from_snapshot(parser::ParserState)::String consume_literal!(parser, "(") consume_literal!(parser, "from_snapshot") - string1240 = consume_terminal!(parser, "STRING") + string1248 = consume_terminal!(parser, "STRING") consume_literal!(parser, ")") - return string1240 + return string1248 end function parse_iceberg_to_snapshot(parser::ParserState)::String consume_literal!(parser, "(") consume_literal!(parser, "to_snapshot") - string1241 = consume_terminal!(parser, "STRING") + string1249 = consume_terminal!(parser, "STRING") consume_literal!(parser, ")") - return string1241 + return string1249 end function parse_undefine(parser::ParserState)::Proto.Undefine - span_start1243 = span_start(parser) + span_start1251 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "undefine") - _t1999 = parse_fragment_id(parser) - fragment_id1242 = _t1999 + _t2015 = parse_fragment_id(parser) + fragment_id1250 = _t2015 consume_literal!(parser, ")") - _t2000 = Proto.Undefine(fragment_id=fragment_id1242) - result1244 = _t2000 - record_span!(parser, span_start1243, "Undefine") - return result1244 + _t2016 = Proto.Undefine(fragment_id=fragment_id1250) + result1252 = _t2016 + record_span!(parser, span_start1251, "Undefine") + return result1252 end function parse_context(parser::ParserState)::Proto.Context - span_start1249 = span_start(parser) + span_start1257 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "context") - xs1245 = Proto.RelationId[] - cond1246 = (match_lookahead_literal(parser, ":", 0) || match_lookahead_terminal(parser, "UINT128", 0)) - while cond1246 - _t2001 = parse_relation_id(parser) - item1247 = _t2001 - push!(xs1245, item1247) - cond1246 = (match_lookahead_literal(parser, ":", 0) || match_lookahead_terminal(parser, "UINT128", 0)) + xs1253 = Proto.RelationId[] + cond1254 = (match_lookahead_literal(parser, ":", 0) || match_lookahead_terminal(parser, "UINT128", 0)) + while cond1254 + _t2017 = parse_relation_id(parser) + item1255 = _t2017 + push!(xs1253, item1255) + cond1254 = (match_lookahead_literal(parser, ":", 0) || match_lookahead_terminal(parser, "UINT128", 0)) end - relation_ids1248 = xs1245 + relation_ids1256 = xs1253 consume_literal!(parser, ")") - _t2002 = Proto.Context(relations=relation_ids1248) - result1250 = _t2002 - record_span!(parser, span_start1249, "Context") - return result1250 + _t2018 = Proto.Context(relations=relation_ids1256) + result1258 = _t2018 + record_span!(parser, span_start1257, "Context") + return result1258 end function parse_snapshot(parser::ParserState)::Proto.Snapshot - span_start1256 = span_start(parser) + span_start1264 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "snapshot") - _t2003 = parse_edb_path(parser) - edb_path1251 = _t2003 - xs1252 = Proto.SnapshotMapping[] - cond1253 = match_lookahead_literal(parser, "[", 0) - while cond1253 - _t2004 = parse_snapshot_mapping(parser) - item1254 = _t2004 - push!(xs1252, item1254) - cond1253 = match_lookahead_literal(parser, "[", 0) + _t2019 = parse_edb_path(parser) + edb_path1259 = _t2019 + xs1260 = Proto.SnapshotMapping[] + cond1261 = match_lookahead_literal(parser, "[", 0) + while cond1261 + _t2020 = parse_snapshot_mapping(parser) + item1262 = _t2020 + push!(xs1260, item1262) + cond1261 = match_lookahead_literal(parser, "[", 0) end - snapshot_mappings1255 = xs1252 + snapshot_mappings1263 = xs1260 consume_literal!(parser, ")") - _t2005 = Proto.Snapshot(mappings=snapshot_mappings1255, prefix=edb_path1251) - result1257 = _t2005 - record_span!(parser, span_start1256, "Snapshot") - return result1257 + _t2021 = Proto.Snapshot(mappings=snapshot_mappings1263, prefix=edb_path1259) + result1265 = _t2021 + record_span!(parser, span_start1264, "Snapshot") + return result1265 end function parse_snapshot_mapping(parser::ParserState)::Proto.SnapshotMapping - span_start1260 = span_start(parser) - _t2006 = parse_edb_path(parser) - edb_path1258 = _t2006 - _t2007 = parse_relation_id(parser) - relation_id1259 = _t2007 - _t2008 = Proto.SnapshotMapping(destination_path=edb_path1258, source_relation=relation_id1259) - result1261 = _t2008 - record_span!(parser, span_start1260, "SnapshotMapping") - return result1261 + span_start1268 = span_start(parser) + _t2022 = parse_edb_path(parser) + edb_path1266 = _t2022 + _t2023 = parse_relation_id(parser) + relation_id1267 = _t2023 + _t2024 = Proto.SnapshotMapping(destination_path=edb_path1266, source_relation=relation_id1267) + result1269 = _t2024 + record_span!(parser, span_start1268, "SnapshotMapping") + return result1269 end function parse_epoch_reads(parser::ParserState)::Vector{Proto.Read} consume_literal!(parser, "(") consume_literal!(parser, "reads") - xs1262 = Proto.Read[] - cond1263 = match_lookahead_literal(parser, "(", 0) - while cond1263 - _t2009 = parse_read(parser) - item1264 = _t2009 - push!(xs1262, item1264) - cond1263 = match_lookahead_literal(parser, "(", 0) + xs1270 = Proto.Read[] + cond1271 = match_lookahead_literal(parser, "(", 0) + while cond1271 + _t2025 = parse_read(parser) + item1272 = _t2025 + push!(xs1270, item1272) + cond1271 = match_lookahead_literal(parser, "(", 0) end - reads1265 = xs1262 + reads1273 = xs1270 consume_literal!(parser, ")") - return reads1265 + return reads1273 end function parse_read(parser::ParserState)::Proto.Read - span_start1272 = span_start(parser) + span_start1281 = span_start(parser) if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "what_if", 1) - _t2011 = 2 + _t2027 = 2 else - if match_lookahead_literal(parser, "output", 1) - _t2012 = 1 + if match_lookahead_literal(parser, "output_export", 1) + _t2028 = 5 else - if match_lookahead_literal(parser, "export_iceberg", 1) - _t2013 = 4 + if match_lookahead_literal(parser, "output", 1) + _t2029 = 1 else - if match_lookahead_literal(parser, "export", 1) - _t2014 = 4 + if match_lookahead_literal(parser, "export_iceberg", 1) + _t2030 = 4 else - if match_lookahead_literal(parser, "demand", 1) - _t2015 = 0 + if match_lookahead_literal(parser, "export", 1) + _t2031 = 4 else - if match_lookahead_literal(parser, "abort", 1) - _t2016 = 3 + if match_lookahead_literal(parser, "demand", 1) + _t2032 = 0 else - _t2016 = -1 + if match_lookahead_literal(parser, "abort", 1) + _t2033 = 3 + else + _t2033 = -1 + end + _t2032 = _t2033 end - _t2015 = _t2016 + _t2031 = _t2032 end - _t2014 = _t2015 + _t2030 = _t2031 end - _t2013 = _t2014 + _t2029 = _t2030 end - _t2012 = _t2013 + _t2028 = _t2029 end - _t2011 = _t2012 + _t2027 = _t2028 end - _t2010 = _t2011 + _t2026 = _t2027 else - _t2010 = -1 + _t2026 = -1 end - prediction1266 = _t2010 - if prediction1266 == 4 - _t2018 = parse_export(parser) - export1271 = _t2018 - _t2019 = Proto.Read(read_type=OneOf(:var"#export", export1271)) - _t2017 = _t2019 + prediction1274 = _t2026 + if prediction1274 == 5 + _t2035 = parse_export_output(parser) + export_output1280 = _t2035 + _t2036 = Proto.Read(read_type=OneOf(:export_output, export_output1280)) + _t2034 = _t2036 else - if prediction1266 == 3 - _t2021 = parse_abort(parser) - abort1270 = _t2021 - _t2022 = Proto.Read(read_type=OneOf(:abort, abort1270)) - _t2020 = _t2022 + if prediction1274 == 4 + _t2038 = parse_export(parser) + export1279 = _t2038 + _t2039 = Proto.Read(read_type=OneOf(:var"#export", export1279)) + _t2037 = _t2039 else - if prediction1266 == 2 - _t2024 = parse_what_if(parser) - what_if1269 = _t2024 - _t2025 = Proto.Read(read_type=OneOf(:what_if, what_if1269)) - _t2023 = _t2025 + if prediction1274 == 3 + _t2041 = parse_abort(parser) + abort1278 = _t2041 + _t2042 = Proto.Read(read_type=OneOf(:abort, abort1278)) + _t2040 = _t2042 else - if prediction1266 == 1 - _t2027 = parse_output(parser) - output1268 = _t2027 - _t2028 = Proto.Read(read_type=OneOf(:output, output1268)) - _t2026 = _t2028 + if prediction1274 == 2 + _t2044 = parse_what_if(parser) + what_if1277 = _t2044 + _t2045 = Proto.Read(read_type=OneOf(:what_if, what_if1277)) + _t2043 = _t2045 else - if prediction1266 == 0 - _t2030 = parse_demand(parser) - demand1267 = _t2030 - _t2031 = Proto.Read(read_type=OneOf(:demand, demand1267)) - _t2029 = _t2031 + if prediction1274 == 1 + _t2047 = parse_output(parser) + output1276 = _t2047 + _t2048 = Proto.Read(read_type=OneOf(:output, output1276)) + _t2046 = _t2048 else - throw(ParseError("Unexpected token in read" * ": " * string(lookahead(parser, 0)))) + if prediction1274 == 0 + _t2050 = parse_demand(parser) + demand1275 = _t2050 + _t2051 = Proto.Read(read_type=OneOf(:demand, demand1275)) + _t2049 = _t2051 + else + throw(ParseError("Unexpected token in read" * ": " * string(lookahead(parser, 0)))) + end + _t2046 = _t2049 end - _t2026 = _t2029 + _t2043 = _t2046 end - _t2023 = _t2026 + _t2040 = _t2043 end - _t2020 = _t2023 + _t2037 = _t2040 end - _t2017 = _t2020 + _t2034 = _t2037 end - result1273 = _t2017 - record_span!(parser, span_start1272, "Read") - return result1273 + result1282 = _t2034 + record_span!(parser, span_start1281, "Read") + return result1282 end function parse_demand(parser::ParserState)::Proto.Demand - span_start1275 = span_start(parser) + span_start1284 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "demand") - _t2032 = parse_relation_id(parser) - relation_id1274 = _t2032 + _t2052 = parse_relation_id(parser) + relation_id1283 = _t2052 consume_literal!(parser, ")") - _t2033 = Proto.Demand(relation_id=relation_id1274) - result1276 = _t2033 - record_span!(parser, span_start1275, "Demand") - return result1276 + _t2053 = Proto.Demand(relation_id=relation_id1283) + result1285 = _t2053 + record_span!(parser, span_start1284, "Demand") + return result1285 end function parse_output(parser::ParserState)::Proto.Output - span_start1279 = span_start(parser) + span_start1288 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "output") - _t2034 = parse_name(parser) - name1277 = _t2034 - _t2035 = parse_relation_id(parser) - relation_id1278 = _t2035 + _t2054 = parse_name(parser) + name1286 = _t2054 + _t2055 = parse_relation_id(parser) + relation_id1287 = _t2055 consume_literal!(parser, ")") - _t2036 = Proto.Output(name=name1277, relation_id=relation_id1278) - result1280 = _t2036 - record_span!(parser, span_start1279, "Output") - return result1280 + _t2056 = Proto.Output(name=name1286, relation_id=relation_id1287) + result1289 = _t2056 + record_span!(parser, span_start1288, "Output") + return result1289 end function parse_what_if(parser::ParserState)::Proto.WhatIf - span_start1283 = span_start(parser) + span_start1292 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "what_if") - _t2037 = parse_name(parser) - name1281 = _t2037 - _t2038 = parse_epoch(parser) - epoch1282 = _t2038 + _t2057 = parse_name(parser) + name1290 = _t2057 + _t2058 = parse_epoch(parser) + epoch1291 = _t2058 consume_literal!(parser, ")") - _t2039 = Proto.WhatIf(branch=name1281, epoch=epoch1282) - result1284 = _t2039 - record_span!(parser, span_start1283, "WhatIf") - return result1284 + _t2059 = Proto.WhatIf(branch=name1290, epoch=epoch1291) + result1293 = _t2059 + record_span!(parser, span_start1292, "WhatIf") + return result1293 end function parse_abort(parser::ParserState)::Proto.Abort - span_start1287 = span_start(parser) + span_start1296 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "abort") if (match_lookahead_literal(parser, ":", 0) && match_lookahead_terminal(parser, "SYMBOL", 1)) - _t2041 = parse_name(parser) - _t2040 = _t2041 + _t2061 = parse_name(parser) + _t2060 = _t2061 else - _t2040 = nothing + _t2060 = nothing end - name1285 = _t2040 - _t2042 = parse_relation_id(parser) - relation_id1286 = _t2042 + name1294 = _t2060 + _t2062 = parse_relation_id(parser) + relation_id1295 = _t2062 consume_literal!(parser, ")") - _t2043 = Proto.Abort(name=(!isnothing(name1285) ? name1285 : "abort"), relation_id=relation_id1286) - result1288 = _t2043 - record_span!(parser, span_start1287, "Abort") - return result1288 + _t2063 = Proto.Abort(name=(!isnothing(name1294) ? name1294 : "abort"), relation_id=relation_id1295) + result1297 = _t2063 + record_span!(parser, span_start1296, "Abort") + return result1297 end function parse_export(parser::ParserState)::Proto.Export - span_start1292 = span_start(parser) + span_start1301 = span_start(parser) if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "export_iceberg", 1) - _t2045 = 1 + _t2065 = 1 else if match_lookahead_literal(parser, "export", 1) - _t2046 = 0 + _t2066 = 0 else - _t2046 = -1 + _t2066 = -1 end - _t2045 = _t2046 + _t2065 = _t2066 end - _t2044 = _t2045 + _t2064 = _t2065 else - _t2044 = -1 + _t2064 = -1 end - prediction1289 = _t2044 - if prediction1289 == 1 + prediction1298 = _t2064 + if prediction1298 == 1 consume_literal!(parser, "(") consume_literal!(parser, "export_iceberg") - _t2048 = parse_export_iceberg_config(parser) - export_iceberg_config1291 = _t2048 + _t2068 = parse_export_iceberg_config(parser) + export_iceberg_config1300 = _t2068 consume_literal!(parser, ")") - _t2049 = Proto.Export(export_config=OneOf(:iceberg_config, export_iceberg_config1291)) - _t2047 = _t2049 + _t2069 = Proto.Export(export_config=OneOf(:iceberg_config, export_iceberg_config1300)) + _t2067 = _t2069 else - if prediction1289 == 0 + if prediction1298 == 0 consume_literal!(parser, "(") consume_literal!(parser, "export") - _t2051 = parse_export_csv_config(parser) - export_csv_config1290 = _t2051 + _t2071 = parse_export_csv_config(parser) + export_csv_config1299 = _t2071 consume_literal!(parser, ")") - _t2052 = Proto.Export(export_config=OneOf(:csv_config, export_csv_config1290)) - _t2050 = _t2052 + _t2072 = Proto.Export(export_config=OneOf(:csv_config, export_csv_config1299)) + _t2070 = _t2072 else throw(ParseError("Unexpected token in export" * ": " * string(lookahead(parser, 0)))) end - _t2047 = _t2050 + _t2067 = _t2070 end - result1293 = _t2047 - record_span!(parser, span_start1292, "Export") - return result1293 + result1302 = _t2067 + record_span!(parser, span_start1301, "Export") + return result1302 end function parse_export_csv_config(parser::ParserState)::Proto.ExportCSVConfig - span_start1301 = span_start(parser) + span_start1310 = span_start(parser) if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "export_csv_config_v2", 1) - _t2054 = 0 + _t2074 = 0 else if match_lookahead_literal(parser, "export_csv_config", 1) - _t2055 = 1 + _t2075 = 1 else - _t2055 = -1 + _t2075 = -1 end - _t2054 = _t2055 + _t2074 = _t2075 end - _t2053 = _t2054 + _t2073 = _t2074 else - _t2053 = -1 + _t2073 = -1 end - prediction1294 = _t2053 - if prediction1294 == 1 + prediction1303 = _t2073 + if prediction1303 == 1 consume_literal!(parser, "(") consume_literal!(parser, "export_csv_config") - _t2057 = parse_export_csv_path(parser) - export_csv_path1298 = _t2057 - _t2058 = parse_export_csv_columns_list(parser) - export_csv_columns_list1299 = _t2058 - _t2059 = parse_config_dict(parser) - config_dict1300 = _t2059 + _t2077 = parse_export_csv_path(parser) + export_csv_path1307 = _t2077 + _t2078 = parse_export_csv_columns_list(parser) + export_csv_columns_list1308 = _t2078 + _t2079 = parse_config_dict(parser) + config_dict1309 = _t2079 consume_literal!(parser, ")") - _t2060 = construct_export_csv_config(parser, export_csv_path1298, export_csv_columns_list1299, config_dict1300) - _t2056 = _t2060 + _t2080 = construct_export_csv_config(parser, export_csv_path1307, export_csv_columns_list1308, config_dict1309) + _t2076 = _t2080 else - if prediction1294 == 0 + if prediction1303 == 0 consume_literal!(parser, "(") consume_literal!(parser, "export_csv_config_v2") - _t2062 = parse_export_csv_path(parser) - export_csv_path1295 = _t2062 - _t2063 = parse_export_csv_source(parser) - export_csv_source1296 = _t2063 - _t2064 = parse_csv_config(parser) - csv_config1297 = _t2064 + _t2082 = parse_export_csv_path(parser) + export_csv_path1304 = _t2082 + _t2083 = parse_export_csv_source(parser) + export_csv_source1305 = _t2083 + _t2084 = parse_csv_config(parser) + csv_config1306 = _t2084 consume_literal!(parser, ")") - _t2065 = construct_export_csv_config_with_source(parser, export_csv_path1295, export_csv_source1296, csv_config1297) - _t2061 = _t2065 + _t2085 = construct_export_csv_config_with_source(parser, export_csv_path1304, export_csv_source1305, csv_config1306) + _t2081 = _t2085 else throw(ParseError("Unexpected token in export_csv_config" * ": " * string(lookahead(parser, 0)))) end - _t2056 = _t2061 + _t2076 = _t2081 end - result1302 = _t2056 - record_span!(parser, span_start1301, "ExportCSVConfig") - return result1302 + result1311 = _t2076 + record_span!(parser, span_start1310, "ExportCSVConfig") + return result1311 end function parse_export_csv_path(parser::ParserState)::String consume_literal!(parser, "(") consume_literal!(parser, "path") - string1303 = consume_terminal!(parser, "STRING") + string1312 = consume_terminal!(parser, "STRING") consume_literal!(parser, ")") - return string1303 + return string1312 end function parse_export_csv_source(parser::ParserState)::Proto.ExportCSVSource - span_start1310 = span_start(parser) + span_start1319 = span_start(parser) if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "table_def", 1) - _t2067 = 1 + _t2087 = 1 else if match_lookahead_literal(parser, "gnf_columns", 1) - _t2068 = 0 + _t2088 = 0 else - _t2068 = -1 + _t2088 = -1 end - _t2067 = _t2068 + _t2087 = _t2088 end - _t2066 = _t2067 + _t2086 = _t2087 else - _t2066 = -1 + _t2086 = -1 end - prediction1304 = _t2066 - if prediction1304 == 1 + prediction1313 = _t2086 + if prediction1313 == 1 consume_literal!(parser, "(") consume_literal!(parser, "table_def") - _t2070 = parse_relation_id(parser) - relation_id1309 = _t2070 + _t2090 = parse_relation_id(parser) + relation_id1318 = _t2090 consume_literal!(parser, ")") - _t2071 = Proto.ExportCSVSource(csv_source=OneOf(:table_def, relation_id1309)) - _t2069 = _t2071 + _t2091 = Proto.ExportCSVSource(csv_source=OneOf(:table_def, relation_id1318)) + _t2089 = _t2091 else - if prediction1304 == 0 + if prediction1313 == 0 consume_literal!(parser, "(") consume_literal!(parser, "gnf_columns") - xs1305 = Proto.ExportCSVColumn[] - cond1306 = match_lookahead_literal(parser, "(", 0) - while cond1306 - _t2073 = parse_export_csv_column(parser) - item1307 = _t2073 - push!(xs1305, item1307) - cond1306 = match_lookahead_literal(parser, "(", 0) + xs1314 = Proto.ExportCSVColumn[] + cond1315 = match_lookahead_literal(parser, "(", 0) + while cond1315 + _t2093 = parse_export_csv_column(parser) + item1316 = _t2093 + push!(xs1314, item1316) + cond1315 = match_lookahead_literal(parser, "(", 0) end - export_csv_columns1308 = xs1305 + export_csv_columns1317 = xs1314 consume_literal!(parser, ")") - _t2074 = Proto.ExportCSVColumns(columns=export_csv_columns1308) - _t2075 = Proto.ExportCSVSource(csv_source=OneOf(:gnf_columns, _t2074)) - _t2072 = _t2075 + _t2094 = Proto.ExportCSVColumns(columns=export_csv_columns1317) + _t2095 = Proto.ExportCSVSource(csv_source=OneOf(:gnf_columns, _t2094)) + _t2092 = _t2095 else throw(ParseError("Unexpected token in export_csv_source" * ": " * string(lookahead(parser, 0)))) end - _t2069 = _t2072 + _t2089 = _t2092 end - result1311 = _t2069 - record_span!(parser, span_start1310, "ExportCSVSource") - return result1311 + result1320 = _t2089 + record_span!(parser, span_start1319, "ExportCSVSource") + return result1320 end function parse_export_csv_column(parser::ParserState)::Proto.ExportCSVColumn - span_start1314 = span_start(parser) + span_start1323 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "column") - string1312 = consume_terminal!(parser, "STRING") - _t2076 = parse_relation_id(parser) - relation_id1313 = _t2076 + string1321 = consume_terminal!(parser, "STRING") + _t2096 = parse_relation_id(parser) + relation_id1322 = _t2096 consume_literal!(parser, ")") - _t2077 = Proto.ExportCSVColumn(column_name=string1312, column_data=relation_id1313) - result1315 = _t2077 - record_span!(parser, span_start1314, "ExportCSVColumn") - return result1315 + _t2097 = Proto.ExportCSVColumn(column_name=string1321, column_data=relation_id1322) + result1324 = _t2097 + record_span!(parser, span_start1323, "ExportCSVColumn") + return result1324 end function parse_export_csv_columns_list(parser::ParserState)::Vector{Proto.ExportCSVColumn} consume_literal!(parser, "(") consume_literal!(parser, "columns") - xs1316 = Proto.ExportCSVColumn[] - cond1317 = match_lookahead_literal(parser, "(", 0) - while cond1317 - _t2078 = parse_export_csv_column(parser) - item1318 = _t2078 - push!(xs1316, item1318) - cond1317 = match_lookahead_literal(parser, "(", 0) + xs1325 = Proto.ExportCSVColumn[] + cond1326 = match_lookahead_literal(parser, "(", 0) + while cond1326 + _t2098 = parse_export_csv_column(parser) + item1327 = _t2098 + push!(xs1325, item1327) + cond1326 = match_lookahead_literal(parser, "(", 0) end - export_csv_columns1319 = xs1316 + export_csv_columns1328 = xs1325 consume_literal!(parser, ")") - return export_csv_columns1319 + return export_csv_columns1328 end function parse_export_iceberg_config(parser::ParserState)::Proto.ExportIcebergConfig - span_start1325 = span_start(parser) + span_start1334 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "export_iceberg_config") - _t2079 = parse_iceberg_locator(parser) - iceberg_locator1320 = _t2079 - _t2080 = parse_iceberg_catalog_config(parser) - iceberg_catalog_config1321 = _t2080 - _t2081 = parse_export_iceberg_table_def(parser) - export_iceberg_table_def1322 = _t2081 - _t2082 = parse_iceberg_table_properties(parser) - iceberg_table_properties1323 = _t2082 + _t2099 = parse_iceberg_locator(parser) + iceberg_locator1329 = _t2099 + _t2100 = parse_iceberg_catalog_config(parser) + iceberg_catalog_config1330 = _t2100 + _t2101 = parse_export_iceberg_table_def(parser) + export_iceberg_table_def1331 = _t2101 + _t2102 = parse_iceberg_table_properties(parser) + iceberg_table_properties1332 = _t2102 if match_lookahead_literal(parser, "{", 0) - _t2084 = parse_config_dict(parser) - _t2083 = _t2084 + _t2104 = parse_config_dict(parser) + _t2103 = _t2104 else - _t2083 = nothing + _t2103 = nothing end - config_dict1324 = _t2083 + config_dict1333 = _t2103 consume_literal!(parser, ")") - _t2085 = construct_export_iceberg_config_full(parser, iceberg_locator1320, iceberg_catalog_config1321, export_iceberg_table_def1322, iceberg_table_properties1323, config_dict1324) - result1326 = _t2085 - record_span!(parser, span_start1325, "ExportIcebergConfig") - return result1326 + _t2105 = construct_export_iceberg_config_full(parser, iceberg_locator1329, iceberg_catalog_config1330, export_iceberg_table_def1331, iceberg_table_properties1332, config_dict1333) + result1335 = _t2105 + record_span!(parser, span_start1334, "ExportIcebergConfig") + return result1335 end function parse_export_iceberg_table_def(parser::ParserState)::Proto.RelationId - span_start1328 = span_start(parser) + span_start1337 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "table_def") - _t2086 = parse_relation_id(parser) - relation_id1327 = _t2086 + _t2106 = parse_relation_id(parser) + relation_id1336 = _t2106 consume_literal!(parser, ")") - result1329 = relation_id1327 - record_span!(parser, span_start1328, "RelationId") - return result1329 + result1338 = relation_id1336 + record_span!(parser, span_start1337, "RelationId") + return result1338 end function parse_iceberg_table_properties(parser::ParserState)::Vector{Tuple{String, String}} consume_literal!(parser, "(") consume_literal!(parser, "table_properties") - xs1330 = Tuple{String, String}[] - cond1331 = match_lookahead_literal(parser, "(", 0) - while cond1331 - _t2087 = parse_iceberg_property_entry(parser) - item1332 = _t2087 - push!(xs1330, item1332) - cond1331 = match_lookahead_literal(parser, "(", 0) + xs1339 = Tuple{String, String}[] + cond1340 = match_lookahead_literal(parser, "(", 0) + while cond1340 + _t2107 = parse_iceberg_property_entry(parser) + item1341 = _t2107 + push!(xs1339, item1341) + cond1340 = match_lookahead_literal(parser, "(", 0) end - iceberg_property_entrys1333 = xs1330 + iceberg_property_entrys1342 = xs1339 + consume_literal!(parser, ")") + return iceberg_property_entrys1342 +end + +function parse_export_output(parser::ParserState)::Proto.ExportOutput + span_start1344 = span_start(parser) + consume_literal!(parser, "(") + consume_literal!(parser, "output_export") + _t2108 = parse_export_csv_output(parser) + export_csv_output1343 = _t2108 + consume_literal!(parser, ")") + _t2109 = Proto.ExportOutput(export_output=OneOf(:csv, export_csv_output1343)) + result1345 = _t2109 + record_span!(parser, span_start1344, "ExportOutput") + return result1345 +end + +function parse_export_csv_output(parser::ParserState)::Proto.ExportCSVOutput + span_start1348 = span_start(parser) + consume_literal!(parser, "(") + consume_literal!(parser, "csv") + _t2110 = parse_export_csv_source(parser) + export_csv_source1346 = _t2110 + _t2111 = parse_csv_config(parser) + csv_config1347 = _t2111 consume_literal!(parser, ")") - return iceberg_property_entrys1333 + _t2112 = Proto.ExportCSVOutput(csv_source=export_csv_source1346, csv_config=csv_config1347) + result1349 = _t2112 + record_span!(parser, span_start1348, "ExportCSVOutput") + return result1349 end diff --git a/sdks/julia/LogicalQueryProtocol.jl/src/pretty.jl b/sdks/julia/LogicalQueryProtocol.jl/src/pretty.jl index 68914d6e..f4551822 100644 --- a/sdks/julia/LogicalQueryProtocol.jl/src/pretty.jl +++ b/sdks/julia/LogicalQueryProtocol.jl/src/pretty.jl @@ -377,89 +377,89 @@ end # --- Helper functions --- function _make_value_int32(pp::PrettyPrinter, v::Int32)::Proto.Value - _t1781 = Proto.Value(value=OneOf(:int32_value, v)) - return _t1781 + _t1803 = Proto.Value(value=OneOf(:int32_value, v)) + return _t1803 end function _make_value_int64(pp::PrettyPrinter, v::Int64)::Proto.Value - _t1782 = Proto.Value(value=OneOf(:int_value, v)) - return _t1782 + _t1804 = Proto.Value(value=OneOf(:int_value, v)) + return _t1804 end function _make_value_float64(pp::PrettyPrinter, v::Float64)::Proto.Value - _t1783 = Proto.Value(value=OneOf(:float_value, v)) - return _t1783 + _t1805 = Proto.Value(value=OneOf(:float_value, v)) + return _t1805 end function _make_value_string(pp::PrettyPrinter, v::String)::Proto.Value - _t1784 = Proto.Value(value=OneOf(:string_value, v)) - return _t1784 + _t1806 = Proto.Value(value=OneOf(:string_value, v)) + return _t1806 end function _make_value_boolean(pp::PrettyPrinter, v::Bool)::Proto.Value - _t1785 = Proto.Value(value=OneOf(:boolean_value, v)) - return _t1785 + _t1807 = Proto.Value(value=OneOf(:boolean_value, v)) + return _t1807 end function _make_value_uint128(pp::PrettyPrinter, v::Proto.UInt128Value)::Proto.Value - _t1786 = Proto.Value(value=OneOf(:uint128_value, v)) - return _t1786 + _t1808 = Proto.Value(value=OneOf(:uint128_value, v)) + return _t1808 end function deconstruct_configure(pp::PrettyPrinter, msg::Proto.Configure)::Vector{Tuple{String, Proto.Value}} result = Tuple{String, Proto.Value}[] if msg.ivm_config.level == Proto.MaintenanceLevel.MAINTENANCE_LEVEL_AUTO - _t1787 = _make_value_string(pp, "auto") - push!(result, ("ivm.maintenance_level", _t1787,)) + _t1809 = _make_value_string(pp, "auto") + push!(result, ("ivm.maintenance_level", _t1809,)) else if msg.ivm_config.level == Proto.MaintenanceLevel.MAINTENANCE_LEVEL_ALL - _t1788 = _make_value_string(pp, "all") - push!(result, ("ivm.maintenance_level", _t1788,)) + _t1810 = _make_value_string(pp, "all") + push!(result, ("ivm.maintenance_level", _t1810,)) else if msg.ivm_config.level == Proto.MaintenanceLevel.MAINTENANCE_LEVEL_OFF - _t1789 = _make_value_string(pp, "off") - push!(result, ("ivm.maintenance_level", _t1789,)) + _t1811 = _make_value_string(pp, "off") + push!(result, ("ivm.maintenance_level", _t1811,)) end end end - _t1790 = _make_value_int64(pp, msg.semantics_version) - push!(result, ("semantics_version", _t1790,)) + _t1812 = _make_value_int64(pp, msg.semantics_version) + push!(result, ("semantics_version", _t1812,)) return sort(result) end function deconstruct_csv_config(pp::PrettyPrinter, msg::Proto.CSVConfig)::Vector{Tuple{String, Proto.Value}} result = Tuple{String, Proto.Value}[] - _t1791 = _make_value_int32(pp, msg.header_row) - push!(result, ("csv_header_row", _t1791,)) - _t1792 = _make_value_int64(pp, msg.skip) - push!(result, ("csv_skip", _t1792,)) + _t1813 = _make_value_int32(pp, msg.header_row) + push!(result, ("csv_header_row", _t1813,)) + _t1814 = _make_value_int64(pp, msg.skip) + push!(result, ("csv_skip", _t1814,)) if msg.new_line != "" - _t1793 = _make_value_string(pp, msg.new_line) - push!(result, ("csv_new_line", _t1793,)) - end - _t1794 = _make_value_string(pp, msg.delimiter) - push!(result, ("csv_delimiter", _t1794,)) - _t1795 = _make_value_string(pp, msg.quotechar) - push!(result, ("csv_quotechar", _t1795,)) - _t1796 = _make_value_string(pp, msg.escapechar) - push!(result, ("csv_escapechar", _t1796,)) + _t1815 = _make_value_string(pp, msg.new_line) + push!(result, ("csv_new_line", _t1815,)) + end + _t1816 = _make_value_string(pp, msg.delimiter) + push!(result, ("csv_delimiter", _t1816,)) + _t1817 = _make_value_string(pp, msg.quotechar) + push!(result, ("csv_quotechar", _t1817,)) + _t1818 = _make_value_string(pp, msg.escapechar) + push!(result, ("csv_escapechar", _t1818,)) if msg.comment != "" - _t1797 = _make_value_string(pp, msg.comment) - push!(result, ("csv_comment", _t1797,)) + _t1819 = _make_value_string(pp, msg.comment) + push!(result, ("csv_comment", _t1819,)) end for missing_string in msg.missing_strings - _t1798 = _make_value_string(pp, missing_string) - push!(result, ("csv_missing_strings", _t1798,)) - end - _t1799 = _make_value_string(pp, msg.decimal_separator) - push!(result, ("csv_decimal_separator", _t1799,)) - _t1800 = _make_value_string(pp, msg.encoding) - push!(result, ("csv_encoding", _t1800,)) - _t1801 = _make_value_string(pp, msg.compression) - push!(result, ("csv_compression", _t1801,)) + _t1820 = _make_value_string(pp, missing_string) + push!(result, ("csv_missing_strings", _t1820,)) + end + _t1821 = _make_value_string(pp, msg.decimal_separator) + push!(result, ("csv_decimal_separator", _t1821,)) + _t1822 = _make_value_string(pp, msg.encoding) + push!(result, ("csv_encoding", _t1822,)) + _t1823 = _make_value_string(pp, msg.compression) + push!(result, ("csv_compression", _t1823,)) if msg.partition_size_mb != 0 - _t1802 = _make_value_int64(pp, msg.partition_size_mb) - push!(result, ("csv_partition_size_mb", _t1802,)) + _t1824 = _make_value_int64(pp, msg.partition_size_mb) + push!(result, ("csv_partition_size_mb", _t1824,)) end return sort(result) end @@ -468,91 +468,91 @@ function deconstruct_csv_storage_integration_optional(pp::PrettyPrinter, msg::Pr if !_has_proto_field(msg, Symbol("storage_integration")) return nothing else - _t1803 = nothing + _t1825 = nothing end si = msg.storage_integration result = Tuple{String, Proto.Value}[] if si.provider != "" - _t1804 = _make_value_string(pp, si.provider) - push!(result, ("provider", _t1804,)) + _t1826 = _make_value_string(pp, si.provider) + push!(result, ("provider", _t1826,)) end if si.azure_sas_token != "" - _t1805 = _make_value_string(pp, "***") - push!(result, ("azure_sas_token", _t1805,)) + _t1827 = _make_value_string(pp, "***") + push!(result, ("azure_sas_token", _t1827,)) end if si.s3_region != "" - _t1806 = _make_value_string(pp, si.s3_region) - push!(result, ("s3_region", _t1806,)) + _t1828 = _make_value_string(pp, si.s3_region) + push!(result, ("s3_region", _t1828,)) end if si.s3_access_key_id != "" - _t1807 = _make_value_string(pp, "***") - push!(result, ("s3_access_key_id", _t1807,)) + _t1829 = _make_value_string(pp, "***") + push!(result, ("s3_access_key_id", _t1829,)) end if si.s3_secret_access_key != "" - _t1808 = _make_value_string(pp, "***") - push!(result, ("s3_secret_access_key", _t1808,)) + _t1830 = _make_value_string(pp, "***") + push!(result, ("s3_secret_access_key", _t1830,)) end return sort(result) end function deconstruct_betree_info_config(pp::PrettyPrinter, msg::Proto.BeTreeInfo)::Vector{Tuple{String, Proto.Value}} result = Tuple{String, Proto.Value}[] - _t1809 = _make_value_float64(pp, msg.storage_config.epsilon) - push!(result, ("betree_config_epsilon", _t1809,)) - _t1810 = _make_value_int64(pp, msg.storage_config.max_pivots) - push!(result, ("betree_config_max_pivots", _t1810,)) - _t1811 = _make_value_int64(pp, msg.storage_config.max_deltas) - push!(result, ("betree_config_max_deltas", _t1811,)) - _t1812 = _make_value_int64(pp, msg.storage_config.max_leaf) - push!(result, ("betree_config_max_leaf", _t1812,)) + _t1831 = _make_value_float64(pp, msg.storage_config.epsilon) + push!(result, ("betree_config_epsilon", _t1831,)) + _t1832 = _make_value_int64(pp, msg.storage_config.max_pivots) + push!(result, ("betree_config_max_pivots", _t1832,)) + _t1833 = _make_value_int64(pp, msg.storage_config.max_deltas) + push!(result, ("betree_config_max_deltas", _t1833,)) + _t1834 = _make_value_int64(pp, msg.storage_config.max_leaf) + push!(result, ("betree_config_max_leaf", _t1834,)) if _has_proto_field(msg.relation_locator, Symbol("root_pageid")) if !isnothing(_get_oneof_field(msg.relation_locator, :root_pageid)) - _t1813 = _make_value_uint128(pp, _get_oneof_field(msg.relation_locator, :root_pageid)) - push!(result, ("betree_locator_root_pageid", _t1813,)) + _t1835 = _make_value_uint128(pp, _get_oneof_field(msg.relation_locator, :root_pageid)) + push!(result, ("betree_locator_root_pageid", _t1835,)) end end if _has_proto_field(msg.relation_locator, Symbol("inline_data")) if !isnothing(_get_oneof_field(msg.relation_locator, :inline_data)) - _t1814 = _make_value_string(pp, String(copy(_get_oneof_field(msg.relation_locator, :inline_data)))) - push!(result, ("betree_locator_inline_data", _t1814,)) + _t1836 = _make_value_string(pp, String(copy(_get_oneof_field(msg.relation_locator, :inline_data)))) + push!(result, ("betree_locator_inline_data", _t1836,)) end end - _t1815 = _make_value_int64(pp, msg.relation_locator.element_count) - push!(result, ("betree_locator_element_count", _t1815,)) - _t1816 = _make_value_int64(pp, msg.relation_locator.tree_height) - push!(result, ("betree_locator_tree_height", _t1816,)) + _t1837 = _make_value_int64(pp, msg.relation_locator.element_count) + push!(result, ("betree_locator_element_count", _t1837,)) + _t1838 = _make_value_int64(pp, msg.relation_locator.tree_height) + push!(result, ("betree_locator_tree_height", _t1838,)) return sort(result) end function deconstruct_export_csv_config(pp::PrettyPrinter, msg::Proto.ExportCSVConfig)::Vector{Tuple{String, Proto.Value}} result = Tuple{String, Proto.Value}[] if !isnothing(msg.partition_size) - _t1817 = _make_value_int64(pp, msg.partition_size) - push!(result, ("partition_size", _t1817,)) + _t1839 = _make_value_int64(pp, msg.partition_size) + push!(result, ("partition_size", _t1839,)) end if !isnothing(msg.compression) - _t1818 = _make_value_string(pp, msg.compression) - push!(result, ("compression", _t1818,)) + _t1840 = _make_value_string(pp, msg.compression) + push!(result, ("compression", _t1840,)) end if !isnothing(msg.syntax_header_row) - _t1819 = _make_value_boolean(pp, msg.syntax_header_row) - push!(result, ("syntax_header_row", _t1819,)) + _t1841 = _make_value_boolean(pp, msg.syntax_header_row) + push!(result, ("syntax_header_row", _t1841,)) end if !isnothing(msg.syntax_missing_string) - _t1820 = _make_value_string(pp, msg.syntax_missing_string) - push!(result, ("syntax_missing_string", _t1820,)) + _t1842 = _make_value_string(pp, msg.syntax_missing_string) + push!(result, ("syntax_missing_string", _t1842,)) end if !isnothing(msg.syntax_delim) - _t1821 = _make_value_string(pp, msg.syntax_delim) - push!(result, ("syntax_delim", _t1821,)) + _t1843 = _make_value_string(pp, msg.syntax_delim) + push!(result, ("syntax_delim", _t1843,)) end if !isnothing(msg.syntax_quotechar) - _t1822 = _make_value_string(pp, msg.syntax_quotechar) - push!(result, ("syntax_quotechar", _t1822,)) + _t1844 = _make_value_string(pp, msg.syntax_quotechar) + push!(result, ("syntax_quotechar", _t1844,)) end if !isnothing(msg.syntax_escapechar) - _t1823 = _make_value_string(pp, msg.syntax_escapechar) - push!(result, ("syntax_escapechar", _t1823,)) + _t1845 = _make_value_string(pp, msg.syntax_escapechar) + push!(result, ("syntax_escapechar", _t1845,)) end return sort(result) end @@ -565,7 +565,7 @@ function deconstruct_iceberg_catalog_config_scope_optional(pp::PrettyPrinter, ms if msg.scope != "" return msg.scope else - _t1824 = nothing + _t1846 = nothing end return nothing end @@ -574,7 +574,7 @@ function deconstruct_iceberg_data_from_snapshot_optional(pp::PrettyPrinter, msg: if msg.from_snapshot != "" return msg.from_snapshot else - _t1825 = nothing + _t1847 = nothing end return nothing end @@ -583,7 +583,7 @@ function deconstruct_iceberg_data_to_snapshot_optional(pp::PrettyPrinter, msg::P if msg.to_snapshot != "" return msg.to_snapshot else - _t1826 = nothing + _t1848 = nothing end return nothing end @@ -591,21 +591,21 @@ end function deconstruct_export_iceberg_config_optional(pp::PrettyPrinter, msg::Proto.ExportIcebergConfig)::Union{Nothing, Vector{Tuple{String, Proto.Value}}} result = Tuple{String, Proto.Value}[] if msg.prefix != "" - _t1827 = _make_value_string(pp, msg.prefix) - push!(result, ("prefix", _t1827,)) + _t1849 = _make_value_string(pp, msg.prefix) + push!(result, ("prefix", _t1849,)) end if msg.target_file_size_bytes != 0 - _t1828 = _make_value_int64(pp, msg.target_file_size_bytes) - push!(result, ("target_file_size_bytes", _t1828,)) + _t1850 = _make_value_int64(pp, msg.target_file_size_bytes) + push!(result, ("target_file_size_bytes", _t1850,)) end if msg.compression != "" - _t1829 = _make_value_string(pp, msg.compression) - push!(result, ("compression", _t1829,)) + _t1851 = _make_value_string(pp, msg.compression) + push!(result, ("compression", _t1851,)) end if length(result) == 0 return nothing else - _t1830 = nothing + _t1852 = nothing end return sort(result) end @@ -620,7 +620,7 @@ function deconstruct_relation_id_uint128(pp::PrettyPrinter, msg::Proto.RelationI if isnothing(name) return relation_id_to_uint128(pp, msg) else - _t1831 = nothing + _t1853 = nothing end return nothing end @@ -639,47 +639,47 @@ end # --- Pretty-print functions --- function pretty_transaction(pp::PrettyPrinter, msg::Proto.Transaction) - flat808 = try_flat(pp, msg, pretty_transaction) - if !isnothing(flat808) - write(pp, flat808) + flat818 = try_flat(pp, msg, pretty_transaction) + if !isnothing(flat818) + write(pp, flat818) return nothing else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("configure")) - _t1598 = _dollar_dollar.configure + _t1618 = _dollar_dollar.configure else - _t1598 = nothing + _t1618 = nothing end if _has_proto_field(_dollar_dollar, Symbol("sync")) - _t1599 = _dollar_dollar.sync + _t1619 = _dollar_dollar.sync else - _t1599 = nothing + _t1619 = nothing end - fields799 = (_t1598, _t1599, _dollar_dollar.epochs,) - unwrapped_fields800 = fields799 + fields809 = (_t1618, _t1619, _dollar_dollar.epochs,) + unwrapped_fields810 = fields809 write(pp, "(transaction") indent_sexp!(pp) - field801 = unwrapped_fields800[1] - if !isnothing(field801) + field811 = unwrapped_fields810[1] + if !isnothing(field811) newline(pp) - opt_val802 = field801 - pretty_configure(pp, opt_val802) + opt_val812 = field811 + pretty_configure(pp, opt_val812) end - field803 = unwrapped_fields800[2] - if !isnothing(field803) + field813 = unwrapped_fields810[2] + if !isnothing(field813) newline(pp) - opt_val804 = field803 - pretty_sync(pp, opt_val804) + opt_val814 = field813 + pretty_sync(pp, opt_val814) end - field805 = unwrapped_fields800[3] - if !isempty(field805) + field815 = unwrapped_fields810[3] + if !isempty(field815) newline(pp) - for (i1600, elem806) in enumerate(field805) - i807 = i1600 - 1 - if (i807 > 0) + for (i1620, elem816) in enumerate(field815) + i817 = i1620 - 1 + if (i817 > 0) newline(pp) end - pretty_epoch(pp, elem806) + pretty_epoch(pp, elem816) end end dedent!(pp) @@ -689,19 +689,19 @@ function pretty_transaction(pp::PrettyPrinter, msg::Proto.Transaction) end function pretty_configure(pp::PrettyPrinter, msg::Proto.Configure) - flat811 = try_flat(pp, msg, pretty_configure) - if !isnothing(flat811) - write(pp, flat811) + flat821 = try_flat(pp, msg, pretty_configure) + if !isnothing(flat821) + write(pp, flat821) return nothing else _dollar_dollar = msg - _t1601 = deconstruct_configure(pp, _dollar_dollar) - fields809 = _t1601 - unwrapped_fields810 = fields809 + _t1621 = deconstruct_configure(pp, _dollar_dollar) + fields819 = _t1621 + unwrapped_fields820 = fields819 write(pp, "(configure") indent_sexp!(pp) newline(pp) - pretty_config_dict(pp, unwrapped_fields810) + pretty_config_dict(pp, unwrapped_fields820) dedent!(pp) write(pp, ")") end @@ -709,22 +709,22 @@ function pretty_configure(pp::PrettyPrinter, msg::Proto.Configure) end function pretty_config_dict(pp::PrettyPrinter, msg::Vector{Tuple{String, Proto.Value}}) - flat815 = try_flat(pp, msg, pretty_config_dict) - if !isnothing(flat815) - write(pp, flat815) + flat825 = try_flat(pp, msg, pretty_config_dict) + if !isnothing(flat825) + write(pp, flat825) return nothing else - fields812 = msg + fields822 = msg write(pp, "{") indent!(pp) - if !isempty(fields812) + if !isempty(fields822) newline(pp) - for (i1602, elem813) in enumerate(fields812) - i814 = i1602 - 1 - if (i814 > 0) + for (i1622, elem823) in enumerate(fields822) + i824 = i1622 - 1 + if (i824 > 0) newline(pp) end - pretty_config_key_value(pp, elem813) + pretty_config_key_value(pp, elem823) end end dedent!(pp) @@ -734,163 +734,163 @@ function pretty_config_dict(pp::PrettyPrinter, msg::Vector{Tuple{String, Proto.V end function pretty_config_key_value(pp::PrettyPrinter, msg::Tuple{String, Proto.Value}) - flat820 = try_flat(pp, msg, pretty_config_key_value) - if !isnothing(flat820) - write(pp, flat820) + flat830 = try_flat(pp, msg, pretty_config_key_value) + if !isnothing(flat830) + write(pp, flat830) return nothing else _dollar_dollar = msg - fields816 = (_dollar_dollar[1], _dollar_dollar[2],) - unwrapped_fields817 = fields816 + fields826 = (_dollar_dollar[1], _dollar_dollar[2],) + unwrapped_fields827 = fields826 write(pp, ":") - field818 = unwrapped_fields817[1] - write(pp, field818) + field828 = unwrapped_fields827[1] + write(pp, field828) write(pp, " ") - field819 = unwrapped_fields817[2] - pretty_raw_value(pp, field819) + field829 = unwrapped_fields827[2] + pretty_raw_value(pp, field829) end return nothing end function pretty_raw_value(pp::PrettyPrinter, msg::Proto.Value) - flat846 = try_flat(pp, msg, pretty_raw_value) - if !isnothing(flat846) - write(pp, flat846) + flat856 = try_flat(pp, msg, pretty_raw_value) + if !isnothing(flat856) + write(pp, flat856) return nothing else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("date_value")) - _t1603 = _get_oneof_field(_dollar_dollar, :date_value) + _t1623 = _get_oneof_field(_dollar_dollar, :date_value) else - _t1603 = nothing + _t1623 = nothing end - deconstruct_result844 = _t1603 - if !isnothing(deconstruct_result844) - unwrapped845 = deconstruct_result844 - pretty_raw_date(pp, unwrapped845) + deconstruct_result854 = _t1623 + if !isnothing(deconstruct_result854) + unwrapped855 = deconstruct_result854 + pretty_raw_date(pp, unwrapped855) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("datetime_value")) - _t1604 = _get_oneof_field(_dollar_dollar, :datetime_value) + _t1624 = _get_oneof_field(_dollar_dollar, :datetime_value) else - _t1604 = nothing + _t1624 = nothing end - deconstruct_result842 = _t1604 - if !isnothing(deconstruct_result842) - unwrapped843 = deconstruct_result842 - pretty_raw_datetime(pp, unwrapped843) + deconstruct_result852 = _t1624 + if !isnothing(deconstruct_result852) + unwrapped853 = deconstruct_result852 + pretty_raw_datetime(pp, unwrapped853) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("string_value")) - _t1605 = _get_oneof_field(_dollar_dollar, :string_value) + _t1625 = _get_oneof_field(_dollar_dollar, :string_value) else - _t1605 = nothing + _t1625 = nothing end - deconstruct_result840 = _t1605 - if !isnothing(deconstruct_result840) - unwrapped841 = deconstruct_result840 - write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, unwrapped841)) + deconstruct_result850 = _t1625 + if !isnothing(deconstruct_result850) + unwrapped851 = deconstruct_result850 + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, unwrapped851)) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("int32_value")) - _t1606 = _get_oneof_field(_dollar_dollar, :int32_value) + _t1626 = _get_oneof_field(_dollar_dollar, :int32_value) else - _t1606 = nothing + _t1626 = nothing end - deconstruct_result838 = _t1606 - if !isnothing(deconstruct_result838) - unwrapped839 = deconstruct_result838 - write(pp, (string(Int64(unwrapped839)) * "i32")) + deconstruct_result848 = _t1626 + if !isnothing(deconstruct_result848) + unwrapped849 = deconstruct_result848 + write(pp, (string(Int64(unwrapped849)) * "i32")) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("int_value")) - _t1607 = _get_oneof_field(_dollar_dollar, :int_value) + _t1627 = _get_oneof_field(_dollar_dollar, :int_value) else - _t1607 = nothing + _t1627 = nothing end - deconstruct_result836 = _t1607 - if !isnothing(deconstruct_result836) - unwrapped837 = deconstruct_result836 - write(pp, string(unwrapped837)) + deconstruct_result846 = _t1627 + if !isnothing(deconstruct_result846) + unwrapped847 = deconstruct_result846 + write(pp, string(unwrapped847)) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("float32_value")) - _t1608 = _get_oneof_field(_dollar_dollar, :float32_value) + _t1628 = _get_oneof_field(_dollar_dollar, :float32_value) else - _t1608 = nothing + _t1628 = nothing end - deconstruct_result834 = _t1608 - if !isnothing(deconstruct_result834) - unwrapped835 = deconstruct_result834 - write(pp, format_float32_literal(unwrapped835)) + deconstruct_result844 = _t1628 + if !isnothing(deconstruct_result844) + unwrapped845 = deconstruct_result844 + write(pp, format_float32_literal(unwrapped845)) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("float_value")) - _t1609 = _get_oneof_field(_dollar_dollar, :float_value) + _t1629 = _get_oneof_field(_dollar_dollar, :float_value) else - _t1609 = nothing + _t1629 = nothing end - deconstruct_result832 = _t1609 - if !isnothing(deconstruct_result832) - unwrapped833 = deconstruct_result832 - write(pp, lowercase(string(unwrapped833))) + deconstruct_result842 = _t1629 + if !isnothing(deconstruct_result842) + unwrapped843 = deconstruct_result842 + write(pp, lowercase(string(unwrapped843))) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("uint32_value")) - _t1610 = _get_oneof_field(_dollar_dollar, :uint32_value) + _t1630 = _get_oneof_field(_dollar_dollar, :uint32_value) else - _t1610 = nothing + _t1630 = nothing end - deconstruct_result830 = _t1610 - if !isnothing(deconstruct_result830) - unwrapped831 = deconstruct_result830 - write(pp, (string(Int64(unwrapped831)) * "u32")) + deconstruct_result840 = _t1630 + if !isnothing(deconstruct_result840) + unwrapped841 = deconstruct_result840 + write(pp, (string(Int64(unwrapped841)) * "u32")) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("uint128_value")) - _t1611 = _get_oneof_field(_dollar_dollar, :uint128_value) + _t1631 = _get_oneof_field(_dollar_dollar, :uint128_value) else - _t1611 = nothing + _t1631 = nothing end - deconstruct_result828 = _t1611 - if !isnothing(deconstruct_result828) - unwrapped829 = deconstruct_result828 - write(pp, format_uint128(DEFAULT_CONSTANT_FORMATTER, pp, unwrapped829)) + deconstruct_result838 = _t1631 + if !isnothing(deconstruct_result838) + unwrapped839 = deconstruct_result838 + write(pp, format_uint128(DEFAULT_CONSTANT_FORMATTER, pp, unwrapped839)) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("int128_value")) - _t1612 = _get_oneof_field(_dollar_dollar, :int128_value) + _t1632 = _get_oneof_field(_dollar_dollar, :int128_value) else - _t1612 = nothing + _t1632 = nothing end - deconstruct_result826 = _t1612 - if !isnothing(deconstruct_result826) - unwrapped827 = deconstruct_result826 - write(pp, format_int128(DEFAULT_CONSTANT_FORMATTER, pp, unwrapped827)) + deconstruct_result836 = _t1632 + if !isnothing(deconstruct_result836) + unwrapped837 = deconstruct_result836 + write(pp, format_int128(DEFAULT_CONSTANT_FORMATTER, pp, unwrapped837)) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("decimal_value")) - _t1613 = _get_oneof_field(_dollar_dollar, :decimal_value) + _t1633 = _get_oneof_field(_dollar_dollar, :decimal_value) else - _t1613 = nothing + _t1633 = nothing end - deconstruct_result824 = _t1613 - if !isnothing(deconstruct_result824) - unwrapped825 = deconstruct_result824 - write(pp, format_decimal(DEFAULT_CONSTANT_FORMATTER, pp, unwrapped825)) + deconstruct_result834 = _t1633 + if !isnothing(deconstruct_result834) + unwrapped835 = deconstruct_result834 + write(pp, format_decimal(DEFAULT_CONSTANT_FORMATTER, pp, unwrapped835)) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("boolean_value")) - _t1614 = _get_oneof_field(_dollar_dollar, :boolean_value) + _t1634 = _get_oneof_field(_dollar_dollar, :boolean_value) else - _t1614 = nothing + _t1634 = nothing end - deconstruct_result822 = _t1614 - if !isnothing(deconstruct_result822) - unwrapped823 = deconstruct_result822 - pretty_boolean_value(pp, unwrapped823) + deconstruct_result832 = _t1634 + if !isnothing(deconstruct_result832) + unwrapped833 = deconstruct_result832 + pretty_boolean_value(pp, unwrapped833) else - fields821 = msg + fields831 = msg write(pp, "missing") end end @@ -909,25 +909,25 @@ function pretty_raw_value(pp::PrettyPrinter, msg::Proto.Value) end function pretty_raw_date(pp::PrettyPrinter, msg::Proto.DateValue) - flat852 = try_flat(pp, msg, pretty_raw_date) - if !isnothing(flat852) - write(pp, flat852) + flat862 = try_flat(pp, msg, pretty_raw_date) + if !isnothing(flat862) + write(pp, flat862) return nothing else _dollar_dollar = msg - fields847 = (Int64(_dollar_dollar.year), Int64(_dollar_dollar.month), Int64(_dollar_dollar.day),) - unwrapped_fields848 = fields847 + fields857 = (Int64(_dollar_dollar.year), Int64(_dollar_dollar.month), Int64(_dollar_dollar.day),) + unwrapped_fields858 = fields857 write(pp, "(date") indent_sexp!(pp) newline(pp) - field849 = unwrapped_fields848[1] - write(pp, string(field849)) + field859 = unwrapped_fields858[1] + write(pp, string(field859)) newline(pp) - field850 = unwrapped_fields848[2] - write(pp, string(field850)) + field860 = unwrapped_fields858[2] + write(pp, string(field860)) newline(pp) - field851 = unwrapped_fields848[3] - write(pp, string(field851)) + field861 = unwrapped_fields858[3] + write(pp, string(field861)) dedent!(pp) write(pp, ")") end @@ -935,39 +935,39 @@ function pretty_raw_date(pp::PrettyPrinter, msg::Proto.DateValue) end function pretty_raw_datetime(pp::PrettyPrinter, msg::Proto.DateTimeValue) - flat863 = try_flat(pp, msg, pretty_raw_datetime) - if !isnothing(flat863) - write(pp, flat863) + flat873 = try_flat(pp, msg, pretty_raw_datetime) + if !isnothing(flat873) + write(pp, flat873) return nothing else _dollar_dollar = msg - fields853 = (Int64(_dollar_dollar.year), Int64(_dollar_dollar.month), Int64(_dollar_dollar.day), Int64(_dollar_dollar.hour), Int64(_dollar_dollar.minute), Int64(_dollar_dollar.second), Int64(_dollar_dollar.microsecond),) - unwrapped_fields854 = fields853 + fields863 = (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_fields864 = fields863 write(pp, "(datetime") indent_sexp!(pp) newline(pp) - field855 = unwrapped_fields854[1] - write(pp, string(field855)) + field865 = unwrapped_fields864[1] + write(pp, string(field865)) newline(pp) - field856 = unwrapped_fields854[2] - write(pp, string(field856)) + field866 = unwrapped_fields864[2] + write(pp, string(field866)) newline(pp) - field857 = unwrapped_fields854[3] - write(pp, string(field857)) + field867 = unwrapped_fields864[3] + write(pp, string(field867)) newline(pp) - field858 = unwrapped_fields854[4] - write(pp, string(field858)) + field868 = unwrapped_fields864[4] + write(pp, string(field868)) newline(pp) - field859 = unwrapped_fields854[5] - write(pp, string(field859)) + field869 = unwrapped_fields864[5] + write(pp, string(field869)) newline(pp) - field860 = unwrapped_fields854[6] - write(pp, string(field860)) - field861 = unwrapped_fields854[7] - if !isnothing(field861) + field870 = unwrapped_fields864[6] + write(pp, string(field870)) + field871 = unwrapped_fields864[7] + if !isnothing(field871) newline(pp) - opt_val862 = field861 - write(pp, string(opt_val862)) + opt_val872 = field871 + write(pp, string(opt_val872)) end dedent!(pp) write(pp, ")") @@ -978,24 +978,24 @@ end function pretty_boolean_value(pp::PrettyPrinter, msg::Bool) _dollar_dollar = msg if _dollar_dollar - _t1615 = () + _t1635 = () else - _t1615 = nothing + _t1635 = nothing end - deconstruct_result866 = _t1615 - if !isnothing(deconstruct_result866) - unwrapped867 = deconstruct_result866 + deconstruct_result876 = _t1635 + if !isnothing(deconstruct_result876) + unwrapped877 = deconstruct_result876 write(pp, "true") else _dollar_dollar = msg if !_dollar_dollar - _t1616 = () + _t1636 = () else - _t1616 = nothing + _t1636 = nothing end - deconstruct_result864 = _t1616 - if !isnothing(deconstruct_result864) - unwrapped865 = deconstruct_result864 + deconstruct_result874 = _t1636 + if !isnothing(deconstruct_result874) + unwrapped875 = deconstruct_result874 write(pp, "false") else throw(ParseError("No matching rule for boolean_value")) @@ -1005,24 +1005,24 @@ function pretty_boolean_value(pp::PrettyPrinter, msg::Bool) end function pretty_sync(pp::PrettyPrinter, msg::Proto.Sync) - flat872 = try_flat(pp, msg, pretty_sync) - if !isnothing(flat872) - write(pp, flat872) + flat882 = try_flat(pp, msg, pretty_sync) + if !isnothing(flat882) + write(pp, flat882) return nothing else _dollar_dollar = msg - fields868 = _dollar_dollar.fragments - unwrapped_fields869 = fields868 + fields878 = _dollar_dollar.fragments + unwrapped_fields879 = fields878 write(pp, "(sync") indent_sexp!(pp) - if !isempty(unwrapped_fields869) + if !isempty(unwrapped_fields879) newline(pp) - for (i1617, elem870) in enumerate(unwrapped_fields869) - i871 = i1617 - 1 - if (i871 > 0) + for (i1637, elem880) in enumerate(unwrapped_fields879) + i881 = i1637 - 1 + if (i881 > 0) newline(pp) end - pretty_fragment_id(pp, elem870) + pretty_fragment_id(pp, elem880) end end dedent!(pp) @@ -1032,52 +1032,52 @@ function pretty_sync(pp::PrettyPrinter, msg::Proto.Sync) end function pretty_fragment_id(pp::PrettyPrinter, msg::Proto.FragmentId) - flat875 = try_flat(pp, msg, pretty_fragment_id) - if !isnothing(flat875) - write(pp, flat875) + flat885 = try_flat(pp, msg, pretty_fragment_id) + if !isnothing(flat885) + write(pp, flat885) return nothing else _dollar_dollar = msg - fields873 = fragment_id_to_string(pp, _dollar_dollar) - unwrapped_fields874 = fields873 + fields883 = fragment_id_to_string(pp, _dollar_dollar) + unwrapped_fields884 = fields883 write(pp, ":") - write(pp, unwrapped_fields874) + write(pp, unwrapped_fields884) end return nothing end function pretty_epoch(pp::PrettyPrinter, msg::Proto.Epoch) - flat882 = try_flat(pp, msg, pretty_epoch) - if !isnothing(flat882) - write(pp, flat882) + flat892 = try_flat(pp, msg, pretty_epoch) + if !isnothing(flat892) + write(pp, flat892) return nothing else _dollar_dollar = msg if !isempty(_dollar_dollar.writes) - _t1618 = _dollar_dollar.writes + _t1638 = _dollar_dollar.writes else - _t1618 = nothing + _t1638 = nothing end if !isempty(_dollar_dollar.reads) - _t1619 = _dollar_dollar.reads + _t1639 = _dollar_dollar.reads else - _t1619 = nothing + _t1639 = nothing end - fields876 = (_t1618, _t1619,) - unwrapped_fields877 = fields876 + fields886 = (_t1638, _t1639,) + unwrapped_fields887 = fields886 write(pp, "(epoch") indent_sexp!(pp) - field878 = unwrapped_fields877[1] - if !isnothing(field878) + field888 = unwrapped_fields887[1] + if !isnothing(field888) newline(pp) - opt_val879 = field878 - pretty_epoch_writes(pp, opt_val879) + opt_val889 = field888 + pretty_epoch_writes(pp, opt_val889) end - field880 = unwrapped_fields877[2] - if !isnothing(field880) + field890 = unwrapped_fields887[2] + if !isnothing(field890) newline(pp) - opt_val881 = field880 - pretty_epoch_reads(pp, opt_val881) + opt_val891 = field890 + pretty_epoch_reads(pp, opt_val891) end dedent!(pp) write(pp, ")") @@ -1086,22 +1086,22 @@ function pretty_epoch(pp::PrettyPrinter, msg::Proto.Epoch) end function pretty_epoch_writes(pp::PrettyPrinter, msg::Vector{Proto.Write}) - flat886 = try_flat(pp, msg, pretty_epoch_writes) - if !isnothing(flat886) - write(pp, flat886) + flat896 = try_flat(pp, msg, pretty_epoch_writes) + if !isnothing(flat896) + write(pp, flat896) return nothing else - fields883 = msg + fields893 = msg write(pp, "(writes") indent_sexp!(pp) - if !isempty(fields883) + if !isempty(fields893) newline(pp) - for (i1620, elem884) in enumerate(fields883) - i885 = i1620 - 1 - if (i885 > 0) + for (i1640, elem894) in enumerate(fields893) + i895 = i1640 - 1 + if (i895 > 0) newline(pp) end - pretty_write(pp, elem884) + pretty_write(pp, elem894) end end dedent!(pp) @@ -1111,54 +1111,54 @@ function pretty_epoch_writes(pp::PrettyPrinter, msg::Vector{Proto.Write}) end function pretty_write(pp::PrettyPrinter, msg::Proto.Write) - flat895 = try_flat(pp, msg, pretty_write) - if !isnothing(flat895) - write(pp, flat895) + flat905 = try_flat(pp, msg, pretty_write) + if !isnothing(flat905) + write(pp, flat905) return nothing else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("define")) - _t1621 = _get_oneof_field(_dollar_dollar, :define) + _t1641 = _get_oneof_field(_dollar_dollar, :define) else - _t1621 = nothing + _t1641 = nothing end - deconstruct_result893 = _t1621 - if !isnothing(deconstruct_result893) - unwrapped894 = deconstruct_result893 - pretty_define(pp, unwrapped894) + deconstruct_result903 = _t1641 + if !isnothing(deconstruct_result903) + unwrapped904 = deconstruct_result903 + pretty_define(pp, unwrapped904) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("undefine")) - _t1622 = _get_oneof_field(_dollar_dollar, :undefine) + _t1642 = _get_oneof_field(_dollar_dollar, :undefine) else - _t1622 = nothing + _t1642 = nothing end - deconstruct_result891 = _t1622 - if !isnothing(deconstruct_result891) - unwrapped892 = deconstruct_result891 - pretty_undefine(pp, unwrapped892) + deconstruct_result901 = _t1642 + if !isnothing(deconstruct_result901) + unwrapped902 = deconstruct_result901 + pretty_undefine(pp, unwrapped902) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("context")) - _t1623 = _get_oneof_field(_dollar_dollar, :context) + _t1643 = _get_oneof_field(_dollar_dollar, :context) else - _t1623 = nothing + _t1643 = nothing end - deconstruct_result889 = _t1623 - if !isnothing(deconstruct_result889) - unwrapped890 = deconstruct_result889 - pretty_context(pp, unwrapped890) + deconstruct_result899 = _t1643 + if !isnothing(deconstruct_result899) + unwrapped900 = deconstruct_result899 + pretty_context(pp, unwrapped900) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("snapshot")) - _t1624 = _get_oneof_field(_dollar_dollar, :snapshot) + _t1644 = _get_oneof_field(_dollar_dollar, :snapshot) else - _t1624 = nothing + _t1644 = nothing end - deconstruct_result887 = _t1624 - if !isnothing(deconstruct_result887) - unwrapped888 = deconstruct_result887 - pretty_snapshot(pp, unwrapped888) + deconstruct_result897 = _t1644 + if !isnothing(deconstruct_result897) + unwrapped898 = deconstruct_result897 + pretty_snapshot(pp, unwrapped898) else throw(ParseError("No matching rule for write")) end @@ -1170,18 +1170,18 @@ function pretty_write(pp::PrettyPrinter, msg::Proto.Write) end function pretty_define(pp::PrettyPrinter, msg::Proto.Define) - flat898 = try_flat(pp, msg, pretty_define) - if !isnothing(flat898) - write(pp, flat898) + flat908 = try_flat(pp, msg, pretty_define) + if !isnothing(flat908) + write(pp, flat908) return nothing else _dollar_dollar = msg - fields896 = _dollar_dollar.fragment - unwrapped_fields897 = fields896 + fields906 = _dollar_dollar.fragment + unwrapped_fields907 = fields906 write(pp, "(define") indent_sexp!(pp) newline(pp) - pretty_fragment(pp, unwrapped_fields897) + pretty_fragment(pp, unwrapped_fields907) dedent!(pp) write(pp, ")") end @@ -1189,29 +1189,29 @@ function pretty_define(pp::PrettyPrinter, msg::Proto.Define) end function pretty_fragment(pp::PrettyPrinter, msg::Proto.Fragment) - flat905 = try_flat(pp, msg, pretty_fragment) - if !isnothing(flat905) - write(pp, flat905) + flat915 = try_flat(pp, msg, pretty_fragment) + if !isnothing(flat915) + write(pp, flat915) return nothing else _dollar_dollar = msg start_pretty_fragment(pp, _dollar_dollar) - fields899 = (_dollar_dollar.id, _dollar_dollar.declarations,) - unwrapped_fields900 = fields899 + fields909 = (_dollar_dollar.id, _dollar_dollar.declarations,) + unwrapped_fields910 = fields909 write(pp, "(fragment") indent_sexp!(pp) newline(pp) - field901 = unwrapped_fields900[1] - pretty_new_fragment_id(pp, field901) - field902 = unwrapped_fields900[2] - if !isempty(field902) + field911 = unwrapped_fields910[1] + pretty_new_fragment_id(pp, field911) + field912 = unwrapped_fields910[2] + if !isempty(field912) newline(pp) - for (i1625, elem903) in enumerate(field902) - i904 = i1625 - 1 - if (i904 > 0) + for (i1645, elem913) in enumerate(field912) + i914 = i1645 - 1 + if (i914 > 0) newline(pp) end - pretty_declaration(pp, elem903) + pretty_declaration(pp, elem913) end end dedent!(pp) @@ -1221,66 +1221,66 @@ function pretty_fragment(pp::PrettyPrinter, msg::Proto.Fragment) end function pretty_new_fragment_id(pp::PrettyPrinter, msg::Proto.FragmentId) - flat907 = try_flat(pp, msg, pretty_new_fragment_id) - if !isnothing(flat907) - write(pp, flat907) + flat917 = try_flat(pp, msg, pretty_new_fragment_id) + if !isnothing(flat917) + write(pp, flat917) return nothing else - fields906 = msg - pretty_fragment_id(pp, fields906) + fields916 = msg + pretty_fragment_id(pp, fields916) end return nothing end function pretty_declaration(pp::PrettyPrinter, msg::Proto.Declaration) - flat916 = try_flat(pp, msg, pretty_declaration) - if !isnothing(flat916) - write(pp, flat916) + flat926 = try_flat(pp, msg, pretty_declaration) + if !isnothing(flat926) + write(pp, flat926) return nothing else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("def")) - _t1626 = _get_oneof_field(_dollar_dollar, :def) + _t1646 = _get_oneof_field(_dollar_dollar, :def) else - _t1626 = nothing + _t1646 = nothing end - deconstruct_result914 = _t1626 - if !isnothing(deconstruct_result914) - unwrapped915 = deconstruct_result914 - pretty_def(pp, unwrapped915) + deconstruct_result924 = _t1646 + if !isnothing(deconstruct_result924) + unwrapped925 = deconstruct_result924 + pretty_def(pp, unwrapped925) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("algorithm")) - _t1627 = _get_oneof_field(_dollar_dollar, :algorithm) + _t1647 = _get_oneof_field(_dollar_dollar, :algorithm) else - _t1627 = nothing + _t1647 = nothing end - deconstruct_result912 = _t1627 - if !isnothing(deconstruct_result912) - unwrapped913 = deconstruct_result912 - pretty_algorithm(pp, unwrapped913) + deconstruct_result922 = _t1647 + if !isnothing(deconstruct_result922) + unwrapped923 = deconstruct_result922 + pretty_algorithm(pp, unwrapped923) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("constraint")) - _t1628 = _get_oneof_field(_dollar_dollar, :constraint) + _t1648 = _get_oneof_field(_dollar_dollar, :constraint) else - _t1628 = nothing + _t1648 = nothing end - deconstruct_result910 = _t1628 - if !isnothing(deconstruct_result910) - unwrapped911 = deconstruct_result910 - pretty_constraint(pp, unwrapped911) + deconstruct_result920 = _t1648 + if !isnothing(deconstruct_result920) + unwrapped921 = deconstruct_result920 + pretty_constraint(pp, unwrapped921) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("data")) - _t1629 = _get_oneof_field(_dollar_dollar, :data) + _t1649 = _get_oneof_field(_dollar_dollar, :data) else - _t1629 = nothing + _t1649 = nothing end - deconstruct_result908 = _t1629 - if !isnothing(deconstruct_result908) - unwrapped909 = deconstruct_result908 - pretty_data(pp, unwrapped909) + deconstruct_result918 = _t1649 + if !isnothing(deconstruct_result918) + unwrapped919 = deconstruct_result918 + pretty_data(pp, unwrapped919) else throw(ParseError("No matching rule for declaration")) end @@ -1292,32 +1292,32 @@ function pretty_declaration(pp::PrettyPrinter, msg::Proto.Declaration) end function pretty_def(pp::PrettyPrinter, msg::Proto.Def) - flat923 = try_flat(pp, msg, pretty_def) - if !isnothing(flat923) - write(pp, flat923) + flat933 = try_flat(pp, msg, pretty_def) + if !isnothing(flat933) + write(pp, flat933) return nothing else _dollar_dollar = msg if !isempty(_dollar_dollar.attrs) - _t1630 = _dollar_dollar.attrs + _t1650 = _dollar_dollar.attrs else - _t1630 = nothing + _t1650 = nothing end - fields917 = (_dollar_dollar.name, _dollar_dollar.body, _t1630,) - unwrapped_fields918 = fields917 + fields927 = (_dollar_dollar.name, _dollar_dollar.body, _t1650,) + unwrapped_fields928 = fields927 write(pp, "(def") indent_sexp!(pp) newline(pp) - field919 = unwrapped_fields918[1] - pretty_relation_id(pp, field919) + field929 = unwrapped_fields928[1] + pretty_relation_id(pp, field929) newline(pp) - field920 = unwrapped_fields918[2] - pretty_abstraction(pp, field920) - field921 = unwrapped_fields918[3] - if !isnothing(field921) + field930 = unwrapped_fields928[2] + pretty_abstraction(pp, field930) + field931 = unwrapped_fields928[3] + if !isnothing(field931) newline(pp) - opt_val922 = field921 - pretty_attrs(pp, opt_val922) + opt_val932 = field931 + pretty_attrs(pp, opt_val932) end dedent!(pp) write(pp, ")") @@ -1326,30 +1326,30 @@ function pretty_def(pp::PrettyPrinter, msg::Proto.Def) end function pretty_relation_id(pp::PrettyPrinter, msg::Proto.RelationId) - flat928 = try_flat(pp, msg, pretty_relation_id) - if !isnothing(flat928) - write(pp, flat928) + flat938 = try_flat(pp, msg, pretty_relation_id) + if !isnothing(flat938) + write(pp, flat938) return nothing else _dollar_dollar = msg if !isnothing(relation_id_to_string(pp, _dollar_dollar)) - _t1632 = deconstruct_relation_id_string(pp, _dollar_dollar) - _t1631 = _t1632 + _t1652 = deconstruct_relation_id_string(pp, _dollar_dollar) + _t1651 = _t1652 else - _t1631 = nothing + _t1651 = nothing end - deconstruct_result926 = _t1631 - if !isnothing(deconstruct_result926) - unwrapped927 = deconstruct_result926 + deconstruct_result936 = _t1651 + if !isnothing(deconstruct_result936) + unwrapped937 = deconstruct_result936 write(pp, ":") - write(pp, unwrapped927) + write(pp, unwrapped937) else _dollar_dollar = msg - _t1633 = deconstruct_relation_id_uint128(pp, _dollar_dollar) - deconstruct_result924 = _t1633 - if !isnothing(deconstruct_result924) - unwrapped925 = deconstruct_result924 - write(pp, format_uint128(DEFAULT_CONSTANT_FORMATTER, pp, unwrapped925)) + _t1653 = deconstruct_relation_id_uint128(pp, _dollar_dollar) + deconstruct_result934 = _t1653 + if !isnothing(deconstruct_result934) + unwrapped935 = deconstruct_result934 + write(pp, format_uint128(DEFAULT_CONSTANT_FORMATTER, pp, unwrapped935)) else throw(ParseError("No matching rule for relation_id")) end @@ -1359,22 +1359,22 @@ function pretty_relation_id(pp::PrettyPrinter, msg::Proto.RelationId) end function pretty_abstraction(pp::PrettyPrinter, msg::Proto.Abstraction) - flat933 = try_flat(pp, msg, pretty_abstraction) - if !isnothing(flat933) - write(pp, flat933) + flat943 = try_flat(pp, msg, pretty_abstraction) + if !isnothing(flat943) + write(pp, flat943) return nothing else _dollar_dollar = msg - _t1634 = deconstruct_bindings(pp, _dollar_dollar) - fields929 = (_t1634, _dollar_dollar.value,) - unwrapped_fields930 = fields929 + _t1654 = deconstruct_bindings(pp, _dollar_dollar) + fields939 = (_t1654, _dollar_dollar.value,) + unwrapped_fields940 = fields939 write(pp, "(") indent!(pp) - field931 = unwrapped_fields930[1] - pretty_bindings(pp, field931) + field941 = unwrapped_fields940[1] + pretty_bindings(pp, field941) newline(pp) - field932 = unwrapped_fields930[2] - pretty_formula(pp, field932) + field942 = unwrapped_fields940[2] + pretty_formula(pp, field942) dedent!(pp) write(pp, ")") end @@ -1382,34 +1382,34 @@ function pretty_abstraction(pp::PrettyPrinter, msg::Proto.Abstraction) end function pretty_bindings(pp::PrettyPrinter, msg::Tuple{Vector{Proto.Binding}, Vector{Proto.Binding}}) - flat941 = try_flat(pp, msg, pretty_bindings) - if !isnothing(flat941) - write(pp, flat941) + flat951 = try_flat(pp, msg, pretty_bindings) + if !isnothing(flat951) + write(pp, flat951) return nothing else _dollar_dollar = msg if !isempty(_dollar_dollar[2]) - _t1635 = _dollar_dollar[2] + _t1655 = _dollar_dollar[2] else - _t1635 = nothing + _t1655 = nothing end - fields934 = (_dollar_dollar[1], _t1635,) - unwrapped_fields935 = fields934 + fields944 = (_dollar_dollar[1], _t1655,) + unwrapped_fields945 = fields944 write(pp, "[") indent!(pp) - field936 = unwrapped_fields935[1] - for (i1636, elem937) in enumerate(field936) - i938 = i1636 - 1 - if (i938 > 0) + field946 = unwrapped_fields945[1] + for (i1656, elem947) in enumerate(field946) + i948 = i1656 - 1 + if (i948 > 0) newline(pp) end - pretty_binding(pp, elem937) + pretty_binding(pp, elem947) end - field939 = unwrapped_fields935[2] - if !isnothing(field939) + field949 = unwrapped_fields945[2] + if !isnothing(field949) newline(pp) - opt_val940 = field939 - pretty_value_bindings(pp, opt_val940) + opt_val950 = field949 + pretty_value_bindings(pp, opt_val950) end dedent!(pp) write(pp, "]") @@ -1418,182 +1418,182 @@ function pretty_bindings(pp::PrettyPrinter, msg::Tuple{Vector{Proto.Binding}, Ve end function pretty_binding(pp::PrettyPrinter, msg::Proto.Binding) - flat946 = try_flat(pp, msg, pretty_binding) - if !isnothing(flat946) - write(pp, flat946) + flat956 = try_flat(pp, msg, pretty_binding) + if !isnothing(flat956) + write(pp, flat956) return nothing else _dollar_dollar = msg - fields942 = (_dollar_dollar.var.name, _dollar_dollar.var"#type",) - unwrapped_fields943 = fields942 - field944 = unwrapped_fields943[1] - write(pp, field944) + fields952 = (_dollar_dollar.var.name, _dollar_dollar.var"#type",) + unwrapped_fields953 = fields952 + field954 = unwrapped_fields953[1] + write(pp, field954) write(pp, "::") - field945 = unwrapped_fields943[2] - pretty_type(pp, field945) + field955 = unwrapped_fields953[2] + pretty_type(pp, field955) end return nothing end function pretty_type(pp::PrettyPrinter, msg::Proto.var"#Type") - flat975 = try_flat(pp, msg, pretty_type) - if !isnothing(flat975) - write(pp, flat975) + flat985 = try_flat(pp, msg, pretty_type) + if !isnothing(flat985) + write(pp, flat985) return nothing else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("unspecified_type")) - _t1637 = _get_oneof_field(_dollar_dollar, :unspecified_type) + _t1657 = _get_oneof_field(_dollar_dollar, :unspecified_type) else - _t1637 = nothing + _t1657 = nothing end - deconstruct_result973 = _t1637 - if !isnothing(deconstruct_result973) - unwrapped974 = deconstruct_result973 - pretty_unspecified_type(pp, unwrapped974) + deconstruct_result983 = _t1657 + if !isnothing(deconstruct_result983) + unwrapped984 = deconstruct_result983 + pretty_unspecified_type(pp, unwrapped984) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("string_type")) - _t1638 = _get_oneof_field(_dollar_dollar, :string_type) + _t1658 = _get_oneof_field(_dollar_dollar, :string_type) else - _t1638 = nothing + _t1658 = nothing end - deconstruct_result971 = _t1638 - if !isnothing(deconstruct_result971) - unwrapped972 = deconstruct_result971 - pretty_string_type(pp, unwrapped972) + deconstruct_result981 = _t1658 + if !isnothing(deconstruct_result981) + unwrapped982 = deconstruct_result981 + pretty_string_type(pp, unwrapped982) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("int_type")) - _t1639 = _get_oneof_field(_dollar_dollar, :int_type) + _t1659 = _get_oneof_field(_dollar_dollar, :int_type) else - _t1639 = nothing + _t1659 = nothing end - deconstruct_result969 = _t1639 - if !isnothing(deconstruct_result969) - unwrapped970 = deconstruct_result969 - pretty_int_type(pp, unwrapped970) + deconstruct_result979 = _t1659 + if !isnothing(deconstruct_result979) + unwrapped980 = deconstruct_result979 + pretty_int_type(pp, unwrapped980) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("float_type")) - _t1640 = _get_oneof_field(_dollar_dollar, :float_type) + _t1660 = _get_oneof_field(_dollar_dollar, :float_type) else - _t1640 = nothing + _t1660 = nothing end - deconstruct_result967 = _t1640 - if !isnothing(deconstruct_result967) - unwrapped968 = deconstruct_result967 - pretty_float_type(pp, unwrapped968) + deconstruct_result977 = _t1660 + if !isnothing(deconstruct_result977) + unwrapped978 = deconstruct_result977 + pretty_float_type(pp, unwrapped978) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("uint128_type")) - _t1641 = _get_oneof_field(_dollar_dollar, :uint128_type) + _t1661 = _get_oneof_field(_dollar_dollar, :uint128_type) else - _t1641 = nothing + _t1661 = nothing end - deconstruct_result965 = _t1641 - if !isnothing(deconstruct_result965) - unwrapped966 = deconstruct_result965 - pretty_uint128_type(pp, unwrapped966) + deconstruct_result975 = _t1661 + if !isnothing(deconstruct_result975) + unwrapped976 = deconstruct_result975 + pretty_uint128_type(pp, unwrapped976) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("int128_type")) - _t1642 = _get_oneof_field(_dollar_dollar, :int128_type) + _t1662 = _get_oneof_field(_dollar_dollar, :int128_type) else - _t1642 = nothing + _t1662 = nothing end - deconstruct_result963 = _t1642 - if !isnothing(deconstruct_result963) - unwrapped964 = deconstruct_result963 - pretty_int128_type(pp, unwrapped964) + deconstruct_result973 = _t1662 + if !isnothing(deconstruct_result973) + unwrapped974 = deconstruct_result973 + pretty_int128_type(pp, unwrapped974) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("date_type")) - _t1643 = _get_oneof_field(_dollar_dollar, :date_type) + _t1663 = _get_oneof_field(_dollar_dollar, :date_type) else - _t1643 = nothing + _t1663 = nothing end - deconstruct_result961 = _t1643 - if !isnothing(deconstruct_result961) - unwrapped962 = deconstruct_result961 - pretty_date_type(pp, unwrapped962) + deconstruct_result971 = _t1663 + if !isnothing(deconstruct_result971) + unwrapped972 = deconstruct_result971 + pretty_date_type(pp, unwrapped972) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("datetime_type")) - _t1644 = _get_oneof_field(_dollar_dollar, :datetime_type) + _t1664 = _get_oneof_field(_dollar_dollar, :datetime_type) else - _t1644 = nothing + _t1664 = nothing end - deconstruct_result959 = _t1644 - if !isnothing(deconstruct_result959) - unwrapped960 = deconstruct_result959 - pretty_datetime_type(pp, unwrapped960) + deconstruct_result969 = _t1664 + if !isnothing(deconstruct_result969) + unwrapped970 = deconstruct_result969 + pretty_datetime_type(pp, unwrapped970) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("missing_type")) - _t1645 = _get_oneof_field(_dollar_dollar, :missing_type) + _t1665 = _get_oneof_field(_dollar_dollar, :missing_type) else - _t1645 = nothing + _t1665 = nothing end - deconstruct_result957 = _t1645 - if !isnothing(deconstruct_result957) - unwrapped958 = deconstruct_result957 - pretty_missing_type(pp, unwrapped958) + deconstruct_result967 = _t1665 + if !isnothing(deconstruct_result967) + unwrapped968 = deconstruct_result967 + pretty_missing_type(pp, unwrapped968) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("decimal_type")) - _t1646 = _get_oneof_field(_dollar_dollar, :decimal_type) + _t1666 = _get_oneof_field(_dollar_dollar, :decimal_type) else - _t1646 = nothing + _t1666 = nothing end - deconstruct_result955 = _t1646 - if !isnothing(deconstruct_result955) - unwrapped956 = deconstruct_result955 - pretty_decimal_type(pp, unwrapped956) + deconstruct_result965 = _t1666 + if !isnothing(deconstruct_result965) + unwrapped966 = deconstruct_result965 + pretty_decimal_type(pp, unwrapped966) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("boolean_type")) - _t1647 = _get_oneof_field(_dollar_dollar, :boolean_type) + _t1667 = _get_oneof_field(_dollar_dollar, :boolean_type) else - _t1647 = nothing + _t1667 = nothing end - deconstruct_result953 = _t1647 - if !isnothing(deconstruct_result953) - unwrapped954 = deconstruct_result953 - pretty_boolean_type(pp, unwrapped954) + deconstruct_result963 = _t1667 + if !isnothing(deconstruct_result963) + unwrapped964 = deconstruct_result963 + pretty_boolean_type(pp, unwrapped964) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("int32_type")) - _t1648 = _get_oneof_field(_dollar_dollar, :int32_type) + _t1668 = _get_oneof_field(_dollar_dollar, :int32_type) else - _t1648 = nothing + _t1668 = nothing end - deconstruct_result951 = _t1648 - if !isnothing(deconstruct_result951) - unwrapped952 = deconstruct_result951 - pretty_int32_type(pp, unwrapped952) + deconstruct_result961 = _t1668 + if !isnothing(deconstruct_result961) + unwrapped962 = deconstruct_result961 + pretty_int32_type(pp, unwrapped962) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("float32_type")) - _t1649 = _get_oneof_field(_dollar_dollar, :float32_type) + _t1669 = _get_oneof_field(_dollar_dollar, :float32_type) else - _t1649 = nothing + _t1669 = nothing end - deconstruct_result949 = _t1649 - if !isnothing(deconstruct_result949) - unwrapped950 = deconstruct_result949 - pretty_float32_type(pp, unwrapped950) + deconstruct_result959 = _t1669 + if !isnothing(deconstruct_result959) + unwrapped960 = deconstruct_result959 + pretty_float32_type(pp, unwrapped960) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("uint32_type")) - _t1650 = _get_oneof_field(_dollar_dollar, :uint32_type) + _t1670 = _get_oneof_field(_dollar_dollar, :uint32_type) else - _t1650 = nothing + _t1670 = nothing end - deconstruct_result947 = _t1650 - if !isnothing(deconstruct_result947) - unwrapped948 = deconstruct_result947 - pretty_uint32_type(pp, unwrapped948) + deconstruct_result957 = _t1670 + if !isnothing(deconstruct_result957) + unwrapped958 = deconstruct_result957 + pretty_uint32_type(pp, unwrapped958) else throw(ParseError("No matching rule for type")) end @@ -1615,76 +1615,76 @@ function pretty_type(pp::PrettyPrinter, msg::Proto.var"#Type") end function pretty_unspecified_type(pp::PrettyPrinter, msg::Proto.UnspecifiedType) - fields976 = msg + fields986 = msg write(pp, "UNKNOWN") return nothing end function pretty_string_type(pp::PrettyPrinter, msg::Proto.StringType) - fields977 = msg + fields987 = msg write(pp, "STRING") return nothing end function pretty_int_type(pp::PrettyPrinter, msg::Proto.IntType) - fields978 = msg + fields988 = msg write(pp, "INT") return nothing end function pretty_float_type(pp::PrettyPrinter, msg::Proto.FloatType) - fields979 = msg + fields989 = msg write(pp, "FLOAT") return nothing end function pretty_uint128_type(pp::PrettyPrinter, msg::Proto.UInt128Type) - fields980 = msg + fields990 = msg write(pp, "UINT128") return nothing end function pretty_int128_type(pp::PrettyPrinter, msg::Proto.Int128Type) - fields981 = msg + fields991 = msg write(pp, "INT128") return nothing end function pretty_date_type(pp::PrettyPrinter, msg::Proto.DateType) - fields982 = msg + fields992 = msg write(pp, "DATE") return nothing end function pretty_datetime_type(pp::PrettyPrinter, msg::Proto.DateTimeType) - fields983 = msg + fields993 = msg write(pp, "DATETIME") return nothing end function pretty_missing_type(pp::PrettyPrinter, msg::Proto.MissingType) - fields984 = msg + fields994 = msg write(pp, "MISSING") return nothing end function pretty_decimal_type(pp::PrettyPrinter, msg::Proto.DecimalType) - flat989 = try_flat(pp, msg, pretty_decimal_type) - if !isnothing(flat989) - write(pp, flat989) + flat999 = try_flat(pp, msg, pretty_decimal_type) + if !isnothing(flat999) + write(pp, flat999) return nothing else _dollar_dollar = msg - fields985 = (Int64(_dollar_dollar.precision), Int64(_dollar_dollar.scale),) - unwrapped_fields986 = fields985 + fields995 = (Int64(_dollar_dollar.precision), Int64(_dollar_dollar.scale),) + unwrapped_fields996 = fields995 write(pp, "(DECIMAL") indent_sexp!(pp) newline(pp) - field987 = unwrapped_fields986[1] - write(pp, string(field987)) + field997 = unwrapped_fields996[1] + write(pp, string(field997)) newline(pp) - field988 = unwrapped_fields986[2] - write(pp, string(field988)) + field998 = unwrapped_fields996[2] + write(pp, string(field998)) dedent!(pp) write(pp, ")") end @@ -1692,45 +1692,45 @@ function pretty_decimal_type(pp::PrettyPrinter, msg::Proto.DecimalType) end function pretty_boolean_type(pp::PrettyPrinter, msg::Proto.BooleanType) - fields990 = msg + fields1000 = msg write(pp, "BOOLEAN") return nothing end function pretty_int32_type(pp::PrettyPrinter, msg::Proto.Int32Type) - fields991 = msg + fields1001 = msg write(pp, "INT32") return nothing end function pretty_float32_type(pp::PrettyPrinter, msg::Proto.Float32Type) - fields992 = msg + fields1002 = msg write(pp, "FLOAT32") return nothing end function pretty_uint32_type(pp::PrettyPrinter, msg::Proto.UInt32Type) - fields993 = msg + fields1003 = msg write(pp, "UINT32") return nothing end function pretty_value_bindings(pp::PrettyPrinter, msg::Vector{Proto.Binding}) - flat997 = try_flat(pp, msg, pretty_value_bindings) - if !isnothing(flat997) - write(pp, flat997) + flat1007 = try_flat(pp, msg, pretty_value_bindings) + if !isnothing(flat1007) + write(pp, flat1007) return nothing else - fields994 = msg + fields1004 = msg write(pp, "|") - if !isempty(fields994) + if !isempty(fields1004) write(pp, " ") - for (i1651, elem995) in enumerate(fields994) - i996 = i1651 - 1 - if (i996 > 0) + for (i1671, elem1005) in enumerate(fields1004) + i1006 = i1671 - 1 + if (i1006 > 0) newline(pp) end - pretty_binding(pp, elem995) + pretty_binding(pp, elem1005) end end end @@ -1738,153 +1738,153 @@ function pretty_value_bindings(pp::PrettyPrinter, msg::Vector{Proto.Binding}) end function pretty_formula(pp::PrettyPrinter, msg::Proto.Formula) - flat1024 = try_flat(pp, msg, pretty_formula) - if !isnothing(flat1024) - write(pp, flat1024) + flat1034 = try_flat(pp, msg, pretty_formula) + if !isnothing(flat1034) + write(pp, flat1034) return nothing else _dollar_dollar = msg if (_has_proto_field(_dollar_dollar, Symbol("conjunction")) && isempty(_get_oneof_field(_dollar_dollar, :conjunction).args)) - _t1652 = _get_oneof_field(_dollar_dollar, :conjunction) + _t1672 = _get_oneof_field(_dollar_dollar, :conjunction) else - _t1652 = nothing + _t1672 = nothing end - deconstruct_result1022 = _t1652 - if !isnothing(deconstruct_result1022) - unwrapped1023 = deconstruct_result1022 - pretty_true(pp, unwrapped1023) + deconstruct_result1032 = _t1672 + if !isnothing(deconstruct_result1032) + unwrapped1033 = deconstruct_result1032 + pretty_true(pp, unwrapped1033) else _dollar_dollar = msg if (_has_proto_field(_dollar_dollar, Symbol("disjunction")) && isempty(_get_oneof_field(_dollar_dollar, :disjunction).args)) - _t1653 = _get_oneof_field(_dollar_dollar, :disjunction) + _t1673 = _get_oneof_field(_dollar_dollar, :disjunction) else - _t1653 = nothing + _t1673 = nothing end - deconstruct_result1020 = _t1653 - if !isnothing(deconstruct_result1020) - unwrapped1021 = deconstruct_result1020 - pretty_false(pp, unwrapped1021) + deconstruct_result1030 = _t1673 + if !isnothing(deconstruct_result1030) + unwrapped1031 = deconstruct_result1030 + pretty_false(pp, unwrapped1031) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("exists")) - _t1654 = _get_oneof_field(_dollar_dollar, :exists) + _t1674 = _get_oneof_field(_dollar_dollar, :exists) else - _t1654 = nothing + _t1674 = nothing end - deconstruct_result1018 = _t1654 - if !isnothing(deconstruct_result1018) - unwrapped1019 = deconstruct_result1018 - pretty_exists(pp, unwrapped1019) + deconstruct_result1028 = _t1674 + if !isnothing(deconstruct_result1028) + unwrapped1029 = deconstruct_result1028 + pretty_exists(pp, unwrapped1029) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("reduce")) - _t1655 = _get_oneof_field(_dollar_dollar, :reduce) + _t1675 = _get_oneof_field(_dollar_dollar, :reduce) else - _t1655 = nothing + _t1675 = nothing end - deconstruct_result1016 = _t1655 - if !isnothing(deconstruct_result1016) - unwrapped1017 = deconstruct_result1016 - pretty_reduce(pp, unwrapped1017) + deconstruct_result1026 = _t1675 + if !isnothing(deconstruct_result1026) + unwrapped1027 = deconstruct_result1026 + pretty_reduce(pp, unwrapped1027) else _dollar_dollar = msg if (_has_proto_field(_dollar_dollar, Symbol("conjunction")) && !isempty(_get_oneof_field(_dollar_dollar, :conjunction).args)) - _t1656 = _get_oneof_field(_dollar_dollar, :conjunction) + _t1676 = _get_oneof_field(_dollar_dollar, :conjunction) else - _t1656 = nothing + _t1676 = nothing end - deconstruct_result1014 = _t1656 - if !isnothing(deconstruct_result1014) - unwrapped1015 = deconstruct_result1014 - pretty_conjunction(pp, unwrapped1015) + deconstruct_result1024 = _t1676 + if !isnothing(deconstruct_result1024) + unwrapped1025 = deconstruct_result1024 + pretty_conjunction(pp, unwrapped1025) else _dollar_dollar = msg if (_has_proto_field(_dollar_dollar, Symbol("disjunction")) && !isempty(_get_oneof_field(_dollar_dollar, :disjunction).args)) - _t1657 = _get_oneof_field(_dollar_dollar, :disjunction) + _t1677 = _get_oneof_field(_dollar_dollar, :disjunction) else - _t1657 = nothing + _t1677 = nothing end - deconstruct_result1012 = _t1657 - if !isnothing(deconstruct_result1012) - unwrapped1013 = deconstruct_result1012 - pretty_disjunction(pp, unwrapped1013) + deconstruct_result1022 = _t1677 + if !isnothing(deconstruct_result1022) + unwrapped1023 = deconstruct_result1022 + pretty_disjunction(pp, unwrapped1023) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("not")) - _t1658 = _get_oneof_field(_dollar_dollar, :not) + _t1678 = _get_oneof_field(_dollar_dollar, :not) else - _t1658 = nothing + _t1678 = nothing end - deconstruct_result1010 = _t1658 - if !isnothing(deconstruct_result1010) - unwrapped1011 = deconstruct_result1010 - pretty_not(pp, unwrapped1011) + deconstruct_result1020 = _t1678 + if !isnothing(deconstruct_result1020) + unwrapped1021 = deconstruct_result1020 + pretty_not(pp, unwrapped1021) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("ffi")) - _t1659 = _get_oneof_field(_dollar_dollar, :ffi) + _t1679 = _get_oneof_field(_dollar_dollar, :ffi) else - _t1659 = nothing + _t1679 = nothing end - deconstruct_result1008 = _t1659 - if !isnothing(deconstruct_result1008) - unwrapped1009 = deconstruct_result1008 - pretty_ffi(pp, unwrapped1009) + deconstruct_result1018 = _t1679 + if !isnothing(deconstruct_result1018) + unwrapped1019 = deconstruct_result1018 + pretty_ffi(pp, unwrapped1019) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("atom")) - _t1660 = _get_oneof_field(_dollar_dollar, :atom) + _t1680 = _get_oneof_field(_dollar_dollar, :atom) else - _t1660 = nothing + _t1680 = nothing end - deconstruct_result1006 = _t1660 - if !isnothing(deconstruct_result1006) - unwrapped1007 = deconstruct_result1006 - pretty_atom(pp, unwrapped1007) + deconstruct_result1016 = _t1680 + if !isnothing(deconstruct_result1016) + unwrapped1017 = deconstruct_result1016 + pretty_atom(pp, unwrapped1017) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("pragma")) - _t1661 = _get_oneof_field(_dollar_dollar, :pragma) + _t1681 = _get_oneof_field(_dollar_dollar, :pragma) else - _t1661 = nothing + _t1681 = nothing end - deconstruct_result1004 = _t1661 - if !isnothing(deconstruct_result1004) - unwrapped1005 = deconstruct_result1004 - pretty_pragma(pp, unwrapped1005) + deconstruct_result1014 = _t1681 + if !isnothing(deconstruct_result1014) + unwrapped1015 = deconstruct_result1014 + pretty_pragma(pp, unwrapped1015) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("primitive")) - _t1662 = _get_oneof_field(_dollar_dollar, :primitive) + _t1682 = _get_oneof_field(_dollar_dollar, :primitive) else - _t1662 = nothing + _t1682 = nothing end - deconstruct_result1002 = _t1662 - if !isnothing(deconstruct_result1002) - unwrapped1003 = deconstruct_result1002 - pretty_primitive(pp, unwrapped1003) + deconstruct_result1012 = _t1682 + if !isnothing(deconstruct_result1012) + unwrapped1013 = deconstruct_result1012 + pretty_primitive(pp, unwrapped1013) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("rel_atom")) - _t1663 = _get_oneof_field(_dollar_dollar, :rel_atom) + _t1683 = _get_oneof_field(_dollar_dollar, :rel_atom) else - _t1663 = nothing + _t1683 = nothing end - deconstruct_result1000 = _t1663 - if !isnothing(deconstruct_result1000) - unwrapped1001 = deconstruct_result1000 - pretty_rel_atom(pp, unwrapped1001) + deconstruct_result1010 = _t1683 + if !isnothing(deconstruct_result1010) + unwrapped1011 = deconstruct_result1010 + pretty_rel_atom(pp, unwrapped1011) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("cast")) - _t1664 = _get_oneof_field(_dollar_dollar, :cast) + _t1684 = _get_oneof_field(_dollar_dollar, :cast) else - _t1664 = nothing + _t1684 = nothing end - deconstruct_result998 = _t1664 - if !isnothing(deconstruct_result998) - unwrapped999 = deconstruct_result998 - pretty_cast(pp, unwrapped999) + deconstruct_result1008 = _t1684 + if !isnothing(deconstruct_result1008) + unwrapped1009 = deconstruct_result1008 + pretty_cast(pp, unwrapped1009) else throw(ParseError("No matching rule for formula")) end @@ -1905,35 +1905,35 @@ function pretty_formula(pp::PrettyPrinter, msg::Proto.Formula) end function pretty_true(pp::PrettyPrinter, msg::Proto.Conjunction) - fields1025 = msg + fields1035 = msg write(pp, "(true)") return nothing end function pretty_false(pp::PrettyPrinter, msg::Proto.Disjunction) - fields1026 = msg + fields1036 = msg write(pp, "(false)") return nothing end function pretty_exists(pp::PrettyPrinter, msg::Proto.Exists) - flat1031 = try_flat(pp, msg, pretty_exists) - if !isnothing(flat1031) - write(pp, flat1031) + flat1041 = try_flat(pp, msg, pretty_exists) + if !isnothing(flat1041) + write(pp, flat1041) return nothing else _dollar_dollar = msg - _t1665 = deconstruct_bindings(pp, _dollar_dollar.body) - fields1027 = (_t1665, _dollar_dollar.body.value,) - unwrapped_fields1028 = fields1027 + _t1685 = deconstruct_bindings(pp, _dollar_dollar.body) + fields1037 = (_t1685, _dollar_dollar.body.value,) + unwrapped_fields1038 = fields1037 write(pp, "(exists") indent_sexp!(pp) newline(pp) - field1029 = unwrapped_fields1028[1] - pretty_bindings(pp, field1029) + field1039 = unwrapped_fields1038[1] + pretty_bindings(pp, field1039) newline(pp) - field1030 = unwrapped_fields1028[2] - pretty_formula(pp, field1030) + field1040 = unwrapped_fields1038[2] + pretty_formula(pp, field1040) dedent!(pp) write(pp, ")") end @@ -1941,25 +1941,25 @@ function pretty_exists(pp::PrettyPrinter, msg::Proto.Exists) end function pretty_reduce(pp::PrettyPrinter, msg::Proto.Reduce) - flat1037 = try_flat(pp, msg, pretty_reduce) - if !isnothing(flat1037) - write(pp, flat1037) + flat1047 = try_flat(pp, msg, pretty_reduce) + if !isnothing(flat1047) + write(pp, flat1047) return nothing else _dollar_dollar = msg - fields1032 = (_dollar_dollar.op, _dollar_dollar.body, _dollar_dollar.terms,) - unwrapped_fields1033 = fields1032 + fields1042 = (_dollar_dollar.op, _dollar_dollar.body, _dollar_dollar.terms,) + unwrapped_fields1043 = fields1042 write(pp, "(reduce") indent_sexp!(pp) newline(pp) - field1034 = unwrapped_fields1033[1] - pretty_abstraction(pp, field1034) + field1044 = unwrapped_fields1043[1] + pretty_abstraction(pp, field1044) newline(pp) - field1035 = unwrapped_fields1033[2] - pretty_abstraction(pp, field1035) + field1045 = unwrapped_fields1043[2] + pretty_abstraction(pp, field1045) newline(pp) - field1036 = unwrapped_fields1033[3] - pretty_terms(pp, field1036) + field1046 = unwrapped_fields1043[3] + pretty_terms(pp, field1046) dedent!(pp) write(pp, ")") end @@ -1967,22 +1967,22 @@ function pretty_reduce(pp::PrettyPrinter, msg::Proto.Reduce) end function pretty_terms(pp::PrettyPrinter, msg::Vector{Proto.Term}) - flat1041 = try_flat(pp, msg, pretty_terms) - if !isnothing(flat1041) - write(pp, flat1041) + flat1051 = try_flat(pp, msg, pretty_terms) + if !isnothing(flat1051) + write(pp, flat1051) return nothing else - fields1038 = msg + fields1048 = msg write(pp, "(terms") indent_sexp!(pp) - if !isempty(fields1038) + if !isempty(fields1048) newline(pp) - for (i1666, elem1039) in enumerate(fields1038) - i1040 = i1666 - 1 - if (i1040 > 0) + for (i1686, elem1049) in enumerate(fields1048) + i1050 = i1686 - 1 + if (i1050 > 0) newline(pp) end - pretty_term(pp, elem1039) + pretty_term(pp, elem1049) end end dedent!(pp) @@ -1992,32 +1992,32 @@ function pretty_terms(pp::PrettyPrinter, msg::Vector{Proto.Term}) end function pretty_term(pp::PrettyPrinter, msg::Proto.Term) - flat1046 = try_flat(pp, msg, pretty_term) - if !isnothing(flat1046) - write(pp, flat1046) + flat1056 = try_flat(pp, msg, pretty_term) + if !isnothing(flat1056) + write(pp, flat1056) return nothing else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("var")) - _t1667 = _get_oneof_field(_dollar_dollar, :var) + _t1687 = _get_oneof_field(_dollar_dollar, :var) else - _t1667 = nothing + _t1687 = nothing end - deconstruct_result1044 = _t1667 - if !isnothing(deconstruct_result1044) - unwrapped1045 = deconstruct_result1044 - pretty_var(pp, unwrapped1045) + deconstruct_result1054 = _t1687 + if !isnothing(deconstruct_result1054) + unwrapped1055 = deconstruct_result1054 + pretty_var(pp, unwrapped1055) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("constant")) - _t1668 = _get_oneof_field(_dollar_dollar, :constant) + _t1688 = _get_oneof_field(_dollar_dollar, :constant) else - _t1668 = nothing + _t1688 = nothing end - deconstruct_result1042 = _t1668 - if !isnothing(deconstruct_result1042) - unwrapped1043 = deconstruct_result1042 - pretty_value(pp, unwrapped1043) + deconstruct_result1052 = _t1688 + if !isnothing(deconstruct_result1052) + unwrapped1053 = deconstruct_result1052 + pretty_value(pp, unwrapped1053) else throw(ParseError("No matching rule for term")) end @@ -2027,158 +2027,158 @@ function pretty_term(pp::PrettyPrinter, msg::Proto.Term) end function pretty_var(pp::PrettyPrinter, msg::Proto.Var) - flat1049 = try_flat(pp, msg, pretty_var) - if !isnothing(flat1049) - write(pp, flat1049) + flat1059 = try_flat(pp, msg, pretty_var) + if !isnothing(flat1059) + write(pp, flat1059) return nothing else _dollar_dollar = msg - fields1047 = _dollar_dollar.name - unwrapped_fields1048 = fields1047 - write(pp, unwrapped_fields1048) + fields1057 = _dollar_dollar.name + unwrapped_fields1058 = fields1057 + write(pp, unwrapped_fields1058) end return nothing end function pretty_value(pp::PrettyPrinter, msg::Proto.Value) - flat1075 = try_flat(pp, msg, pretty_value) - if !isnothing(flat1075) - write(pp, flat1075) + flat1085 = try_flat(pp, msg, pretty_value) + if !isnothing(flat1085) + write(pp, flat1085) return nothing else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("date_value")) - _t1669 = _get_oneof_field(_dollar_dollar, :date_value) + _t1689 = _get_oneof_field(_dollar_dollar, :date_value) else - _t1669 = nothing + _t1689 = nothing end - deconstruct_result1073 = _t1669 - if !isnothing(deconstruct_result1073) - unwrapped1074 = deconstruct_result1073 - pretty_date(pp, unwrapped1074) + deconstruct_result1083 = _t1689 + if !isnothing(deconstruct_result1083) + unwrapped1084 = deconstruct_result1083 + pretty_date(pp, unwrapped1084) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("datetime_value")) - _t1670 = _get_oneof_field(_dollar_dollar, :datetime_value) + _t1690 = _get_oneof_field(_dollar_dollar, :datetime_value) else - _t1670 = nothing + _t1690 = nothing end - deconstruct_result1071 = _t1670 - if !isnothing(deconstruct_result1071) - unwrapped1072 = deconstruct_result1071 - pretty_datetime(pp, unwrapped1072) + deconstruct_result1081 = _t1690 + if !isnothing(deconstruct_result1081) + unwrapped1082 = deconstruct_result1081 + pretty_datetime(pp, unwrapped1082) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("string_value")) - _t1671 = _get_oneof_field(_dollar_dollar, :string_value) + _t1691 = _get_oneof_field(_dollar_dollar, :string_value) else - _t1671 = nothing + _t1691 = nothing end - deconstruct_result1069 = _t1671 - if !isnothing(deconstruct_result1069) - unwrapped1070 = deconstruct_result1069 - write(pp, format_string(pp, unwrapped1070)) + deconstruct_result1079 = _t1691 + if !isnothing(deconstruct_result1079) + unwrapped1080 = deconstruct_result1079 + write(pp, format_string(pp, unwrapped1080)) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("int32_value")) - _t1672 = _get_oneof_field(_dollar_dollar, :int32_value) + _t1692 = _get_oneof_field(_dollar_dollar, :int32_value) else - _t1672 = nothing + _t1692 = nothing end - deconstruct_result1067 = _t1672 - if !isnothing(deconstruct_result1067) - unwrapped1068 = deconstruct_result1067 - write(pp, format_int32(pp, unwrapped1068)) + deconstruct_result1077 = _t1692 + if !isnothing(deconstruct_result1077) + unwrapped1078 = deconstruct_result1077 + write(pp, format_int32(pp, unwrapped1078)) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("int_value")) - _t1673 = _get_oneof_field(_dollar_dollar, :int_value) + _t1693 = _get_oneof_field(_dollar_dollar, :int_value) else - _t1673 = nothing + _t1693 = nothing end - deconstruct_result1065 = _t1673 - if !isnothing(deconstruct_result1065) - unwrapped1066 = deconstruct_result1065 - write(pp, format_int(pp, unwrapped1066)) + deconstruct_result1075 = _t1693 + if !isnothing(deconstruct_result1075) + unwrapped1076 = deconstruct_result1075 + write(pp, format_int(pp, unwrapped1076)) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("float32_value")) - _t1674 = _get_oneof_field(_dollar_dollar, :float32_value) + _t1694 = _get_oneof_field(_dollar_dollar, :float32_value) else - _t1674 = nothing + _t1694 = nothing end - deconstruct_result1063 = _t1674 - if !isnothing(deconstruct_result1063) - unwrapped1064 = deconstruct_result1063 - write(pp, format_float32(pp, unwrapped1064)) + deconstruct_result1073 = _t1694 + if !isnothing(deconstruct_result1073) + unwrapped1074 = deconstruct_result1073 + write(pp, format_float32(pp, unwrapped1074)) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("float_value")) - _t1675 = _get_oneof_field(_dollar_dollar, :float_value) + _t1695 = _get_oneof_field(_dollar_dollar, :float_value) else - _t1675 = nothing + _t1695 = nothing end - deconstruct_result1061 = _t1675 - if !isnothing(deconstruct_result1061) - unwrapped1062 = deconstruct_result1061 - write(pp, format_float(pp, unwrapped1062)) + deconstruct_result1071 = _t1695 + if !isnothing(deconstruct_result1071) + unwrapped1072 = deconstruct_result1071 + write(pp, format_float(pp, unwrapped1072)) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("uint32_value")) - _t1676 = _get_oneof_field(_dollar_dollar, :uint32_value) + _t1696 = _get_oneof_field(_dollar_dollar, :uint32_value) else - _t1676 = nothing + _t1696 = nothing end - deconstruct_result1059 = _t1676 - if !isnothing(deconstruct_result1059) - unwrapped1060 = deconstruct_result1059 - write(pp, format_uint32(pp, unwrapped1060)) + deconstruct_result1069 = _t1696 + if !isnothing(deconstruct_result1069) + unwrapped1070 = deconstruct_result1069 + write(pp, format_uint32(pp, unwrapped1070)) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("uint128_value")) - _t1677 = _get_oneof_field(_dollar_dollar, :uint128_value) + _t1697 = _get_oneof_field(_dollar_dollar, :uint128_value) else - _t1677 = nothing + _t1697 = nothing end - deconstruct_result1057 = _t1677 - if !isnothing(deconstruct_result1057) - unwrapped1058 = deconstruct_result1057 - write(pp, format_uint128(pp, unwrapped1058)) + deconstruct_result1067 = _t1697 + if !isnothing(deconstruct_result1067) + unwrapped1068 = deconstruct_result1067 + write(pp, format_uint128(pp, unwrapped1068)) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("int128_value")) - _t1678 = _get_oneof_field(_dollar_dollar, :int128_value) + _t1698 = _get_oneof_field(_dollar_dollar, :int128_value) else - _t1678 = nothing + _t1698 = nothing end - deconstruct_result1055 = _t1678 - if !isnothing(deconstruct_result1055) - unwrapped1056 = deconstruct_result1055 - write(pp, format_int128(pp, unwrapped1056)) + deconstruct_result1065 = _t1698 + if !isnothing(deconstruct_result1065) + unwrapped1066 = deconstruct_result1065 + write(pp, format_int128(pp, unwrapped1066)) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("decimal_value")) - _t1679 = _get_oneof_field(_dollar_dollar, :decimal_value) + _t1699 = _get_oneof_field(_dollar_dollar, :decimal_value) else - _t1679 = nothing + _t1699 = nothing end - deconstruct_result1053 = _t1679 - if !isnothing(deconstruct_result1053) - unwrapped1054 = deconstruct_result1053 - write(pp, format_decimal(pp, unwrapped1054)) + deconstruct_result1063 = _t1699 + if !isnothing(deconstruct_result1063) + unwrapped1064 = deconstruct_result1063 + write(pp, format_decimal(pp, unwrapped1064)) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("boolean_value")) - _t1680 = _get_oneof_field(_dollar_dollar, :boolean_value) + _t1700 = _get_oneof_field(_dollar_dollar, :boolean_value) else - _t1680 = nothing + _t1700 = nothing end - deconstruct_result1051 = _t1680 - if !isnothing(deconstruct_result1051) - unwrapped1052 = deconstruct_result1051 - pretty_boolean_value(pp, unwrapped1052) + deconstruct_result1061 = _t1700 + if !isnothing(deconstruct_result1061) + unwrapped1062 = deconstruct_result1061 + pretty_boolean_value(pp, unwrapped1062) else - fields1050 = msg + fields1060 = msg write(pp, "missing") end end @@ -2197,25 +2197,25 @@ function pretty_value(pp::PrettyPrinter, msg::Proto.Value) end function pretty_date(pp::PrettyPrinter, msg::Proto.DateValue) - flat1081 = try_flat(pp, msg, pretty_date) - if !isnothing(flat1081) - write(pp, flat1081) + flat1091 = try_flat(pp, msg, pretty_date) + if !isnothing(flat1091) + write(pp, flat1091) return nothing else _dollar_dollar = msg - fields1076 = (Int64(_dollar_dollar.year), Int64(_dollar_dollar.month), Int64(_dollar_dollar.day),) - unwrapped_fields1077 = fields1076 + fields1086 = (Int64(_dollar_dollar.year), Int64(_dollar_dollar.month), Int64(_dollar_dollar.day),) + unwrapped_fields1087 = fields1086 write(pp, "(date") indent_sexp!(pp) newline(pp) - field1078 = unwrapped_fields1077[1] - write(pp, format_int(pp, field1078)) + field1088 = unwrapped_fields1087[1] + write(pp, format_int(pp, field1088)) newline(pp) - field1079 = unwrapped_fields1077[2] - write(pp, format_int(pp, field1079)) + field1089 = unwrapped_fields1087[2] + write(pp, format_int(pp, field1089)) newline(pp) - field1080 = unwrapped_fields1077[3] - write(pp, format_int(pp, field1080)) + field1090 = unwrapped_fields1087[3] + write(pp, format_int(pp, field1090)) dedent!(pp) write(pp, ")") end @@ -2223,39 +2223,39 @@ function pretty_date(pp::PrettyPrinter, msg::Proto.DateValue) end function pretty_datetime(pp::PrettyPrinter, msg::Proto.DateTimeValue) - flat1092 = try_flat(pp, msg, pretty_datetime) - if !isnothing(flat1092) - write(pp, flat1092) + flat1102 = try_flat(pp, msg, pretty_datetime) + if !isnothing(flat1102) + write(pp, flat1102) return nothing else _dollar_dollar = msg - fields1082 = (Int64(_dollar_dollar.year), Int64(_dollar_dollar.month), Int64(_dollar_dollar.day), Int64(_dollar_dollar.hour), Int64(_dollar_dollar.minute), Int64(_dollar_dollar.second), Int64(_dollar_dollar.microsecond),) - unwrapped_fields1083 = fields1082 + fields1092 = (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_fields1093 = fields1092 write(pp, "(datetime") indent_sexp!(pp) newline(pp) - field1084 = unwrapped_fields1083[1] - write(pp, format_int(pp, field1084)) + field1094 = unwrapped_fields1093[1] + write(pp, format_int(pp, field1094)) newline(pp) - field1085 = unwrapped_fields1083[2] - write(pp, format_int(pp, field1085)) + field1095 = unwrapped_fields1093[2] + write(pp, format_int(pp, field1095)) newline(pp) - field1086 = unwrapped_fields1083[3] - write(pp, format_int(pp, field1086)) + field1096 = unwrapped_fields1093[3] + write(pp, format_int(pp, field1096)) newline(pp) - field1087 = unwrapped_fields1083[4] - write(pp, format_int(pp, field1087)) + field1097 = unwrapped_fields1093[4] + write(pp, format_int(pp, field1097)) newline(pp) - field1088 = unwrapped_fields1083[5] - write(pp, format_int(pp, field1088)) + field1098 = unwrapped_fields1093[5] + write(pp, format_int(pp, field1098)) newline(pp) - field1089 = unwrapped_fields1083[6] - write(pp, format_int(pp, field1089)) - field1090 = unwrapped_fields1083[7] - if !isnothing(field1090) + field1099 = unwrapped_fields1093[6] + write(pp, format_int(pp, field1099)) + field1100 = unwrapped_fields1093[7] + if !isnothing(field1100) newline(pp) - opt_val1091 = field1090 - write(pp, format_int(pp, opt_val1091)) + opt_val1101 = field1100 + write(pp, format_int(pp, opt_val1101)) end dedent!(pp) write(pp, ")") @@ -2264,24 +2264,24 @@ function pretty_datetime(pp::PrettyPrinter, msg::Proto.DateTimeValue) end function pretty_conjunction(pp::PrettyPrinter, msg::Proto.Conjunction) - flat1097 = try_flat(pp, msg, pretty_conjunction) - if !isnothing(flat1097) - write(pp, flat1097) + flat1107 = try_flat(pp, msg, pretty_conjunction) + if !isnothing(flat1107) + write(pp, flat1107) return nothing else _dollar_dollar = msg - fields1093 = _dollar_dollar.args - unwrapped_fields1094 = fields1093 + fields1103 = _dollar_dollar.args + unwrapped_fields1104 = fields1103 write(pp, "(and") indent_sexp!(pp) - if !isempty(unwrapped_fields1094) + if !isempty(unwrapped_fields1104) newline(pp) - for (i1681, elem1095) in enumerate(unwrapped_fields1094) - i1096 = i1681 - 1 - if (i1096 > 0) + for (i1701, elem1105) in enumerate(unwrapped_fields1104) + i1106 = i1701 - 1 + if (i1106 > 0) newline(pp) end - pretty_formula(pp, elem1095) + pretty_formula(pp, elem1105) end end dedent!(pp) @@ -2291,24 +2291,24 @@ function pretty_conjunction(pp::PrettyPrinter, msg::Proto.Conjunction) end function pretty_disjunction(pp::PrettyPrinter, msg::Proto.Disjunction) - flat1102 = try_flat(pp, msg, pretty_disjunction) - if !isnothing(flat1102) - write(pp, flat1102) + flat1112 = try_flat(pp, msg, pretty_disjunction) + if !isnothing(flat1112) + write(pp, flat1112) return nothing else _dollar_dollar = msg - fields1098 = _dollar_dollar.args - unwrapped_fields1099 = fields1098 + fields1108 = _dollar_dollar.args + unwrapped_fields1109 = fields1108 write(pp, "(or") indent_sexp!(pp) - if !isempty(unwrapped_fields1099) + if !isempty(unwrapped_fields1109) newline(pp) - for (i1682, elem1100) in enumerate(unwrapped_fields1099) - i1101 = i1682 - 1 - if (i1101 > 0) + for (i1702, elem1110) in enumerate(unwrapped_fields1109) + i1111 = i1702 - 1 + if (i1111 > 0) newline(pp) end - pretty_formula(pp, elem1100) + pretty_formula(pp, elem1110) end end dedent!(pp) @@ -2318,18 +2318,18 @@ function pretty_disjunction(pp::PrettyPrinter, msg::Proto.Disjunction) end function pretty_not(pp::PrettyPrinter, msg::Proto.Not) - flat1105 = try_flat(pp, msg, pretty_not) - if !isnothing(flat1105) - write(pp, flat1105) + flat1115 = try_flat(pp, msg, pretty_not) + if !isnothing(flat1115) + write(pp, flat1115) return nothing else _dollar_dollar = msg - fields1103 = _dollar_dollar.arg - unwrapped_fields1104 = fields1103 + fields1113 = _dollar_dollar.arg + unwrapped_fields1114 = fields1113 write(pp, "(not") indent_sexp!(pp) newline(pp) - pretty_formula(pp, unwrapped_fields1104) + pretty_formula(pp, unwrapped_fields1114) dedent!(pp) write(pp, ")") end @@ -2337,25 +2337,25 @@ function pretty_not(pp::PrettyPrinter, msg::Proto.Not) end function pretty_ffi(pp::PrettyPrinter, msg::Proto.FFI) - flat1111 = try_flat(pp, msg, pretty_ffi) - if !isnothing(flat1111) - write(pp, flat1111) + flat1121 = try_flat(pp, msg, pretty_ffi) + if !isnothing(flat1121) + write(pp, flat1121) return nothing else _dollar_dollar = msg - fields1106 = (_dollar_dollar.name, _dollar_dollar.args, _dollar_dollar.terms,) - unwrapped_fields1107 = fields1106 + fields1116 = (_dollar_dollar.name, _dollar_dollar.args, _dollar_dollar.terms,) + unwrapped_fields1117 = fields1116 write(pp, "(ffi") indent_sexp!(pp) newline(pp) - field1108 = unwrapped_fields1107[1] - pretty_name(pp, field1108) + field1118 = unwrapped_fields1117[1] + pretty_name(pp, field1118) newline(pp) - field1109 = unwrapped_fields1107[2] - pretty_ffi_args(pp, field1109) + field1119 = unwrapped_fields1117[2] + pretty_ffi_args(pp, field1119) newline(pp) - field1110 = unwrapped_fields1107[3] - pretty_terms(pp, field1110) + field1120 = unwrapped_fields1117[3] + pretty_terms(pp, field1120) dedent!(pp) write(pp, ")") end @@ -2363,35 +2363,35 @@ function pretty_ffi(pp::PrettyPrinter, msg::Proto.FFI) end function pretty_name(pp::PrettyPrinter, msg::String) - flat1113 = try_flat(pp, msg, pretty_name) - if !isnothing(flat1113) - write(pp, flat1113) + flat1123 = try_flat(pp, msg, pretty_name) + if !isnothing(flat1123) + write(pp, flat1123) return nothing else - fields1112 = msg + fields1122 = msg write(pp, ":") - write(pp, fields1112) + write(pp, fields1122) end return nothing end function pretty_ffi_args(pp::PrettyPrinter, msg::Vector{Proto.Abstraction}) - flat1117 = try_flat(pp, msg, pretty_ffi_args) - if !isnothing(flat1117) - write(pp, flat1117) + flat1127 = try_flat(pp, msg, pretty_ffi_args) + if !isnothing(flat1127) + write(pp, flat1127) return nothing else - fields1114 = msg + fields1124 = msg write(pp, "(args") indent_sexp!(pp) - if !isempty(fields1114) + if !isempty(fields1124) newline(pp) - for (i1683, elem1115) in enumerate(fields1114) - i1116 = i1683 - 1 - if (i1116 > 0) + for (i1703, elem1125) in enumerate(fields1124) + i1126 = i1703 - 1 + if (i1126 > 0) newline(pp) end - pretty_abstraction(pp, elem1115) + pretty_abstraction(pp, elem1125) end end dedent!(pp) @@ -2401,28 +2401,28 @@ function pretty_ffi_args(pp::PrettyPrinter, msg::Vector{Proto.Abstraction}) end function pretty_atom(pp::PrettyPrinter, msg::Proto.Atom) - flat1124 = try_flat(pp, msg, pretty_atom) - if !isnothing(flat1124) - write(pp, flat1124) + flat1134 = try_flat(pp, msg, pretty_atom) + if !isnothing(flat1134) + write(pp, flat1134) return nothing else _dollar_dollar = msg - fields1118 = (_dollar_dollar.name, _dollar_dollar.terms,) - unwrapped_fields1119 = fields1118 + fields1128 = (_dollar_dollar.name, _dollar_dollar.terms,) + unwrapped_fields1129 = fields1128 write(pp, "(atom") indent_sexp!(pp) newline(pp) - field1120 = unwrapped_fields1119[1] - pretty_relation_id(pp, field1120) - field1121 = unwrapped_fields1119[2] - if !isempty(field1121) + field1130 = unwrapped_fields1129[1] + pretty_relation_id(pp, field1130) + field1131 = unwrapped_fields1129[2] + if !isempty(field1131) newline(pp) - for (i1684, elem1122) in enumerate(field1121) - i1123 = i1684 - 1 - if (i1123 > 0) + for (i1704, elem1132) in enumerate(field1131) + i1133 = i1704 - 1 + if (i1133 > 0) newline(pp) end - pretty_term(pp, elem1122) + pretty_term(pp, elem1132) end end dedent!(pp) @@ -2432,28 +2432,28 @@ function pretty_atom(pp::PrettyPrinter, msg::Proto.Atom) end function pretty_pragma(pp::PrettyPrinter, msg::Proto.Pragma) - flat1131 = try_flat(pp, msg, pretty_pragma) - if !isnothing(flat1131) - write(pp, flat1131) + flat1141 = try_flat(pp, msg, pretty_pragma) + if !isnothing(flat1141) + write(pp, flat1141) return nothing else _dollar_dollar = msg - fields1125 = (_dollar_dollar.name, _dollar_dollar.terms,) - unwrapped_fields1126 = fields1125 + fields1135 = (_dollar_dollar.name, _dollar_dollar.terms,) + unwrapped_fields1136 = fields1135 write(pp, "(pragma") indent_sexp!(pp) newline(pp) - field1127 = unwrapped_fields1126[1] - pretty_name(pp, field1127) - field1128 = unwrapped_fields1126[2] - if !isempty(field1128) + field1137 = unwrapped_fields1136[1] + pretty_name(pp, field1137) + field1138 = unwrapped_fields1136[2] + if !isempty(field1138) newline(pp) - for (i1685, elem1129) in enumerate(field1128) - i1130 = i1685 - 1 - if (i1130 > 0) + for (i1705, elem1139) in enumerate(field1138) + i1140 = i1705 - 1 + if (i1140 > 0) newline(pp) end - pretty_term(pp, elem1129) + pretty_term(pp, elem1139) end end dedent!(pp) @@ -2463,118 +2463,118 @@ function pretty_pragma(pp::PrettyPrinter, msg::Proto.Pragma) end function pretty_primitive(pp::PrettyPrinter, msg::Proto.Primitive) - flat1147 = try_flat(pp, msg, pretty_primitive) - if !isnothing(flat1147) - write(pp, flat1147) + flat1157 = try_flat(pp, msg, pretty_primitive) + if !isnothing(flat1157) + write(pp, flat1157) return nothing else _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_eq" - _t1686 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) + _t1706 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) else - _t1686 = nothing + _t1706 = nothing end - guard_result1146 = _t1686 - if !isnothing(guard_result1146) + guard_result1156 = _t1706 + if !isnothing(guard_result1156) pretty_eq(pp, msg) else _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_lt_monotype" - _t1687 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) + _t1707 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) else - _t1687 = nothing + _t1707 = nothing end - guard_result1145 = _t1687 - if !isnothing(guard_result1145) + guard_result1155 = _t1707 + if !isnothing(guard_result1155) pretty_lt(pp, msg) else _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_lt_eq_monotype" - _t1688 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) + _t1708 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) else - _t1688 = nothing + _t1708 = nothing end - guard_result1144 = _t1688 - if !isnothing(guard_result1144) + guard_result1154 = _t1708 + if !isnothing(guard_result1154) pretty_lt_eq(pp, msg) else _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_gt_monotype" - _t1689 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) + _t1709 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) else - _t1689 = nothing + _t1709 = nothing end - guard_result1143 = _t1689 - if !isnothing(guard_result1143) + guard_result1153 = _t1709 + if !isnothing(guard_result1153) pretty_gt(pp, msg) else _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_gt_eq_monotype" - _t1690 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) + _t1710 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) else - _t1690 = nothing + _t1710 = nothing end - guard_result1142 = _t1690 - if !isnothing(guard_result1142) + guard_result1152 = _t1710 + if !isnothing(guard_result1152) pretty_gt_eq(pp, msg) else _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_add_monotype" - _t1691 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term), _get_oneof_field(_dollar_dollar.terms[3], :term),) + _t1711 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term), _get_oneof_field(_dollar_dollar.terms[3], :term),) else - _t1691 = nothing + _t1711 = nothing end - guard_result1141 = _t1691 - if !isnothing(guard_result1141) + guard_result1151 = _t1711 + if !isnothing(guard_result1151) pretty_add(pp, msg) else _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_subtract_monotype" - _t1692 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term), _get_oneof_field(_dollar_dollar.terms[3], :term),) + _t1712 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term), _get_oneof_field(_dollar_dollar.terms[3], :term),) else - _t1692 = nothing + _t1712 = nothing end - guard_result1140 = _t1692 - if !isnothing(guard_result1140) + guard_result1150 = _t1712 + if !isnothing(guard_result1150) pretty_minus(pp, msg) else _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_multiply_monotype" - _t1693 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term), _get_oneof_field(_dollar_dollar.terms[3], :term),) + _t1713 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term), _get_oneof_field(_dollar_dollar.terms[3], :term),) else - _t1693 = nothing + _t1713 = nothing end - guard_result1139 = _t1693 - if !isnothing(guard_result1139) + guard_result1149 = _t1713 + if !isnothing(guard_result1149) pretty_multiply(pp, msg) else _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_divide_monotype" - _t1694 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term), _get_oneof_field(_dollar_dollar.terms[3], :term),) + _t1714 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term), _get_oneof_field(_dollar_dollar.terms[3], :term),) else - _t1694 = nothing + _t1714 = nothing end - guard_result1138 = _t1694 - if !isnothing(guard_result1138) + guard_result1148 = _t1714 + if !isnothing(guard_result1148) pretty_divide(pp, msg) else _dollar_dollar = msg - fields1132 = (_dollar_dollar.name, _dollar_dollar.terms,) - unwrapped_fields1133 = fields1132 + fields1142 = (_dollar_dollar.name, _dollar_dollar.terms,) + unwrapped_fields1143 = fields1142 write(pp, "(primitive") indent_sexp!(pp) newline(pp) - field1134 = unwrapped_fields1133[1] - pretty_name(pp, field1134) - field1135 = unwrapped_fields1133[2] - if !isempty(field1135) + field1144 = unwrapped_fields1143[1] + pretty_name(pp, field1144) + field1145 = unwrapped_fields1143[2] + if !isempty(field1145) newline(pp) - for (i1695, elem1136) in enumerate(field1135) - i1137 = i1695 - 1 - if (i1137 > 0) + for (i1715, elem1146) in enumerate(field1145) + i1147 = i1715 - 1 + if (i1147 > 0) newline(pp) end - pretty_rel_term(pp, elem1136) + pretty_rel_term(pp, elem1146) end end dedent!(pp) @@ -2593,27 +2593,27 @@ function pretty_primitive(pp::PrettyPrinter, msg::Proto.Primitive) end function pretty_eq(pp::PrettyPrinter, msg::Proto.Primitive) - flat1152 = try_flat(pp, msg, pretty_eq) - if !isnothing(flat1152) - write(pp, flat1152) + flat1162 = try_flat(pp, msg, pretty_eq) + if !isnothing(flat1162) + write(pp, flat1162) return nothing else _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_eq" - _t1696 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) + _t1716 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) else - _t1696 = nothing + _t1716 = nothing end - fields1148 = _t1696 - unwrapped_fields1149 = fields1148 + fields1158 = _t1716 + unwrapped_fields1159 = fields1158 write(pp, "(=") indent_sexp!(pp) newline(pp) - field1150 = unwrapped_fields1149[1] - pretty_term(pp, field1150) + field1160 = unwrapped_fields1159[1] + pretty_term(pp, field1160) newline(pp) - field1151 = unwrapped_fields1149[2] - pretty_term(pp, field1151) + field1161 = unwrapped_fields1159[2] + pretty_term(pp, field1161) dedent!(pp) write(pp, ")") end @@ -2621,27 +2621,27 @@ function pretty_eq(pp::PrettyPrinter, msg::Proto.Primitive) end function pretty_lt(pp::PrettyPrinter, msg::Proto.Primitive) - flat1157 = try_flat(pp, msg, pretty_lt) - if !isnothing(flat1157) - write(pp, flat1157) + flat1167 = try_flat(pp, msg, pretty_lt) + if !isnothing(flat1167) + write(pp, flat1167) return nothing else _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_lt_monotype" - _t1697 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) + _t1717 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) else - _t1697 = nothing + _t1717 = nothing end - fields1153 = _t1697 - unwrapped_fields1154 = fields1153 + fields1163 = _t1717 + unwrapped_fields1164 = fields1163 write(pp, "(<") indent_sexp!(pp) newline(pp) - field1155 = unwrapped_fields1154[1] - pretty_term(pp, field1155) + field1165 = unwrapped_fields1164[1] + pretty_term(pp, field1165) newline(pp) - field1156 = unwrapped_fields1154[2] - pretty_term(pp, field1156) + field1166 = unwrapped_fields1164[2] + pretty_term(pp, field1166) dedent!(pp) write(pp, ")") end @@ -2649,27 +2649,27 @@ function pretty_lt(pp::PrettyPrinter, msg::Proto.Primitive) end function pretty_lt_eq(pp::PrettyPrinter, msg::Proto.Primitive) - flat1162 = try_flat(pp, msg, pretty_lt_eq) - if !isnothing(flat1162) - write(pp, flat1162) + flat1172 = try_flat(pp, msg, pretty_lt_eq) + if !isnothing(flat1172) + write(pp, flat1172) return nothing else _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_lt_eq_monotype" - _t1698 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) + _t1718 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) else - _t1698 = nothing + _t1718 = nothing end - fields1158 = _t1698 - unwrapped_fields1159 = fields1158 + fields1168 = _t1718 + unwrapped_fields1169 = fields1168 write(pp, "(<=") indent_sexp!(pp) newline(pp) - field1160 = unwrapped_fields1159[1] - pretty_term(pp, field1160) + field1170 = unwrapped_fields1169[1] + pretty_term(pp, field1170) newline(pp) - field1161 = unwrapped_fields1159[2] - pretty_term(pp, field1161) + field1171 = unwrapped_fields1169[2] + pretty_term(pp, field1171) dedent!(pp) write(pp, ")") end @@ -2677,27 +2677,27 @@ function pretty_lt_eq(pp::PrettyPrinter, msg::Proto.Primitive) end function pretty_gt(pp::PrettyPrinter, msg::Proto.Primitive) - flat1167 = try_flat(pp, msg, pretty_gt) - if !isnothing(flat1167) - write(pp, flat1167) + flat1177 = try_flat(pp, msg, pretty_gt) + if !isnothing(flat1177) + write(pp, flat1177) return nothing else _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_gt_monotype" - _t1699 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) + _t1719 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) else - _t1699 = nothing + _t1719 = nothing end - fields1163 = _t1699 - unwrapped_fields1164 = fields1163 + fields1173 = _t1719 + unwrapped_fields1174 = fields1173 write(pp, "(>") indent_sexp!(pp) newline(pp) - field1165 = unwrapped_fields1164[1] - pretty_term(pp, field1165) + field1175 = unwrapped_fields1174[1] + pretty_term(pp, field1175) newline(pp) - field1166 = unwrapped_fields1164[2] - pretty_term(pp, field1166) + field1176 = unwrapped_fields1174[2] + pretty_term(pp, field1176) dedent!(pp) write(pp, ")") end @@ -2705,27 +2705,27 @@ function pretty_gt(pp::PrettyPrinter, msg::Proto.Primitive) end function pretty_gt_eq(pp::PrettyPrinter, msg::Proto.Primitive) - flat1172 = try_flat(pp, msg, pretty_gt_eq) - if !isnothing(flat1172) - write(pp, flat1172) + flat1182 = try_flat(pp, msg, pretty_gt_eq) + if !isnothing(flat1182) + write(pp, flat1182) return nothing else _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_gt_eq_monotype" - _t1700 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) + _t1720 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) else - _t1700 = nothing + _t1720 = nothing end - fields1168 = _t1700 - unwrapped_fields1169 = fields1168 + fields1178 = _t1720 + unwrapped_fields1179 = fields1178 write(pp, "(>=") indent_sexp!(pp) newline(pp) - field1170 = unwrapped_fields1169[1] - pretty_term(pp, field1170) + field1180 = unwrapped_fields1179[1] + pretty_term(pp, field1180) newline(pp) - field1171 = unwrapped_fields1169[2] - pretty_term(pp, field1171) + field1181 = unwrapped_fields1179[2] + pretty_term(pp, field1181) dedent!(pp) write(pp, ")") end @@ -2733,30 +2733,30 @@ function pretty_gt_eq(pp::PrettyPrinter, msg::Proto.Primitive) end function pretty_add(pp::PrettyPrinter, msg::Proto.Primitive) - flat1178 = try_flat(pp, msg, pretty_add) - if !isnothing(flat1178) - write(pp, flat1178) + flat1188 = try_flat(pp, msg, pretty_add) + if !isnothing(flat1188) + write(pp, flat1188) return nothing else _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_add_monotype" - _t1701 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term), _get_oneof_field(_dollar_dollar.terms[3], :term),) + _t1721 = (_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 - _t1701 = nothing + _t1721 = nothing end - fields1173 = _t1701 - unwrapped_fields1174 = fields1173 + fields1183 = _t1721 + unwrapped_fields1184 = fields1183 write(pp, "(+") indent_sexp!(pp) newline(pp) - field1175 = unwrapped_fields1174[1] - pretty_term(pp, field1175) + field1185 = unwrapped_fields1184[1] + pretty_term(pp, field1185) newline(pp) - field1176 = unwrapped_fields1174[2] - pretty_term(pp, field1176) + field1186 = unwrapped_fields1184[2] + pretty_term(pp, field1186) newline(pp) - field1177 = unwrapped_fields1174[3] - pretty_term(pp, field1177) + field1187 = unwrapped_fields1184[3] + pretty_term(pp, field1187) dedent!(pp) write(pp, ")") end @@ -2764,30 +2764,30 @@ function pretty_add(pp::PrettyPrinter, msg::Proto.Primitive) end function pretty_minus(pp::PrettyPrinter, msg::Proto.Primitive) - flat1184 = try_flat(pp, msg, pretty_minus) - if !isnothing(flat1184) - write(pp, flat1184) + flat1194 = try_flat(pp, msg, pretty_minus) + if !isnothing(flat1194) + write(pp, flat1194) return nothing else _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_subtract_monotype" - _t1702 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term), _get_oneof_field(_dollar_dollar.terms[3], :term),) + _t1722 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term), _get_oneof_field(_dollar_dollar.terms[3], :term),) else - _t1702 = nothing + _t1722 = nothing end - fields1179 = _t1702 - unwrapped_fields1180 = fields1179 + fields1189 = _t1722 + unwrapped_fields1190 = fields1189 write(pp, "(-") indent_sexp!(pp) newline(pp) - field1181 = unwrapped_fields1180[1] - pretty_term(pp, field1181) + field1191 = unwrapped_fields1190[1] + pretty_term(pp, field1191) newline(pp) - field1182 = unwrapped_fields1180[2] - pretty_term(pp, field1182) + field1192 = unwrapped_fields1190[2] + pretty_term(pp, field1192) newline(pp) - field1183 = unwrapped_fields1180[3] - pretty_term(pp, field1183) + field1193 = unwrapped_fields1190[3] + pretty_term(pp, field1193) dedent!(pp) write(pp, ")") end @@ -2795,30 +2795,30 @@ function pretty_minus(pp::PrettyPrinter, msg::Proto.Primitive) end function pretty_multiply(pp::PrettyPrinter, msg::Proto.Primitive) - flat1190 = try_flat(pp, msg, pretty_multiply) - if !isnothing(flat1190) - write(pp, flat1190) + flat1200 = try_flat(pp, msg, pretty_multiply) + if !isnothing(flat1200) + write(pp, flat1200) return nothing else _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_multiply_monotype" - _t1703 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term), _get_oneof_field(_dollar_dollar.terms[3], :term),) + _t1723 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term), _get_oneof_field(_dollar_dollar.terms[3], :term),) else - _t1703 = nothing + _t1723 = nothing end - fields1185 = _t1703 - unwrapped_fields1186 = fields1185 + fields1195 = _t1723 + unwrapped_fields1196 = fields1195 write(pp, "(*") indent_sexp!(pp) newline(pp) - field1187 = unwrapped_fields1186[1] - pretty_term(pp, field1187) + field1197 = unwrapped_fields1196[1] + pretty_term(pp, field1197) newline(pp) - field1188 = unwrapped_fields1186[2] - pretty_term(pp, field1188) + field1198 = unwrapped_fields1196[2] + pretty_term(pp, field1198) newline(pp) - field1189 = unwrapped_fields1186[3] - pretty_term(pp, field1189) + field1199 = unwrapped_fields1196[3] + pretty_term(pp, field1199) dedent!(pp) write(pp, ")") end @@ -2826,30 +2826,30 @@ function pretty_multiply(pp::PrettyPrinter, msg::Proto.Primitive) end function pretty_divide(pp::PrettyPrinter, msg::Proto.Primitive) - flat1196 = try_flat(pp, msg, pretty_divide) - if !isnothing(flat1196) - write(pp, flat1196) + flat1206 = try_flat(pp, msg, pretty_divide) + if !isnothing(flat1206) + write(pp, flat1206) return nothing else _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_divide_monotype" - _t1704 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term), _get_oneof_field(_dollar_dollar.terms[3], :term),) + _t1724 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term), _get_oneof_field(_dollar_dollar.terms[3], :term),) else - _t1704 = nothing + _t1724 = nothing end - fields1191 = _t1704 - unwrapped_fields1192 = fields1191 + fields1201 = _t1724 + unwrapped_fields1202 = fields1201 write(pp, "(/") indent_sexp!(pp) newline(pp) - field1193 = unwrapped_fields1192[1] - pretty_term(pp, field1193) + field1203 = unwrapped_fields1202[1] + pretty_term(pp, field1203) newline(pp) - field1194 = unwrapped_fields1192[2] - pretty_term(pp, field1194) + field1204 = unwrapped_fields1202[2] + pretty_term(pp, field1204) newline(pp) - field1195 = unwrapped_fields1192[3] - pretty_term(pp, field1195) + field1205 = unwrapped_fields1202[3] + pretty_term(pp, field1205) dedent!(pp) write(pp, ")") end @@ -2857,32 +2857,32 @@ function pretty_divide(pp::PrettyPrinter, msg::Proto.Primitive) end function pretty_rel_term(pp::PrettyPrinter, msg::Proto.RelTerm) - flat1201 = try_flat(pp, msg, pretty_rel_term) - if !isnothing(flat1201) - write(pp, flat1201) + flat1211 = try_flat(pp, msg, pretty_rel_term) + if !isnothing(flat1211) + write(pp, flat1211) return nothing else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("specialized_value")) - _t1705 = _get_oneof_field(_dollar_dollar, :specialized_value) + _t1725 = _get_oneof_field(_dollar_dollar, :specialized_value) else - _t1705 = nothing + _t1725 = nothing end - deconstruct_result1199 = _t1705 - if !isnothing(deconstruct_result1199) - unwrapped1200 = deconstruct_result1199 - pretty_specialized_value(pp, unwrapped1200) + deconstruct_result1209 = _t1725 + if !isnothing(deconstruct_result1209) + unwrapped1210 = deconstruct_result1209 + pretty_specialized_value(pp, unwrapped1210) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("term")) - _t1706 = _get_oneof_field(_dollar_dollar, :term) + _t1726 = _get_oneof_field(_dollar_dollar, :term) else - _t1706 = nothing + _t1726 = nothing end - deconstruct_result1197 = _t1706 - if !isnothing(deconstruct_result1197) - unwrapped1198 = deconstruct_result1197 - pretty_term(pp, unwrapped1198) + deconstruct_result1207 = _t1726 + if !isnothing(deconstruct_result1207) + unwrapped1208 = deconstruct_result1207 + pretty_term(pp, unwrapped1208) else throw(ParseError("No matching rule for rel_term")) end @@ -2892,41 +2892,41 @@ function pretty_rel_term(pp::PrettyPrinter, msg::Proto.RelTerm) end function pretty_specialized_value(pp::PrettyPrinter, msg::Proto.Value) - flat1203 = try_flat(pp, msg, pretty_specialized_value) - if !isnothing(flat1203) - write(pp, flat1203) + flat1213 = try_flat(pp, msg, pretty_specialized_value) + if !isnothing(flat1213) + write(pp, flat1213) return nothing else - fields1202 = msg + fields1212 = msg write(pp, "#") - pretty_raw_value(pp, fields1202) + pretty_raw_value(pp, fields1212) end return nothing end function pretty_rel_atom(pp::PrettyPrinter, msg::Proto.RelAtom) - flat1210 = try_flat(pp, msg, pretty_rel_atom) - if !isnothing(flat1210) - write(pp, flat1210) + flat1220 = try_flat(pp, msg, pretty_rel_atom) + if !isnothing(flat1220) + write(pp, flat1220) return nothing else _dollar_dollar = msg - fields1204 = (_dollar_dollar.name, _dollar_dollar.terms,) - unwrapped_fields1205 = fields1204 + fields1214 = (_dollar_dollar.name, _dollar_dollar.terms,) + unwrapped_fields1215 = fields1214 write(pp, "(relatom") indent_sexp!(pp) newline(pp) - field1206 = unwrapped_fields1205[1] - pretty_name(pp, field1206) - field1207 = unwrapped_fields1205[2] - if !isempty(field1207) + field1216 = unwrapped_fields1215[1] + pretty_name(pp, field1216) + field1217 = unwrapped_fields1215[2] + if !isempty(field1217) newline(pp) - for (i1707, elem1208) in enumerate(field1207) - i1209 = i1707 - 1 - if (i1209 > 0) + for (i1727, elem1218) in enumerate(field1217) + i1219 = i1727 - 1 + if (i1219 > 0) newline(pp) end - pretty_rel_term(pp, elem1208) + pretty_rel_term(pp, elem1218) end end dedent!(pp) @@ -2936,22 +2936,22 @@ function pretty_rel_atom(pp::PrettyPrinter, msg::Proto.RelAtom) end function pretty_cast(pp::PrettyPrinter, msg::Proto.Cast) - flat1215 = try_flat(pp, msg, pretty_cast) - if !isnothing(flat1215) - write(pp, flat1215) + flat1225 = try_flat(pp, msg, pretty_cast) + if !isnothing(flat1225) + write(pp, flat1225) return nothing else _dollar_dollar = msg - fields1211 = (_dollar_dollar.input, _dollar_dollar.result,) - unwrapped_fields1212 = fields1211 + fields1221 = (_dollar_dollar.input, _dollar_dollar.result,) + unwrapped_fields1222 = fields1221 write(pp, "(cast") indent_sexp!(pp) newline(pp) - field1213 = unwrapped_fields1212[1] - pretty_term(pp, field1213) + field1223 = unwrapped_fields1222[1] + pretty_term(pp, field1223) newline(pp) - field1214 = unwrapped_fields1212[2] - pretty_term(pp, field1214) + field1224 = unwrapped_fields1222[2] + pretty_term(pp, field1224) dedent!(pp) write(pp, ")") end @@ -2959,22 +2959,22 @@ function pretty_cast(pp::PrettyPrinter, msg::Proto.Cast) end function pretty_attrs(pp::PrettyPrinter, msg::Vector{Proto.Attribute}) - flat1219 = try_flat(pp, msg, pretty_attrs) - if !isnothing(flat1219) - write(pp, flat1219) + flat1229 = try_flat(pp, msg, pretty_attrs) + if !isnothing(flat1229) + write(pp, flat1229) return nothing else - fields1216 = msg + fields1226 = msg write(pp, "(attrs") indent_sexp!(pp) - if !isempty(fields1216) + if !isempty(fields1226) newline(pp) - for (i1708, elem1217) in enumerate(fields1216) - i1218 = i1708 - 1 - if (i1218 > 0) + for (i1728, elem1227) in enumerate(fields1226) + i1228 = i1728 - 1 + if (i1228 > 0) newline(pp) end - pretty_attribute(pp, elem1217) + pretty_attribute(pp, elem1227) end end dedent!(pp) @@ -2984,28 +2984,28 @@ function pretty_attrs(pp::PrettyPrinter, msg::Vector{Proto.Attribute}) end function pretty_attribute(pp::PrettyPrinter, msg::Proto.Attribute) - flat1226 = try_flat(pp, msg, pretty_attribute) - if !isnothing(flat1226) - write(pp, flat1226) + flat1236 = try_flat(pp, msg, pretty_attribute) + if !isnothing(flat1236) + write(pp, flat1236) return nothing else _dollar_dollar = msg - fields1220 = (_dollar_dollar.name, _dollar_dollar.args,) - unwrapped_fields1221 = fields1220 + fields1230 = (_dollar_dollar.name, _dollar_dollar.args,) + unwrapped_fields1231 = fields1230 write(pp, "(attribute") indent_sexp!(pp) newline(pp) - field1222 = unwrapped_fields1221[1] - pretty_name(pp, field1222) - field1223 = unwrapped_fields1221[2] - if !isempty(field1223) + field1232 = unwrapped_fields1231[1] + pretty_name(pp, field1232) + field1233 = unwrapped_fields1231[2] + if !isempty(field1233) newline(pp) - for (i1709, elem1224) in enumerate(field1223) - i1225 = i1709 - 1 - if (i1225 > 0) + for (i1729, elem1234) in enumerate(field1233) + i1235 = i1729 - 1 + if (i1235 > 0) newline(pp) end - pretty_raw_value(pp, elem1224) + pretty_raw_value(pp, elem1234) end end dedent!(pp) @@ -3015,40 +3015,40 @@ function pretty_attribute(pp::PrettyPrinter, msg::Proto.Attribute) end function pretty_algorithm(pp::PrettyPrinter, msg::Proto.Algorithm) - flat1235 = try_flat(pp, msg, pretty_algorithm) - if !isnothing(flat1235) - write(pp, flat1235) + flat1245 = try_flat(pp, msg, pretty_algorithm) + if !isnothing(flat1245) + write(pp, flat1245) return nothing else _dollar_dollar = msg if !isempty(_dollar_dollar.attrs) - _t1710 = _dollar_dollar.attrs + _t1730 = _dollar_dollar.attrs else - _t1710 = nothing + _t1730 = nothing end - fields1227 = (_dollar_dollar.var"#global", _dollar_dollar.body, _t1710,) - unwrapped_fields1228 = fields1227 + fields1237 = (_dollar_dollar.var"#global", _dollar_dollar.body, _t1730,) + unwrapped_fields1238 = fields1237 write(pp, "(algorithm") indent_sexp!(pp) - field1229 = unwrapped_fields1228[1] - if !isempty(field1229) + field1239 = unwrapped_fields1238[1] + if !isempty(field1239) newline(pp) - for (i1711, elem1230) in enumerate(field1229) - i1231 = i1711 - 1 - if (i1231 > 0) + for (i1731, elem1240) in enumerate(field1239) + i1241 = i1731 - 1 + if (i1241 > 0) newline(pp) end - pretty_relation_id(pp, elem1230) + pretty_relation_id(pp, elem1240) end end newline(pp) - field1232 = unwrapped_fields1228[2] - pretty_script(pp, field1232) - field1233 = unwrapped_fields1228[3] - if !isnothing(field1233) + field1242 = unwrapped_fields1238[2] + pretty_script(pp, field1242) + field1243 = unwrapped_fields1238[3] + if !isnothing(field1243) newline(pp) - opt_val1234 = field1233 - pretty_attrs(pp, opt_val1234) + opt_val1244 = field1243 + pretty_attrs(pp, opt_val1244) end dedent!(pp) write(pp, ")") @@ -3057,24 +3057,24 @@ function pretty_algorithm(pp::PrettyPrinter, msg::Proto.Algorithm) end function pretty_script(pp::PrettyPrinter, msg::Proto.Script) - flat1240 = try_flat(pp, msg, pretty_script) - if !isnothing(flat1240) - write(pp, flat1240) + flat1250 = try_flat(pp, msg, pretty_script) + if !isnothing(flat1250) + write(pp, flat1250) return nothing else _dollar_dollar = msg - fields1236 = _dollar_dollar.constructs - unwrapped_fields1237 = fields1236 + fields1246 = _dollar_dollar.constructs + unwrapped_fields1247 = fields1246 write(pp, "(script") indent_sexp!(pp) - if !isempty(unwrapped_fields1237) + if !isempty(unwrapped_fields1247) newline(pp) - for (i1712, elem1238) in enumerate(unwrapped_fields1237) - i1239 = i1712 - 1 - if (i1239 > 0) + for (i1732, elem1248) in enumerate(unwrapped_fields1247) + i1249 = i1732 - 1 + if (i1249 > 0) newline(pp) end - pretty_construct(pp, elem1238) + pretty_construct(pp, elem1248) end end dedent!(pp) @@ -3084,32 +3084,32 @@ function pretty_script(pp::PrettyPrinter, msg::Proto.Script) end function pretty_construct(pp::PrettyPrinter, msg::Proto.Construct) - flat1245 = try_flat(pp, msg, pretty_construct) - if !isnothing(flat1245) - write(pp, flat1245) + flat1255 = try_flat(pp, msg, pretty_construct) + if !isnothing(flat1255) + write(pp, flat1255) return nothing else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("loop")) - _t1713 = _get_oneof_field(_dollar_dollar, :loop) + _t1733 = _get_oneof_field(_dollar_dollar, :loop) else - _t1713 = nothing + _t1733 = nothing end - deconstruct_result1243 = _t1713 - if !isnothing(deconstruct_result1243) - unwrapped1244 = deconstruct_result1243 - pretty_loop(pp, unwrapped1244) + deconstruct_result1253 = _t1733 + if !isnothing(deconstruct_result1253) + unwrapped1254 = deconstruct_result1253 + pretty_loop(pp, unwrapped1254) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("instruction")) - _t1714 = _get_oneof_field(_dollar_dollar, :instruction) + _t1734 = _get_oneof_field(_dollar_dollar, :instruction) else - _t1714 = nothing + _t1734 = nothing end - deconstruct_result1241 = _t1714 - if !isnothing(deconstruct_result1241) - unwrapped1242 = deconstruct_result1241 - pretty_instruction(pp, unwrapped1242) + deconstruct_result1251 = _t1734 + if !isnothing(deconstruct_result1251) + unwrapped1252 = deconstruct_result1251 + pretty_instruction(pp, unwrapped1252) else throw(ParseError("No matching rule for construct")) end @@ -3119,32 +3119,32 @@ function pretty_construct(pp::PrettyPrinter, msg::Proto.Construct) end function pretty_loop(pp::PrettyPrinter, msg::Proto.Loop) - flat1252 = try_flat(pp, msg, pretty_loop) - if !isnothing(flat1252) - write(pp, flat1252) + flat1262 = try_flat(pp, msg, pretty_loop) + if !isnothing(flat1262) + write(pp, flat1262) return nothing else _dollar_dollar = msg if !isempty(_dollar_dollar.attrs) - _t1715 = _dollar_dollar.attrs + _t1735 = _dollar_dollar.attrs else - _t1715 = nothing + _t1735 = nothing end - fields1246 = (_dollar_dollar.init, _dollar_dollar.body, _t1715,) - unwrapped_fields1247 = fields1246 + fields1256 = (_dollar_dollar.init, _dollar_dollar.body, _t1735,) + unwrapped_fields1257 = fields1256 write(pp, "(loop") indent_sexp!(pp) newline(pp) - field1248 = unwrapped_fields1247[1] - pretty_init(pp, field1248) + field1258 = unwrapped_fields1257[1] + pretty_init(pp, field1258) newline(pp) - field1249 = unwrapped_fields1247[2] - pretty_script(pp, field1249) - field1250 = unwrapped_fields1247[3] - if !isnothing(field1250) + field1259 = unwrapped_fields1257[2] + pretty_script(pp, field1259) + field1260 = unwrapped_fields1257[3] + if !isnothing(field1260) newline(pp) - opt_val1251 = field1250 - pretty_attrs(pp, opt_val1251) + opt_val1261 = field1260 + pretty_attrs(pp, opt_val1261) end dedent!(pp) write(pp, ")") @@ -3153,22 +3153,22 @@ function pretty_loop(pp::PrettyPrinter, msg::Proto.Loop) end function pretty_init(pp::PrettyPrinter, msg::Vector{Proto.Instruction}) - flat1256 = try_flat(pp, msg, pretty_init) - if !isnothing(flat1256) - write(pp, flat1256) + flat1266 = try_flat(pp, msg, pretty_init) + if !isnothing(flat1266) + write(pp, flat1266) return nothing else - fields1253 = msg + fields1263 = msg write(pp, "(init") indent_sexp!(pp) - if !isempty(fields1253) + if !isempty(fields1263) newline(pp) - for (i1716, elem1254) in enumerate(fields1253) - i1255 = i1716 - 1 - if (i1255 > 0) + for (i1736, elem1264) in enumerate(fields1263) + i1265 = i1736 - 1 + if (i1265 > 0) newline(pp) end - pretty_instruction(pp, elem1254) + pretty_instruction(pp, elem1264) end end dedent!(pp) @@ -3178,65 +3178,65 @@ function pretty_init(pp::PrettyPrinter, msg::Vector{Proto.Instruction}) end function pretty_instruction(pp::PrettyPrinter, msg::Proto.Instruction) - flat1267 = try_flat(pp, msg, pretty_instruction) - if !isnothing(flat1267) - write(pp, flat1267) + flat1277 = try_flat(pp, msg, pretty_instruction) + if !isnothing(flat1277) + write(pp, flat1277) return nothing else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("assign")) - _t1717 = _get_oneof_field(_dollar_dollar, :assign) + _t1737 = _get_oneof_field(_dollar_dollar, :assign) else - _t1717 = nothing + _t1737 = nothing end - deconstruct_result1265 = _t1717 - if !isnothing(deconstruct_result1265) - unwrapped1266 = deconstruct_result1265 - pretty_assign(pp, unwrapped1266) + deconstruct_result1275 = _t1737 + if !isnothing(deconstruct_result1275) + unwrapped1276 = deconstruct_result1275 + pretty_assign(pp, unwrapped1276) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("upsert")) - _t1718 = _get_oneof_field(_dollar_dollar, :upsert) + _t1738 = _get_oneof_field(_dollar_dollar, :upsert) else - _t1718 = nothing + _t1738 = nothing end - deconstruct_result1263 = _t1718 - if !isnothing(deconstruct_result1263) - unwrapped1264 = deconstruct_result1263 - pretty_upsert(pp, unwrapped1264) + deconstruct_result1273 = _t1738 + if !isnothing(deconstruct_result1273) + unwrapped1274 = deconstruct_result1273 + pretty_upsert(pp, unwrapped1274) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("#break")) - _t1719 = _get_oneof_field(_dollar_dollar, :var"#break") + _t1739 = _get_oneof_field(_dollar_dollar, :var"#break") else - _t1719 = nothing + _t1739 = nothing end - deconstruct_result1261 = _t1719 - if !isnothing(deconstruct_result1261) - unwrapped1262 = deconstruct_result1261 - pretty_break(pp, unwrapped1262) + deconstruct_result1271 = _t1739 + if !isnothing(deconstruct_result1271) + unwrapped1272 = deconstruct_result1271 + pretty_break(pp, unwrapped1272) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("monoid_def")) - _t1720 = _get_oneof_field(_dollar_dollar, :monoid_def) + _t1740 = _get_oneof_field(_dollar_dollar, :monoid_def) else - _t1720 = nothing + _t1740 = nothing end - deconstruct_result1259 = _t1720 - if !isnothing(deconstruct_result1259) - unwrapped1260 = deconstruct_result1259 - pretty_monoid_def(pp, unwrapped1260) + deconstruct_result1269 = _t1740 + if !isnothing(deconstruct_result1269) + unwrapped1270 = deconstruct_result1269 + pretty_monoid_def(pp, unwrapped1270) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("monus_def")) - _t1721 = _get_oneof_field(_dollar_dollar, :monus_def) + _t1741 = _get_oneof_field(_dollar_dollar, :monus_def) else - _t1721 = nothing + _t1741 = nothing end - deconstruct_result1257 = _t1721 - if !isnothing(deconstruct_result1257) - unwrapped1258 = deconstruct_result1257 - pretty_monus_def(pp, unwrapped1258) + deconstruct_result1267 = _t1741 + if !isnothing(deconstruct_result1267) + unwrapped1268 = deconstruct_result1267 + pretty_monus_def(pp, unwrapped1268) else throw(ParseError("No matching rule for instruction")) end @@ -3249,32 +3249,32 @@ function pretty_instruction(pp::PrettyPrinter, msg::Proto.Instruction) end function pretty_assign(pp::PrettyPrinter, msg::Proto.Assign) - flat1274 = try_flat(pp, msg, pretty_assign) - if !isnothing(flat1274) - write(pp, flat1274) + flat1284 = try_flat(pp, msg, pretty_assign) + if !isnothing(flat1284) + write(pp, flat1284) return nothing else _dollar_dollar = msg if !isempty(_dollar_dollar.attrs) - _t1722 = _dollar_dollar.attrs + _t1742 = _dollar_dollar.attrs else - _t1722 = nothing + _t1742 = nothing end - fields1268 = (_dollar_dollar.name, _dollar_dollar.body, _t1722,) - unwrapped_fields1269 = fields1268 + fields1278 = (_dollar_dollar.name, _dollar_dollar.body, _t1742,) + unwrapped_fields1279 = fields1278 write(pp, "(assign") indent_sexp!(pp) newline(pp) - field1270 = unwrapped_fields1269[1] - pretty_relation_id(pp, field1270) + field1280 = unwrapped_fields1279[1] + pretty_relation_id(pp, field1280) newline(pp) - field1271 = unwrapped_fields1269[2] - pretty_abstraction(pp, field1271) - field1272 = unwrapped_fields1269[3] - if !isnothing(field1272) + field1281 = unwrapped_fields1279[2] + pretty_abstraction(pp, field1281) + field1282 = unwrapped_fields1279[3] + if !isnothing(field1282) newline(pp) - opt_val1273 = field1272 - pretty_attrs(pp, opt_val1273) + opt_val1283 = field1282 + pretty_attrs(pp, opt_val1283) end dedent!(pp) write(pp, ")") @@ -3283,32 +3283,32 @@ function pretty_assign(pp::PrettyPrinter, msg::Proto.Assign) end function pretty_upsert(pp::PrettyPrinter, msg::Proto.Upsert) - flat1281 = try_flat(pp, msg, pretty_upsert) - if !isnothing(flat1281) - write(pp, flat1281) + flat1291 = try_flat(pp, msg, pretty_upsert) + if !isnothing(flat1291) + write(pp, flat1291) return nothing else _dollar_dollar = msg if !isempty(_dollar_dollar.attrs) - _t1723 = _dollar_dollar.attrs + _t1743 = _dollar_dollar.attrs else - _t1723 = nothing + _t1743 = nothing end - fields1275 = (_dollar_dollar.name, (_dollar_dollar.body, _dollar_dollar.value_arity,), _t1723,) - unwrapped_fields1276 = fields1275 + fields1285 = (_dollar_dollar.name, (_dollar_dollar.body, _dollar_dollar.value_arity,), _t1743,) + unwrapped_fields1286 = fields1285 write(pp, "(upsert") indent_sexp!(pp) newline(pp) - field1277 = unwrapped_fields1276[1] - pretty_relation_id(pp, field1277) + field1287 = unwrapped_fields1286[1] + pretty_relation_id(pp, field1287) newline(pp) - field1278 = unwrapped_fields1276[2] - pretty_abstraction_with_arity(pp, field1278) - field1279 = unwrapped_fields1276[3] - if !isnothing(field1279) + field1288 = unwrapped_fields1286[2] + pretty_abstraction_with_arity(pp, field1288) + field1289 = unwrapped_fields1286[3] + if !isnothing(field1289) newline(pp) - opt_val1280 = field1279 - pretty_attrs(pp, opt_val1280) + opt_val1290 = field1289 + pretty_attrs(pp, opt_val1290) end dedent!(pp) write(pp, ")") @@ -3317,22 +3317,22 @@ function pretty_upsert(pp::PrettyPrinter, msg::Proto.Upsert) end function pretty_abstraction_with_arity(pp::PrettyPrinter, msg::Tuple{Proto.Abstraction, Int64}) - flat1286 = try_flat(pp, msg, pretty_abstraction_with_arity) - if !isnothing(flat1286) - write(pp, flat1286) + flat1296 = try_flat(pp, msg, pretty_abstraction_with_arity) + if !isnothing(flat1296) + write(pp, flat1296) return nothing else _dollar_dollar = msg - _t1724 = deconstruct_bindings_with_arity(pp, _dollar_dollar[1], _dollar_dollar[2]) - fields1282 = (_t1724, _dollar_dollar[1].value,) - unwrapped_fields1283 = fields1282 + _t1744 = deconstruct_bindings_with_arity(pp, _dollar_dollar[1], _dollar_dollar[2]) + fields1292 = (_t1744, _dollar_dollar[1].value,) + unwrapped_fields1293 = fields1292 write(pp, "(") indent!(pp) - field1284 = unwrapped_fields1283[1] - pretty_bindings(pp, field1284) + field1294 = unwrapped_fields1293[1] + pretty_bindings(pp, field1294) newline(pp) - field1285 = unwrapped_fields1283[2] - pretty_formula(pp, field1285) + field1295 = unwrapped_fields1293[2] + pretty_formula(pp, field1295) dedent!(pp) write(pp, ")") end @@ -3340,32 +3340,32 @@ function pretty_abstraction_with_arity(pp::PrettyPrinter, msg::Tuple{Proto.Abstr end function pretty_break(pp::PrettyPrinter, msg::Proto.Break) - flat1293 = try_flat(pp, msg, pretty_break) - if !isnothing(flat1293) - write(pp, flat1293) + flat1303 = try_flat(pp, msg, pretty_break) + if !isnothing(flat1303) + write(pp, flat1303) return nothing else _dollar_dollar = msg if !isempty(_dollar_dollar.attrs) - _t1725 = _dollar_dollar.attrs + _t1745 = _dollar_dollar.attrs else - _t1725 = nothing + _t1745 = nothing end - fields1287 = (_dollar_dollar.name, _dollar_dollar.body, _t1725,) - unwrapped_fields1288 = fields1287 + fields1297 = (_dollar_dollar.name, _dollar_dollar.body, _t1745,) + unwrapped_fields1298 = fields1297 write(pp, "(break") indent_sexp!(pp) newline(pp) - field1289 = unwrapped_fields1288[1] - pretty_relation_id(pp, field1289) + field1299 = unwrapped_fields1298[1] + pretty_relation_id(pp, field1299) newline(pp) - field1290 = unwrapped_fields1288[2] - pretty_abstraction(pp, field1290) - field1291 = unwrapped_fields1288[3] - if !isnothing(field1291) + field1300 = unwrapped_fields1298[2] + pretty_abstraction(pp, field1300) + field1301 = unwrapped_fields1298[3] + if !isnothing(field1301) newline(pp) - opt_val1292 = field1291 - pretty_attrs(pp, opt_val1292) + opt_val1302 = field1301 + pretty_attrs(pp, opt_val1302) end dedent!(pp) write(pp, ")") @@ -3374,35 +3374,35 @@ function pretty_break(pp::PrettyPrinter, msg::Proto.Break) end function pretty_monoid_def(pp::PrettyPrinter, msg::Proto.MonoidDef) - flat1301 = try_flat(pp, msg, pretty_monoid_def) - if !isnothing(flat1301) - write(pp, flat1301) + flat1311 = try_flat(pp, msg, pretty_monoid_def) + if !isnothing(flat1311) + write(pp, flat1311) return nothing else _dollar_dollar = msg if !isempty(_dollar_dollar.attrs) - _t1726 = _dollar_dollar.attrs + _t1746 = _dollar_dollar.attrs else - _t1726 = nothing + _t1746 = nothing end - fields1294 = (_dollar_dollar.monoid, _dollar_dollar.name, (_dollar_dollar.body, _dollar_dollar.value_arity,), _t1726,) - unwrapped_fields1295 = fields1294 + fields1304 = (_dollar_dollar.monoid, _dollar_dollar.name, (_dollar_dollar.body, _dollar_dollar.value_arity,), _t1746,) + unwrapped_fields1305 = fields1304 write(pp, "(monoid") indent_sexp!(pp) newline(pp) - field1296 = unwrapped_fields1295[1] - pretty_monoid(pp, field1296) + field1306 = unwrapped_fields1305[1] + pretty_monoid(pp, field1306) newline(pp) - field1297 = unwrapped_fields1295[2] - pretty_relation_id(pp, field1297) + field1307 = unwrapped_fields1305[2] + pretty_relation_id(pp, field1307) newline(pp) - field1298 = unwrapped_fields1295[3] - pretty_abstraction_with_arity(pp, field1298) - field1299 = unwrapped_fields1295[4] - if !isnothing(field1299) + field1308 = unwrapped_fields1305[3] + pretty_abstraction_with_arity(pp, field1308) + field1309 = unwrapped_fields1305[4] + if !isnothing(field1309) newline(pp) - opt_val1300 = field1299 - pretty_attrs(pp, opt_val1300) + opt_val1310 = field1309 + pretty_attrs(pp, opt_val1310) end dedent!(pp) write(pp, ")") @@ -3411,54 +3411,54 @@ function pretty_monoid_def(pp::PrettyPrinter, msg::Proto.MonoidDef) end function pretty_monoid(pp::PrettyPrinter, msg::Proto.Monoid) - flat1310 = try_flat(pp, msg, pretty_monoid) - if !isnothing(flat1310) - write(pp, flat1310) + flat1320 = try_flat(pp, msg, pretty_monoid) + if !isnothing(flat1320) + write(pp, flat1320) return nothing else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("or_monoid")) - _t1727 = _get_oneof_field(_dollar_dollar, :or_monoid) + _t1747 = _get_oneof_field(_dollar_dollar, :or_monoid) else - _t1727 = nothing + _t1747 = nothing end - deconstruct_result1308 = _t1727 - if !isnothing(deconstruct_result1308) - unwrapped1309 = deconstruct_result1308 - pretty_or_monoid(pp, unwrapped1309) + deconstruct_result1318 = _t1747 + if !isnothing(deconstruct_result1318) + unwrapped1319 = deconstruct_result1318 + pretty_or_monoid(pp, unwrapped1319) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("min_monoid")) - _t1728 = _get_oneof_field(_dollar_dollar, :min_monoid) + _t1748 = _get_oneof_field(_dollar_dollar, :min_monoid) else - _t1728 = nothing + _t1748 = nothing end - deconstruct_result1306 = _t1728 - if !isnothing(deconstruct_result1306) - unwrapped1307 = deconstruct_result1306 - pretty_min_monoid(pp, unwrapped1307) + deconstruct_result1316 = _t1748 + if !isnothing(deconstruct_result1316) + unwrapped1317 = deconstruct_result1316 + pretty_min_monoid(pp, unwrapped1317) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("max_monoid")) - _t1729 = _get_oneof_field(_dollar_dollar, :max_monoid) + _t1749 = _get_oneof_field(_dollar_dollar, :max_monoid) else - _t1729 = nothing + _t1749 = nothing end - deconstruct_result1304 = _t1729 - if !isnothing(deconstruct_result1304) - unwrapped1305 = deconstruct_result1304 - pretty_max_monoid(pp, unwrapped1305) + deconstruct_result1314 = _t1749 + if !isnothing(deconstruct_result1314) + unwrapped1315 = deconstruct_result1314 + pretty_max_monoid(pp, unwrapped1315) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("sum_monoid")) - _t1730 = _get_oneof_field(_dollar_dollar, :sum_monoid) + _t1750 = _get_oneof_field(_dollar_dollar, :sum_monoid) else - _t1730 = nothing + _t1750 = nothing end - deconstruct_result1302 = _t1730 - if !isnothing(deconstruct_result1302) - unwrapped1303 = deconstruct_result1302 - pretty_sum_monoid(pp, unwrapped1303) + deconstruct_result1312 = _t1750 + if !isnothing(deconstruct_result1312) + unwrapped1313 = deconstruct_result1312 + pretty_sum_monoid(pp, unwrapped1313) else throw(ParseError("No matching rule for monoid")) end @@ -3470,24 +3470,24 @@ function pretty_monoid(pp::PrettyPrinter, msg::Proto.Monoid) end function pretty_or_monoid(pp::PrettyPrinter, msg::Proto.OrMonoid) - fields1311 = msg + fields1321 = msg write(pp, "(or)") return nothing end function pretty_min_monoid(pp::PrettyPrinter, msg::Proto.MinMonoid) - flat1314 = try_flat(pp, msg, pretty_min_monoid) - if !isnothing(flat1314) - write(pp, flat1314) + flat1324 = try_flat(pp, msg, pretty_min_monoid) + if !isnothing(flat1324) + write(pp, flat1324) return nothing else _dollar_dollar = msg - fields1312 = _dollar_dollar.var"#type" - unwrapped_fields1313 = fields1312 + fields1322 = _dollar_dollar.var"#type" + unwrapped_fields1323 = fields1322 write(pp, "(min") indent_sexp!(pp) newline(pp) - pretty_type(pp, unwrapped_fields1313) + pretty_type(pp, unwrapped_fields1323) dedent!(pp) write(pp, ")") end @@ -3495,18 +3495,18 @@ function pretty_min_monoid(pp::PrettyPrinter, msg::Proto.MinMonoid) end function pretty_max_monoid(pp::PrettyPrinter, msg::Proto.MaxMonoid) - flat1317 = try_flat(pp, msg, pretty_max_monoid) - if !isnothing(flat1317) - write(pp, flat1317) + flat1327 = try_flat(pp, msg, pretty_max_monoid) + if !isnothing(flat1327) + write(pp, flat1327) return nothing else _dollar_dollar = msg - fields1315 = _dollar_dollar.var"#type" - unwrapped_fields1316 = fields1315 + fields1325 = _dollar_dollar.var"#type" + unwrapped_fields1326 = fields1325 write(pp, "(max") indent_sexp!(pp) newline(pp) - pretty_type(pp, unwrapped_fields1316) + pretty_type(pp, unwrapped_fields1326) dedent!(pp) write(pp, ")") end @@ -3514,18 +3514,18 @@ function pretty_max_monoid(pp::PrettyPrinter, msg::Proto.MaxMonoid) end function pretty_sum_monoid(pp::PrettyPrinter, msg::Proto.SumMonoid) - flat1320 = try_flat(pp, msg, pretty_sum_monoid) - if !isnothing(flat1320) - write(pp, flat1320) + flat1330 = try_flat(pp, msg, pretty_sum_monoid) + if !isnothing(flat1330) + write(pp, flat1330) return nothing else _dollar_dollar = msg - fields1318 = _dollar_dollar.var"#type" - unwrapped_fields1319 = fields1318 + fields1328 = _dollar_dollar.var"#type" + unwrapped_fields1329 = fields1328 write(pp, "(sum") indent_sexp!(pp) newline(pp) - pretty_type(pp, unwrapped_fields1319) + pretty_type(pp, unwrapped_fields1329) dedent!(pp) write(pp, ")") end @@ -3533,35 +3533,35 @@ function pretty_sum_monoid(pp::PrettyPrinter, msg::Proto.SumMonoid) end function pretty_monus_def(pp::PrettyPrinter, msg::Proto.MonusDef) - flat1328 = try_flat(pp, msg, pretty_monus_def) - if !isnothing(flat1328) - write(pp, flat1328) + flat1338 = try_flat(pp, msg, pretty_monus_def) + if !isnothing(flat1338) + write(pp, flat1338) return nothing else _dollar_dollar = msg if !isempty(_dollar_dollar.attrs) - _t1731 = _dollar_dollar.attrs + _t1751 = _dollar_dollar.attrs else - _t1731 = nothing + _t1751 = nothing end - fields1321 = (_dollar_dollar.monoid, _dollar_dollar.name, (_dollar_dollar.body, _dollar_dollar.value_arity,), _t1731,) - unwrapped_fields1322 = fields1321 + fields1331 = (_dollar_dollar.monoid, _dollar_dollar.name, (_dollar_dollar.body, _dollar_dollar.value_arity,), _t1751,) + unwrapped_fields1332 = fields1331 write(pp, "(monus") indent_sexp!(pp) newline(pp) - field1323 = unwrapped_fields1322[1] - pretty_monoid(pp, field1323) + field1333 = unwrapped_fields1332[1] + pretty_monoid(pp, field1333) newline(pp) - field1324 = unwrapped_fields1322[2] - pretty_relation_id(pp, field1324) + field1334 = unwrapped_fields1332[2] + pretty_relation_id(pp, field1334) newline(pp) - field1325 = unwrapped_fields1322[3] - pretty_abstraction_with_arity(pp, field1325) - field1326 = unwrapped_fields1322[4] - if !isnothing(field1326) + field1335 = unwrapped_fields1332[3] + pretty_abstraction_with_arity(pp, field1335) + field1336 = unwrapped_fields1332[4] + if !isnothing(field1336) newline(pp) - opt_val1327 = field1326 - pretty_attrs(pp, opt_val1327) + opt_val1337 = field1336 + pretty_attrs(pp, opt_val1337) end dedent!(pp) write(pp, ")") @@ -3570,28 +3570,28 @@ function pretty_monus_def(pp::PrettyPrinter, msg::Proto.MonusDef) end function pretty_constraint(pp::PrettyPrinter, msg::Proto.Constraint) - flat1335 = try_flat(pp, msg, pretty_constraint) - if !isnothing(flat1335) - write(pp, flat1335) + flat1345 = try_flat(pp, msg, pretty_constraint) + if !isnothing(flat1345) + write(pp, flat1345) return nothing else _dollar_dollar = msg - fields1329 = (_dollar_dollar.name, _get_oneof_field(_dollar_dollar, :functional_dependency).guard, _get_oneof_field(_dollar_dollar, :functional_dependency).keys, _get_oneof_field(_dollar_dollar, :functional_dependency).values,) - unwrapped_fields1330 = fields1329 + fields1339 = (_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_fields1340 = fields1339 write(pp, "(functional_dependency") indent_sexp!(pp) newline(pp) - field1331 = unwrapped_fields1330[1] - pretty_relation_id(pp, field1331) + field1341 = unwrapped_fields1340[1] + pretty_relation_id(pp, field1341) newline(pp) - field1332 = unwrapped_fields1330[2] - pretty_abstraction(pp, field1332) + field1342 = unwrapped_fields1340[2] + pretty_abstraction(pp, field1342) newline(pp) - field1333 = unwrapped_fields1330[3] - pretty_functional_dependency_keys(pp, field1333) + field1343 = unwrapped_fields1340[3] + pretty_functional_dependency_keys(pp, field1343) newline(pp) - field1334 = unwrapped_fields1330[4] - pretty_functional_dependency_values(pp, field1334) + field1344 = unwrapped_fields1340[4] + pretty_functional_dependency_values(pp, field1344) dedent!(pp) write(pp, ")") end @@ -3599,22 +3599,22 @@ function pretty_constraint(pp::PrettyPrinter, msg::Proto.Constraint) end function pretty_functional_dependency_keys(pp::PrettyPrinter, msg::Vector{Proto.Var}) - flat1339 = try_flat(pp, msg, pretty_functional_dependency_keys) - if !isnothing(flat1339) - write(pp, flat1339) + flat1349 = try_flat(pp, msg, pretty_functional_dependency_keys) + if !isnothing(flat1349) + write(pp, flat1349) return nothing else - fields1336 = msg + fields1346 = msg write(pp, "(keys") indent_sexp!(pp) - if !isempty(fields1336) + if !isempty(fields1346) newline(pp) - for (i1732, elem1337) in enumerate(fields1336) - i1338 = i1732 - 1 - if (i1338 > 0) + for (i1752, elem1347) in enumerate(fields1346) + i1348 = i1752 - 1 + if (i1348 > 0) newline(pp) end - pretty_var(pp, elem1337) + pretty_var(pp, elem1347) end end dedent!(pp) @@ -3624,22 +3624,22 @@ function pretty_functional_dependency_keys(pp::PrettyPrinter, msg::Vector{Proto. end function pretty_functional_dependency_values(pp::PrettyPrinter, msg::Vector{Proto.Var}) - flat1343 = try_flat(pp, msg, pretty_functional_dependency_values) - if !isnothing(flat1343) - write(pp, flat1343) + flat1353 = try_flat(pp, msg, pretty_functional_dependency_values) + if !isnothing(flat1353) + write(pp, flat1353) return nothing else - fields1340 = msg + fields1350 = msg write(pp, "(values") indent_sexp!(pp) - if !isempty(fields1340) + if !isempty(fields1350) newline(pp) - for (i1733, elem1341) in enumerate(fields1340) - i1342 = i1733 - 1 - if (i1342 > 0) + for (i1753, elem1351) in enumerate(fields1350) + i1352 = i1753 - 1 + if (i1352 > 0) newline(pp) end - pretty_var(pp, elem1341) + pretty_var(pp, elem1351) end end dedent!(pp) @@ -3649,54 +3649,54 @@ function pretty_functional_dependency_values(pp::PrettyPrinter, msg::Vector{Prot end function pretty_data(pp::PrettyPrinter, msg::Proto.Data) - flat1352 = try_flat(pp, msg, pretty_data) - if !isnothing(flat1352) - write(pp, flat1352) + flat1362 = try_flat(pp, msg, pretty_data) + if !isnothing(flat1362) + write(pp, flat1362) return nothing else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("edb")) - _t1734 = _get_oneof_field(_dollar_dollar, :edb) + _t1754 = _get_oneof_field(_dollar_dollar, :edb) else - _t1734 = nothing + _t1754 = nothing end - deconstruct_result1350 = _t1734 - if !isnothing(deconstruct_result1350) - unwrapped1351 = deconstruct_result1350 - pretty_edb(pp, unwrapped1351) + deconstruct_result1360 = _t1754 + if !isnothing(deconstruct_result1360) + unwrapped1361 = deconstruct_result1360 + pretty_edb(pp, unwrapped1361) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("betree_relation")) - _t1735 = _get_oneof_field(_dollar_dollar, :betree_relation) + _t1755 = _get_oneof_field(_dollar_dollar, :betree_relation) else - _t1735 = nothing + _t1755 = nothing end - deconstruct_result1348 = _t1735 - if !isnothing(deconstruct_result1348) - unwrapped1349 = deconstruct_result1348 - pretty_betree_relation(pp, unwrapped1349) + deconstruct_result1358 = _t1755 + if !isnothing(deconstruct_result1358) + unwrapped1359 = deconstruct_result1358 + pretty_betree_relation(pp, unwrapped1359) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("csv_data")) - _t1736 = _get_oneof_field(_dollar_dollar, :csv_data) + _t1756 = _get_oneof_field(_dollar_dollar, :csv_data) else - _t1736 = nothing + _t1756 = nothing end - deconstruct_result1346 = _t1736 - if !isnothing(deconstruct_result1346) - unwrapped1347 = deconstruct_result1346 - pretty_csv_data(pp, unwrapped1347) + deconstruct_result1356 = _t1756 + if !isnothing(deconstruct_result1356) + unwrapped1357 = deconstruct_result1356 + pretty_csv_data(pp, unwrapped1357) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("iceberg_data")) - _t1737 = _get_oneof_field(_dollar_dollar, :iceberg_data) + _t1757 = _get_oneof_field(_dollar_dollar, :iceberg_data) else - _t1737 = nothing + _t1757 = nothing end - deconstruct_result1344 = _t1737 - if !isnothing(deconstruct_result1344) - unwrapped1345 = deconstruct_result1344 - pretty_iceberg_data(pp, unwrapped1345) + deconstruct_result1354 = _t1757 + if !isnothing(deconstruct_result1354) + unwrapped1355 = deconstruct_result1354 + pretty_iceberg_data(pp, unwrapped1355) else throw(ParseError("No matching rule for data")) end @@ -3708,25 +3708,25 @@ function pretty_data(pp::PrettyPrinter, msg::Proto.Data) end function pretty_edb(pp::PrettyPrinter, msg::Proto.EDB) - flat1358 = try_flat(pp, msg, pretty_edb) - if !isnothing(flat1358) - write(pp, flat1358) + flat1368 = try_flat(pp, msg, pretty_edb) + if !isnothing(flat1368) + write(pp, flat1368) return nothing else _dollar_dollar = msg - fields1353 = (_dollar_dollar.target_id, _dollar_dollar.path, _dollar_dollar.types,) - unwrapped_fields1354 = fields1353 + fields1363 = (_dollar_dollar.target_id, _dollar_dollar.path, _dollar_dollar.types,) + unwrapped_fields1364 = fields1363 write(pp, "(edb") indent_sexp!(pp) newline(pp) - field1355 = unwrapped_fields1354[1] - pretty_relation_id(pp, field1355) + field1365 = unwrapped_fields1364[1] + pretty_relation_id(pp, field1365) newline(pp) - field1356 = unwrapped_fields1354[2] - pretty_edb_path(pp, field1356) + field1366 = unwrapped_fields1364[2] + pretty_edb_path(pp, field1366) newline(pp) - field1357 = unwrapped_fields1354[3] - pretty_edb_types(pp, field1357) + field1367 = unwrapped_fields1364[3] + pretty_edb_types(pp, field1367) dedent!(pp) write(pp, ")") end @@ -3734,20 +3734,20 @@ function pretty_edb(pp::PrettyPrinter, msg::Proto.EDB) end function pretty_edb_path(pp::PrettyPrinter, msg::Vector{String}) - flat1362 = try_flat(pp, msg, pretty_edb_path) - if !isnothing(flat1362) - write(pp, flat1362) + flat1372 = try_flat(pp, msg, pretty_edb_path) + if !isnothing(flat1372) + write(pp, flat1372) return nothing else - fields1359 = msg + fields1369 = msg write(pp, "[") indent!(pp) - for (i1738, elem1360) in enumerate(fields1359) - i1361 = i1738 - 1 - if (i1361 > 0) + for (i1758, elem1370) in enumerate(fields1369) + i1371 = i1758 - 1 + if (i1371 > 0) newline(pp) end - write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, elem1360)) + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, elem1370)) end dedent!(pp) write(pp, "]") @@ -3756,20 +3756,20 @@ function pretty_edb_path(pp::PrettyPrinter, msg::Vector{String}) end function pretty_edb_types(pp::PrettyPrinter, msg::Vector{Proto.var"#Type"}) - flat1366 = try_flat(pp, msg, pretty_edb_types) - if !isnothing(flat1366) - write(pp, flat1366) + flat1376 = try_flat(pp, msg, pretty_edb_types) + if !isnothing(flat1376) + write(pp, flat1376) return nothing else - fields1363 = msg + fields1373 = msg write(pp, "[") indent!(pp) - for (i1739, elem1364) in enumerate(fields1363) - i1365 = i1739 - 1 - if (i1365 > 0) + for (i1759, elem1374) in enumerate(fields1373) + i1375 = i1759 - 1 + if (i1375 > 0) newline(pp) end - pretty_type(pp, elem1364) + pretty_type(pp, elem1374) end dedent!(pp) write(pp, "]") @@ -3778,22 +3778,22 @@ function pretty_edb_types(pp::PrettyPrinter, msg::Vector{Proto.var"#Type"}) end function pretty_betree_relation(pp::PrettyPrinter, msg::Proto.BeTreeRelation) - flat1371 = try_flat(pp, msg, pretty_betree_relation) - if !isnothing(flat1371) - write(pp, flat1371) + flat1381 = try_flat(pp, msg, pretty_betree_relation) + if !isnothing(flat1381) + write(pp, flat1381) return nothing else _dollar_dollar = msg - fields1367 = (_dollar_dollar.name, _dollar_dollar.relation_info,) - unwrapped_fields1368 = fields1367 + fields1377 = (_dollar_dollar.name, _dollar_dollar.relation_info,) + unwrapped_fields1378 = fields1377 write(pp, "(betree_relation") indent_sexp!(pp) newline(pp) - field1369 = unwrapped_fields1368[1] - pretty_relation_id(pp, field1369) + field1379 = unwrapped_fields1378[1] + pretty_relation_id(pp, field1379) newline(pp) - field1370 = unwrapped_fields1368[2] - pretty_betree_info(pp, field1370) + field1380 = unwrapped_fields1378[2] + pretty_betree_info(pp, field1380) dedent!(pp) write(pp, ")") end @@ -3801,26 +3801,26 @@ function pretty_betree_relation(pp::PrettyPrinter, msg::Proto.BeTreeRelation) end function pretty_betree_info(pp::PrettyPrinter, msg::Proto.BeTreeInfo) - flat1377 = try_flat(pp, msg, pretty_betree_info) - if !isnothing(flat1377) - write(pp, flat1377) + flat1387 = try_flat(pp, msg, pretty_betree_info) + if !isnothing(flat1387) + write(pp, flat1387) return nothing else _dollar_dollar = msg - _t1740 = deconstruct_betree_info_config(pp, _dollar_dollar) - fields1372 = (_dollar_dollar.key_types, _dollar_dollar.value_types, _t1740,) - unwrapped_fields1373 = fields1372 + _t1760 = deconstruct_betree_info_config(pp, _dollar_dollar) + fields1382 = (_dollar_dollar.key_types, _dollar_dollar.value_types, _t1760,) + unwrapped_fields1383 = fields1382 write(pp, "(betree_info") indent_sexp!(pp) newline(pp) - field1374 = unwrapped_fields1373[1] - pretty_betree_info_key_types(pp, field1374) + field1384 = unwrapped_fields1383[1] + pretty_betree_info_key_types(pp, field1384) newline(pp) - field1375 = unwrapped_fields1373[2] - pretty_betree_info_value_types(pp, field1375) + field1385 = unwrapped_fields1383[2] + pretty_betree_info_value_types(pp, field1385) newline(pp) - field1376 = unwrapped_fields1373[3] - pretty_config_dict(pp, field1376) + field1386 = unwrapped_fields1383[3] + pretty_config_dict(pp, field1386) dedent!(pp) write(pp, ")") end @@ -3828,22 +3828,22 @@ function pretty_betree_info(pp::PrettyPrinter, msg::Proto.BeTreeInfo) end function pretty_betree_info_key_types(pp::PrettyPrinter, msg::Vector{Proto.var"#Type"}) - flat1381 = try_flat(pp, msg, pretty_betree_info_key_types) - if !isnothing(flat1381) - write(pp, flat1381) + flat1391 = try_flat(pp, msg, pretty_betree_info_key_types) + if !isnothing(flat1391) + write(pp, flat1391) return nothing else - fields1378 = msg + fields1388 = msg write(pp, "(key_types") indent_sexp!(pp) - if !isempty(fields1378) + if !isempty(fields1388) newline(pp) - for (i1741, elem1379) in enumerate(fields1378) - i1380 = i1741 - 1 - if (i1380 > 0) + for (i1761, elem1389) in enumerate(fields1388) + i1390 = i1761 - 1 + if (i1390 > 0) newline(pp) end - pretty_type(pp, elem1379) + pretty_type(pp, elem1389) end end dedent!(pp) @@ -3853,22 +3853,22 @@ function pretty_betree_info_key_types(pp::PrettyPrinter, msg::Vector{Proto.var"# end function pretty_betree_info_value_types(pp::PrettyPrinter, msg::Vector{Proto.var"#Type"}) - flat1385 = try_flat(pp, msg, pretty_betree_info_value_types) - if !isnothing(flat1385) - write(pp, flat1385) + flat1395 = try_flat(pp, msg, pretty_betree_info_value_types) + if !isnothing(flat1395) + write(pp, flat1395) return nothing else - fields1382 = msg + fields1392 = msg write(pp, "(value_types") indent_sexp!(pp) - if !isempty(fields1382) + if !isempty(fields1392) newline(pp) - for (i1742, elem1383) in enumerate(fields1382) - i1384 = i1742 - 1 - if (i1384 > 0) + for (i1762, elem1393) in enumerate(fields1392) + i1394 = i1762 - 1 + if (i1394 > 0) newline(pp) end - pretty_type(pp, elem1383) + pretty_type(pp, elem1393) end end dedent!(pp) @@ -3878,28 +3878,28 @@ function pretty_betree_info_value_types(pp::PrettyPrinter, msg::Vector{Proto.var end function pretty_csv_data(pp::PrettyPrinter, msg::Proto.CSVData) - flat1392 = try_flat(pp, msg, pretty_csv_data) - if !isnothing(flat1392) - write(pp, flat1392) + flat1402 = try_flat(pp, msg, pretty_csv_data) + if !isnothing(flat1402) + write(pp, flat1402) return nothing else _dollar_dollar = msg - fields1386 = (_dollar_dollar.locator, _dollar_dollar.config, _dollar_dollar.columns, _dollar_dollar.asof,) - unwrapped_fields1387 = fields1386 + fields1396 = (_dollar_dollar.locator, _dollar_dollar.config, _dollar_dollar.columns, _dollar_dollar.asof,) + unwrapped_fields1397 = fields1396 write(pp, "(csv_data") indent_sexp!(pp) newline(pp) - field1388 = unwrapped_fields1387[1] - pretty_csvlocator(pp, field1388) + field1398 = unwrapped_fields1397[1] + pretty_csvlocator(pp, field1398) newline(pp) - field1389 = unwrapped_fields1387[2] - pretty_csv_config(pp, field1389) + field1399 = unwrapped_fields1397[2] + pretty_csv_config(pp, field1399) newline(pp) - field1390 = unwrapped_fields1387[3] - pretty_gnf_columns(pp, field1390) + field1400 = unwrapped_fields1397[3] + pretty_gnf_columns(pp, field1400) newline(pp) - field1391 = unwrapped_fields1387[4] - pretty_csv_asof(pp, field1391) + field1401 = unwrapped_fields1397[4] + pretty_csv_asof(pp, field1401) dedent!(pp) write(pp, ")") end @@ -3907,37 +3907,37 @@ function pretty_csv_data(pp::PrettyPrinter, msg::Proto.CSVData) end function pretty_csvlocator(pp::PrettyPrinter, msg::Proto.CSVLocator) - flat1399 = try_flat(pp, msg, pretty_csvlocator) - if !isnothing(flat1399) - write(pp, flat1399) + flat1409 = try_flat(pp, msg, pretty_csvlocator) + if !isnothing(flat1409) + write(pp, flat1409) return nothing else _dollar_dollar = msg if !isempty(_dollar_dollar.paths) - _t1743 = _dollar_dollar.paths + _t1763 = _dollar_dollar.paths else - _t1743 = nothing + _t1763 = nothing end if String(copy(_dollar_dollar.inline_data)) != "" - _t1744 = String(copy(_dollar_dollar.inline_data)) + _t1764 = String(copy(_dollar_dollar.inline_data)) else - _t1744 = nothing + _t1764 = nothing end - fields1393 = (_t1743, _t1744,) - unwrapped_fields1394 = fields1393 + fields1403 = (_t1763, _t1764,) + unwrapped_fields1404 = fields1403 write(pp, "(csv_locator") indent_sexp!(pp) - field1395 = unwrapped_fields1394[1] - if !isnothing(field1395) + field1405 = unwrapped_fields1404[1] + if !isnothing(field1405) newline(pp) - opt_val1396 = field1395 - pretty_csv_locator_paths(pp, opt_val1396) + opt_val1406 = field1405 + pretty_csv_locator_paths(pp, opt_val1406) end - field1397 = unwrapped_fields1394[2] - if !isnothing(field1397) + field1407 = unwrapped_fields1404[2] + if !isnothing(field1407) newline(pp) - opt_val1398 = field1397 - pretty_csv_locator_inline_data(pp, opt_val1398) + opt_val1408 = field1407 + pretty_csv_locator_inline_data(pp, opt_val1408) end dedent!(pp) write(pp, ")") @@ -3946,22 +3946,22 @@ function pretty_csvlocator(pp::PrettyPrinter, msg::Proto.CSVLocator) end function pretty_csv_locator_paths(pp::PrettyPrinter, msg::Vector{String}) - flat1403 = try_flat(pp, msg, pretty_csv_locator_paths) - if !isnothing(flat1403) - write(pp, flat1403) + flat1413 = try_flat(pp, msg, pretty_csv_locator_paths) + if !isnothing(flat1413) + write(pp, flat1413) return nothing else - fields1400 = msg + fields1410 = msg write(pp, "(paths") indent_sexp!(pp) - if !isempty(fields1400) + if !isempty(fields1410) newline(pp) - for (i1745, elem1401) in enumerate(fields1400) - i1402 = i1745 - 1 - if (i1402 > 0) + for (i1765, elem1411) in enumerate(fields1410) + i1412 = i1765 - 1 + if (i1412 > 0) newline(pp) end - write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, elem1401)) + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, elem1411)) end end dedent!(pp) @@ -3971,16 +3971,16 @@ function pretty_csv_locator_paths(pp::PrettyPrinter, msg::Vector{String}) end function pretty_csv_locator_inline_data(pp::PrettyPrinter, msg::String) - flat1405 = try_flat(pp, msg, pretty_csv_locator_inline_data) - if !isnothing(flat1405) - write(pp, flat1405) + flat1415 = try_flat(pp, msg, pretty_csv_locator_inline_data) + if !isnothing(flat1415) + write(pp, flat1415) return nothing else - fields1404 = msg + fields1414 = msg write(pp, "(inline_data") indent_sexp!(pp) newline(pp) - write(pp, format_string(pp, fields1404)) + write(pp, format_string(pp, fields1414)) dedent!(pp) write(pp, ")") end @@ -3988,26 +3988,26 @@ function pretty_csv_locator_inline_data(pp::PrettyPrinter, msg::String) end function pretty_csv_config(pp::PrettyPrinter, msg::Proto.CSVConfig) - flat1411 = try_flat(pp, msg, pretty_csv_config) - if !isnothing(flat1411) - write(pp, flat1411) + flat1421 = try_flat(pp, msg, pretty_csv_config) + if !isnothing(flat1421) + write(pp, flat1421) return nothing else _dollar_dollar = msg - _t1746 = deconstruct_csv_config(pp, _dollar_dollar) - _t1747 = deconstruct_csv_storage_integration_optional(pp, _dollar_dollar) - fields1406 = (_t1746, _t1747,) - unwrapped_fields1407 = fields1406 + _t1766 = deconstruct_csv_config(pp, _dollar_dollar) + _t1767 = deconstruct_csv_storage_integration_optional(pp, _dollar_dollar) + fields1416 = (_t1766, _t1767,) + unwrapped_fields1417 = fields1416 write(pp, "(csv_config") indent_sexp!(pp) newline(pp) - field1408 = unwrapped_fields1407[1] - pretty_config_dict(pp, field1408) - field1409 = unwrapped_fields1407[2] - if !isnothing(field1409) + field1418 = unwrapped_fields1417[1] + pretty_config_dict(pp, field1418) + field1419 = unwrapped_fields1417[2] + if !isnothing(field1419) newline(pp) - opt_val1410 = field1409 - pretty__storage_integration(pp, opt_val1410) + opt_val1420 = field1419 + pretty__storage_integration(pp, opt_val1420) end dedent!(pp) write(pp, ")") @@ -4016,16 +4016,16 @@ function pretty_csv_config(pp::PrettyPrinter, msg::Proto.CSVConfig) end function pretty__storage_integration(pp::PrettyPrinter, msg::Vector{Tuple{String, Proto.Value}}) - flat1413 = try_flat(pp, msg, pretty__storage_integration) - if !isnothing(flat1413) - write(pp, flat1413) + flat1423 = try_flat(pp, msg, pretty__storage_integration) + if !isnothing(flat1423) + write(pp, flat1423) return nothing else - fields1412 = msg + fields1422 = msg write(pp, "(storage_integration") indent_sexp!(pp) newline(pp) - pretty_config_dict(pp, fields1412) + pretty_config_dict(pp, fields1422) dedent!(pp) write(pp, ")") end @@ -4033,22 +4033,22 @@ function pretty__storage_integration(pp::PrettyPrinter, msg::Vector{Tuple{String end function pretty_gnf_columns(pp::PrettyPrinter, msg::Vector{Proto.GNFColumn}) - flat1417 = try_flat(pp, msg, pretty_gnf_columns) - if !isnothing(flat1417) - write(pp, flat1417) + flat1427 = try_flat(pp, msg, pretty_gnf_columns) + if !isnothing(flat1427) + write(pp, flat1427) return nothing else - fields1414 = msg + fields1424 = msg write(pp, "(columns") indent_sexp!(pp) - if !isempty(fields1414) + if !isempty(fields1424) newline(pp) - for (i1748, elem1415) in enumerate(fields1414) - i1416 = i1748 - 1 - if (i1416 > 0) + for (i1768, elem1425) in enumerate(fields1424) + i1426 = i1768 - 1 + if (i1426 > 0) newline(pp) end - pretty_gnf_column(pp, elem1415) + pretty_gnf_column(pp, elem1425) end end dedent!(pp) @@ -4058,39 +4058,39 @@ function pretty_gnf_columns(pp::PrettyPrinter, msg::Vector{Proto.GNFColumn}) end function pretty_gnf_column(pp::PrettyPrinter, msg::Proto.GNFColumn) - flat1426 = try_flat(pp, msg, pretty_gnf_column) - if !isnothing(flat1426) - write(pp, flat1426) + flat1436 = try_flat(pp, msg, pretty_gnf_column) + if !isnothing(flat1436) + write(pp, flat1436) return nothing else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("target_id")) - _t1749 = _dollar_dollar.target_id + _t1769 = _dollar_dollar.target_id else - _t1749 = nothing + _t1769 = nothing end - fields1418 = (_dollar_dollar.column_path, _t1749, _dollar_dollar.types,) - unwrapped_fields1419 = fields1418 + fields1428 = (_dollar_dollar.column_path, _t1769, _dollar_dollar.types,) + unwrapped_fields1429 = fields1428 write(pp, "(column") indent_sexp!(pp) newline(pp) - field1420 = unwrapped_fields1419[1] - pretty_gnf_column_path(pp, field1420) - field1421 = unwrapped_fields1419[2] - if !isnothing(field1421) + field1430 = unwrapped_fields1429[1] + pretty_gnf_column_path(pp, field1430) + field1431 = unwrapped_fields1429[2] + if !isnothing(field1431) newline(pp) - opt_val1422 = field1421 - pretty_relation_id(pp, opt_val1422) + opt_val1432 = field1431 + pretty_relation_id(pp, opt_val1432) end newline(pp) write(pp, "[") - field1423 = unwrapped_fields1419[3] - for (i1750, elem1424) in enumerate(field1423) - i1425 = i1750 - 1 - if (i1425 > 0) + field1433 = unwrapped_fields1429[3] + for (i1770, elem1434) in enumerate(field1433) + i1435 = i1770 - 1 + if (i1435 > 0) newline(pp) end - pretty_type(pp, elem1424) + pretty_type(pp, elem1434) end write(pp, "]") dedent!(pp) @@ -4100,39 +4100,39 @@ function pretty_gnf_column(pp::PrettyPrinter, msg::Proto.GNFColumn) end function pretty_gnf_column_path(pp::PrettyPrinter, msg::Vector{String}) - flat1433 = try_flat(pp, msg, pretty_gnf_column_path) - if !isnothing(flat1433) - write(pp, flat1433) + flat1443 = try_flat(pp, msg, pretty_gnf_column_path) + if !isnothing(flat1443) + write(pp, flat1443) return nothing else _dollar_dollar = msg if length(_dollar_dollar) == 1 - _t1751 = _dollar_dollar[1] + _t1771 = _dollar_dollar[1] else - _t1751 = nothing + _t1771 = nothing end - deconstruct_result1431 = _t1751 - if !isnothing(deconstruct_result1431) - unwrapped1432 = deconstruct_result1431 - write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, unwrapped1432)) + deconstruct_result1441 = _t1771 + if !isnothing(deconstruct_result1441) + unwrapped1442 = deconstruct_result1441 + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, unwrapped1442)) else _dollar_dollar = msg if length(_dollar_dollar) != 1 - _t1752 = _dollar_dollar + _t1772 = _dollar_dollar else - _t1752 = nothing + _t1772 = nothing end - deconstruct_result1427 = _t1752 - if !isnothing(deconstruct_result1427) - unwrapped1428 = deconstruct_result1427 + deconstruct_result1437 = _t1772 + if !isnothing(deconstruct_result1437) + unwrapped1438 = deconstruct_result1437 write(pp, "[") indent!(pp) - for (i1753, elem1429) in enumerate(unwrapped1428) - i1430 = i1753 - 1 - if (i1430 > 0) + for (i1773, elem1439) in enumerate(unwrapped1438) + i1440 = i1773 - 1 + if (i1440 > 0) newline(pp) end - write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, elem1429)) + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, elem1439)) end dedent!(pp) write(pp, "]") @@ -4145,16 +4145,16 @@ function pretty_gnf_column_path(pp::PrettyPrinter, msg::Vector{String}) end function pretty_csv_asof(pp::PrettyPrinter, msg::String) - flat1435 = try_flat(pp, msg, pretty_csv_asof) - if !isnothing(flat1435) - write(pp, flat1435) + flat1445 = try_flat(pp, msg, pretty_csv_asof) + if !isnothing(flat1445) + write(pp, flat1445) return nothing else - fields1434 = msg + fields1444 = msg write(pp, "(asof") indent_sexp!(pp) newline(pp) - write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, fields1434)) + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, fields1444)) dedent!(pp) write(pp, ")") end @@ -4162,42 +4162,42 @@ function pretty_csv_asof(pp::PrettyPrinter, msg::String) end function pretty_iceberg_data(pp::PrettyPrinter, msg::Proto.IcebergData) - flat1446 = try_flat(pp, msg, pretty_iceberg_data) - if !isnothing(flat1446) - write(pp, flat1446) + flat1456 = try_flat(pp, msg, pretty_iceberg_data) + if !isnothing(flat1456) + write(pp, flat1456) return nothing else _dollar_dollar = msg - _t1754 = deconstruct_iceberg_data_from_snapshot_optional(pp, _dollar_dollar) - _t1755 = deconstruct_iceberg_data_to_snapshot_optional(pp, _dollar_dollar) - fields1436 = (_dollar_dollar.locator, _dollar_dollar.config, _dollar_dollar.columns, _t1754, _t1755, _dollar_dollar.returns_delta,) - unwrapped_fields1437 = fields1436 + _t1774 = deconstruct_iceberg_data_from_snapshot_optional(pp, _dollar_dollar) + _t1775 = deconstruct_iceberg_data_to_snapshot_optional(pp, _dollar_dollar) + fields1446 = (_dollar_dollar.locator, _dollar_dollar.config, _dollar_dollar.columns, _t1774, _t1775, _dollar_dollar.returns_delta,) + unwrapped_fields1447 = fields1446 write(pp, "(iceberg_data") indent_sexp!(pp) newline(pp) - field1438 = unwrapped_fields1437[1] - pretty_iceberg_locator(pp, field1438) + field1448 = unwrapped_fields1447[1] + pretty_iceberg_locator(pp, field1448) newline(pp) - field1439 = unwrapped_fields1437[2] - pretty_iceberg_catalog_config(pp, field1439) + field1449 = unwrapped_fields1447[2] + pretty_iceberg_catalog_config(pp, field1449) newline(pp) - field1440 = unwrapped_fields1437[3] - pretty_gnf_columns(pp, field1440) - field1441 = unwrapped_fields1437[4] - if !isnothing(field1441) + field1450 = unwrapped_fields1447[3] + pretty_gnf_columns(pp, field1450) + field1451 = unwrapped_fields1447[4] + if !isnothing(field1451) newline(pp) - opt_val1442 = field1441 - pretty_iceberg_from_snapshot(pp, opt_val1442) + opt_val1452 = field1451 + pretty_iceberg_from_snapshot(pp, opt_val1452) end - field1443 = unwrapped_fields1437[5] - if !isnothing(field1443) + field1453 = unwrapped_fields1447[5] + if !isnothing(field1453) newline(pp) - opt_val1444 = field1443 - pretty_iceberg_to_snapshot(pp, opt_val1444) + opt_val1454 = field1453 + pretty_iceberg_to_snapshot(pp, opt_val1454) end newline(pp) - field1445 = unwrapped_fields1437[6] - pretty_boolean_value(pp, field1445) + field1455 = unwrapped_fields1447[6] + pretty_boolean_value(pp, field1455) dedent!(pp) write(pp, ")") end @@ -4205,25 +4205,25 @@ function pretty_iceberg_data(pp::PrettyPrinter, msg::Proto.IcebergData) end function pretty_iceberg_locator(pp::PrettyPrinter, msg::Proto.IcebergLocator) - flat1452 = try_flat(pp, msg, pretty_iceberg_locator) - if !isnothing(flat1452) - write(pp, flat1452) + flat1462 = try_flat(pp, msg, pretty_iceberg_locator) + if !isnothing(flat1462) + write(pp, flat1462) return nothing else _dollar_dollar = msg - fields1447 = (_dollar_dollar.table_name, _dollar_dollar.namespace, _dollar_dollar.warehouse,) - unwrapped_fields1448 = fields1447 + fields1457 = (_dollar_dollar.table_name, _dollar_dollar.namespace, _dollar_dollar.warehouse,) + unwrapped_fields1458 = fields1457 write(pp, "(iceberg_locator") indent_sexp!(pp) newline(pp) - field1449 = unwrapped_fields1448[1] - pretty_iceberg_locator_table_name(pp, field1449) + field1459 = unwrapped_fields1458[1] + pretty_iceberg_locator_table_name(pp, field1459) newline(pp) - field1450 = unwrapped_fields1448[2] - pretty_iceberg_locator_namespace(pp, field1450) + field1460 = unwrapped_fields1458[2] + pretty_iceberg_locator_namespace(pp, field1460) newline(pp) - field1451 = unwrapped_fields1448[3] - pretty_iceberg_locator_warehouse(pp, field1451) + field1461 = unwrapped_fields1458[3] + pretty_iceberg_locator_warehouse(pp, field1461) dedent!(pp) write(pp, ")") end @@ -4231,16 +4231,16 @@ function pretty_iceberg_locator(pp::PrettyPrinter, msg::Proto.IcebergLocator) end function pretty_iceberg_locator_table_name(pp::PrettyPrinter, msg::String) - flat1454 = try_flat(pp, msg, pretty_iceberg_locator_table_name) - if !isnothing(flat1454) - write(pp, flat1454) + flat1464 = try_flat(pp, msg, pretty_iceberg_locator_table_name) + if !isnothing(flat1464) + write(pp, flat1464) return nothing else - fields1453 = msg + fields1463 = msg write(pp, "(table_name") indent_sexp!(pp) newline(pp) - write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, fields1453)) + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, fields1463)) dedent!(pp) write(pp, ")") end @@ -4248,22 +4248,22 @@ function pretty_iceberg_locator_table_name(pp::PrettyPrinter, msg::String) end function pretty_iceberg_locator_namespace(pp::PrettyPrinter, msg::Vector{String}) - flat1458 = try_flat(pp, msg, pretty_iceberg_locator_namespace) - if !isnothing(flat1458) - write(pp, flat1458) + flat1468 = try_flat(pp, msg, pretty_iceberg_locator_namespace) + if !isnothing(flat1468) + write(pp, flat1468) return nothing else - fields1455 = msg + fields1465 = msg write(pp, "(namespace") indent_sexp!(pp) - if !isempty(fields1455) + if !isempty(fields1465) newline(pp) - for (i1756, elem1456) in enumerate(fields1455) - i1457 = i1756 - 1 - if (i1457 > 0) + for (i1776, elem1466) in enumerate(fields1465) + i1467 = i1776 - 1 + if (i1467 > 0) newline(pp) end - write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, elem1456)) + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, elem1466)) end end dedent!(pp) @@ -4273,16 +4273,16 @@ function pretty_iceberg_locator_namespace(pp::PrettyPrinter, msg::Vector{String} end function pretty_iceberg_locator_warehouse(pp::PrettyPrinter, msg::String) - flat1460 = try_flat(pp, msg, pretty_iceberg_locator_warehouse) - if !isnothing(flat1460) - write(pp, flat1460) + flat1470 = try_flat(pp, msg, pretty_iceberg_locator_warehouse) + if !isnothing(flat1470) + write(pp, flat1470) return nothing else - fields1459 = msg + fields1469 = msg write(pp, "(warehouse") indent_sexp!(pp) newline(pp) - write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, fields1459)) + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, fields1469)) dedent!(pp) write(pp, ")") end @@ -4290,32 +4290,32 @@ function pretty_iceberg_locator_warehouse(pp::PrettyPrinter, msg::String) end function pretty_iceberg_catalog_config(pp::PrettyPrinter, msg::Proto.IcebergCatalogConfig) - flat1468 = try_flat(pp, msg, pretty_iceberg_catalog_config) - if !isnothing(flat1468) - write(pp, flat1468) + flat1478 = try_flat(pp, msg, pretty_iceberg_catalog_config) + if !isnothing(flat1478) + write(pp, flat1478) return nothing else _dollar_dollar = msg - _t1757 = deconstruct_iceberg_catalog_config_scope_optional(pp, _dollar_dollar) - fields1461 = (_dollar_dollar.catalog_uri, _t1757, sort([(k, v) for (k, v) in _dollar_dollar.properties]), sort([(k, v) for (k, v) in _dollar_dollar.auth_properties]),) - unwrapped_fields1462 = fields1461 + _t1777 = deconstruct_iceberg_catalog_config_scope_optional(pp, _dollar_dollar) + fields1471 = (_dollar_dollar.catalog_uri, _t1777, sort([(k, v) for (k, v) in _dollar_dollar.properties]), sort([(k, v) for (k, v) in _dollar_dollar.auth_properties]),) + unwrapped_fields1472 = fields1471 write(pp, "(iceberg_catalog_config") indent_sexp!(pp) newline(pp) - field1463 = unwrapped_fields1462[1] - pretty_iceberg_catalog_uri(pp, field1463) - field1464 = unwrapped_fields1462[2] - if !isnothing(field1464) + field1473 = unwrapped_fields1472[1] + pretty_iceberg_catalog_uri(pp, field1473) + field1474 = unwrapped_fields1472[2] + if !isnothing(field1474) newline(pp) - opt_val1465 = field1464 - pretty_iceberg_catalog_config_scope(pp, opt_val1465) + opt_val1475 = field1474 + pretty_iceberg_catalog_config_scope(pp, opt_val1475) end newline(pp) - field1466 = unwrapped_fields1462[3] - pretty_iceberg_properties(pp, field1466) + field1476 = unwrapped_fields1472[3] + pretty_iceberg_properties(pp, field1476) newline(pp) - field1467 = unwrapped_fields1462[4] - pretty_iceberg_auth_properties(pp, field1467) + field1477 = unwrapped_fields1472[4] + pretty_iceberg_auth_properties(pp, field1477) dedent!(pp) write(pp, ")") end @@ -4323,16 +4323,16 @@ function pretty_iceberg_catalog_config(pp::PrettyPrinter, msg::Proto.IcebergCata end function pretty_iceberg_catalog_uri(pp::PrettyPrinter, msg::String) - flat1470 = try_flat(pp, msg, pretty_iceberg_catalog_uri) - if !isnothing(flat1470) - write(pp, flat1470) + flat1480 = try_flat(pp, msg, pretty_iceberg_catalog_uri) + if !isnothing(flat1480) + write(pp, flat1480) return nothing else - fields1469 = msg + fields1479 = msg write(pp, "(catalog_uri") indent_sexp!(pp) newline(pp) - write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, fields1469)) + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, fields1479)) dedent!(pp) write(pp, ")") end @@ -4340,16 +4340,16 @@ function pretty_iceberg_catalog_uri(pp::PrettyPrinter, msg::String) end function pretty_iceberg_catalog_config_scope(pp::PrettyPrinter, msg::String) - flat1472 = try_flat(pp, msg, pretty_iceberg_catalog_config_scope) - if !isnothing(flat1472) - write(pp, flat1472) + flat1482 = try_flat(pp, msg, pretty_iceberg_catalog_config_scope) + if !isnothing(flat1482) + write(pp, flat1482) return nothing else - fields1471 = msg + fields1481 = msg write(pp, "(scope") indent_sexp!(pp) newline(pp) - write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, fields1471)) + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, fields1481)) dedent!(pp) write(pp, ")") end @@ -4357,22 +4357,22 @@ function pretty_iceberg_catalog_config_scope(pp::PrettyPrinter, msg::String) end function pretty_iceberg_properties(pp::PrettyPrinter, msg::Vector{Tuple{String, String}}) - flat1476 = try_flat(pp, msg, pretty_iceberg_properties) - if !isnothing(flat1476) - write(pp, flat1476) + flat1486 = try_flat(pp, msg, pretty_iceberg_properties) + if !isnothing(flat1486) + write(pp, flat1486) return nothing else - fields1473 = msg + fields1483 = msg write(pp, "(properties") indent_sexp!(pp) - if !isempty(fields1473) + if !isempty(fields1483) newline(pp) - for (i1758, elem1474) in enumerate(fields1473) - i1475 = i1758 - 1 - if (i1475 > 0) + for (i1778, elem1484) in enumerate(fields1483) + i1485 = i1778 - 1 + if (i1485 > 0) newline(pp) end - pretty_iceberg_property_entry(pp, elem1474) + pretty_iceberg_property_entry(pp, elem1484) end end dedent!(pp) @@ -4382,22 +4382,22 @@ function pretty_iceberg_properties(pp::PrettyPrinter, msg::Vector{Tuple{String, end function pretty_iceberg_property_entry(pp::PrettyPrinter, msg::Tuple{String, String}) - flat1481 = try_flat(pp, msg, pretty_iceberg_property_entry) - if !isnothing(flat1481) - write(pp, flat1481) + flat1491 = try_flat(pp, msg, pretty_iceberg_property_entry) + if !isnothing(flat1491) + write(pp, flat1491) return nothing else _dollar_dollar = msg - fields1477 = (_dollar_dollar[1], _dollar_dollar[2],) - unwrapped_fields1478 = fields1477 + fields1487 = (_dollar_dollar[1], _dollar_dollar[2],) + unwrapped_fields1488 = fields1487 write(pp, "(prop") indent_sexp!(pp) newline(pp) - field1479 = unwrapped_fields1478[1] - write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, field1479)) + field1489 = unwrapped_fields1488[1] + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, field1489)) newline(pp) - field1480 = unwrapped_fields1478[2] - write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, field1480)) + field1490 = unwrapped_fields1488[2] + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, field1490)) dedent!(pp) write(pp, ")") end @@ -4405,22 +4405,22 @@ function pretty_iceberg_property_entry(pp::PrettyPrinter, msg::Tuple{String, Str end function pretty_iceberg_auth_properties(pp::PrettyPrinter, msg::Vector{Tuple{String, String}}) - flat1485 = try_flat(pp, msg, pretty_iceberg_auth_properties) - if !isnothing(flat1485) - write(pp, flat1485) + flat1495 = try_flat(pp, msg, pretty_iceberg_auth_properties) + if !isnothing(flat1495) + write(pp, flat1495) return nothing else - fields1482 = msg + fields1492 = msg write(pp, "(auth_properties") indent_sexp!(pp) - if !isempty(fields1482) + if !isempty(fields1492) newline(pp) - for (i1759, elem1483) in enumerate(fields1482) - i1484 = i1759 - 1 - if (i1484 > 0) + for (i1779, elem1493) in enumerate(fields1492) + i1494 = i1779 - 1 + if (i1494 > 0) newline(pp) end - pretty_iceberg_masked_property_entry(pp, elem1483) + pretty_iceberg_masked_property_entry(pp, elem1493) end end dedent!(pp) @@ -4430,23 +4430,23 @@ function pretty_iceberg_auth_properties(pp::PrettyPrinter, msg::Vector{Tuple{Str end function pretty_iceberg_masked_property_entry(pp::PrettyPrinter, msg::Tuple{String, String}) - flat1490 = try_flat(pp, msg, pretty_iceberg_masked_property_entry) - if !isnothing(flat1490) - write(pp, flat1490) + flat1500 = try_flat(pp, msg, pretty_iceberg_masked_property_entry) + if !isnothing(flat1500) + write(pp, flat1500) return nothing else _dollar_dollar = msg - _t1760 = mask_secret_value(pp, _dollar_dollar) - fields1486 = (_dollar_dollar[1], _t1760,) - unwrapped_fields1487 = fields1486 + _t1780 = mask_secret_value(pp, _dollar_dollar) + fields1496 = (_dollar_dollar[1], _t1780,) + unwrapped_fields1497 = fields1496 write(pp, "(prop") indent_sexp!(pp) newline(pp) - field1488 = unwrapped_fields1487[1] - write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, field1488)) + field1498 = unwrapped_fields1497[1] + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, field1498)) newline(pp) - field1489 = unwrapped_fields1487[2] - write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, field1489)) + field1499 = unwrapped_fields1497[2] + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, field1499)) dedent!(pp) write(pp, ")") end @@ -4454,16 +4454,16 @@ function pretty_iceberg_masked_property_entry(pp::PrettyPrinter, msg::Tuple{Stri end function pretty_iceberg_from_snapshot(pp::PrettyPrinter, msg::String) - flat1492 = try_flat(pp, msg, pretty_iceberg_from_snapshot) - if !isnothing(flat1492) - write(pp, flat1492) + flat1502 = try_flat(pp, msg, pretty_iceberg_from_snapshot) + if !isnothing(flat1502) + write(pp, flat1502) return nothing else - fields1491 = msg + fields1501 = msg write(pp, "(from_snapshot") indent_sexp!(pp) newline(pp) - write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, fields1491)) + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, fields1501)) dedent!(pp) write(pp, ")") end @@ -4471,16 +4471,16 @@ function pretty_iceberg_from_snapshot(pp::PrettyPrinter, msg::String) end function pretty_iceberg_to_snapshot(pp::PrettyPrinter, msg::String) - flat1494 = try_flat(pp, msg, pretty_iceberg_to_snapshot) - if !isnothing(flat1494) - write(pp, flat1494) + flat1504 = try_flat(pp, msg, pretty_iceberg_to_snapshot) + if !isnothing(flat1504) + write(pp, flat1504) return nothing else - fields1493 = msg + fields1503 = msg write(pp, "(to_snapshot") indent_sexp!(pp) newline(pp) - write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, fields1493)) + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, fields1503)) dedent!(pp) write(pp, ")") end @@ -4488,18 +4488,18 @@ function pretty_iceberg_to_snapshot(pp::PrettyPrinter, msg::String) end function pretty_undefine(pp::PrettyPrinter, msg::Proto.Undefine) - flat1497 = try_flat(pp, msg, pretty_undefine) - if !isnothing(flat1497) - write(pp, flat1497) + flat1507 = try_flat(pp, msg, pretty_undefine) + if !isnothing(flat1507) + write(pp, flat1507) return nothing else _dollar_dollar = msg - fields1495 = _dollar_dollar.fragment_id - unwrapped_fields1496 = fields1495 + fields1505 = _dollar_dollar.fragment_id + unwrapped_fields1506 = fields1505 write(pp, "(undefine") indent_sexp!(pp) newline(pp) - pretty_fragment_id(pp, unwrapped_fields1496) + pretty_fragment_id(pp, unwrapped_fields1506) dedent!(pp) write(pp, ")") end @@ -4507,24 +4507,24 @@ function pretty_undefine(pp::PrettyPrinter, msg::Proto.Undefine) end function pretty_context(pp::PrettyPrinter, msg::Proto.Context) - flat1502 = try_flat(pp, msg, pretty_context) - if !isnothing(flat1502) - write(pp, flat1502) + flat1512 = try_flat(pp, msg, pretty_context) + if !isnothing(flat1512) + write(pp, flat1512) return nothing else _dollar_dollar = msg - fields1498 = _dollar_dollar.relations - unwrapped_fields1499 = fields1498 + fields1508 = _dollar_dollar.relations + unwrapped_fields1509 = fields1508 write(pp, "(context") indent_sexp!(pp) - if !isempty(unwrapped_fields1499) + if !isempty(unwrapped_fields1509) newline(pp) - for (i1761, elem1500) in enumerate(unwrapped_fields1499) - i1501 = i1761 - 1 - if (i1501 > 0) + for (i1781, elem1510) in enumerate(unwrapped_fields1509) + i1511 = i1781 - 1 + if (i1511 > 0) newline(pp) end - pretty_relation_id(pp, elem1500) + pretty_relation_id(pp, elem1510) end end dedent!(pp) @@ -4534,28 +4534,28 @@ function pretty_context(pp::PrettyPrinter, msg::Proto.Context) end function pretty_snapshot(pp::PrettyPrinter, msg::Proto.Snapshot) - flat1509 = try_flat(pp, msg, pretty_snapshot) - if !isnothing(flat1509) - write(pp, flat1509) + flat1519 = try_flat(pp, msg, pretty_snapshot) + if !isnothing(flat1519) + write(pp, flat1519) return nothing else _dollar_dollar = msg - fields1503 = (_dollar_dollar.prefix, _dollar_dollar.mappings,) - unwrapped_fields1504 = fields1503 + fields1513 = (_dollar_dollar.prefix, _dollar_dollar.mappings,) + unwrapped_fields1514 = fields1513 write(pp, "(snapshot") indent_sexp!(pp) newline(pp) - field1505 = unwrapped_fields1504[1] - pretty_edb_path(pp, field1505) - field1506 = unwrapped_fields1504[2] - if !isempty(field1506) + field1515 = unwrapped_fields1514[1] + pretty_edb_path(pp, field1515) + field1516 = unwrapped_fields1514[2] + if !isempty(field1516) newline(pp) - for (i1762, elem1507) in enumerate(field1506) - i1508 = i1762 - 1 - if (i1508 > 0) + for (i1782, elem1517) in enumerate(field1516) + i1518 = i1782 - 1 + if (i1518 > 0) newline(pp) end - pretty_snapshot_mapping(pp, elem1507) + pretty_snapshot_mapping(pp, elem1517) end end dedent!(pp) @@ -4565,40 +4565,40 @@ function pretty_snapshot(pp::PrettyPrinter, msg::Proto.Snapshot) end function pretty_snapshot_mapping(pp::PrettyPrinter, msg::Proto.SnapshotMapping) - flat1514 = try_flat(pp, msg, pretty_snapshot_mapping) - if !isnothing(flat1514) - write(pp, flat1514) + flat1524 = try_flat(pp, msg, pretty_snapshot_mapping) + if !isnothing(flat1524) + write(pp, flat1524) return nothing else _dollar_dollar = msg - fields1510 = (_dollar_dollar.destination_path, _dollar_dollar.source_relation,) - unwrapped_fields1511 = fields1510 - field1512 = unwrapped_fields1511[1] - pretty_edb_path(pp, field1512) + fields1520 = (_dollar_dollar.destination_path, _dollar_dollar.source_relation,) + unwrapped_fields1521 = fields1520 + field1522 = unwrapped_fields1521[1] + pretty_edb_path(pp, field1522) write(pp, " ") - field1513 = unwrapped_fields1511[2] - pretty_relation_id(pp, field1513) + field1523 = unwrapped_fields1521[2] + pretty_relation_id(pp, field1523) end return nothing end function pretty_epoch_reads(pp::PrettyPrinter, msg::Vector{Proto.Read}) - flat1518 = try_flat(pp, msg, pretty_epoch_reads) - if !isnothing(flat1518) - write(pp, flat1518) + flat1528 = try_flat(pp, msg, pretty_epoch_reads) + if !isnothing(flat1528) + write(pp, flat1528) return nothing else - fields1515 = msg + fields1525 = msg write(pp, "(reads") indent_sexp!(pp) - if !isempty(fields1515) + if !isempty(fields1525) newline(pp) - for (i1763, elem1516) in enumerate(fields1515) - i1517 = i1763 - 1 - if (i1517 > 0) + for (i1783, elem1526) in enumerate(fields1525) + i1527 = i1783 - 1 + if (i1527 > 0) newline(pp) end - pretty_read(pp, elem1516) + pretty_read(pp, elem1526) end end dedent!(pp) @@ -4608,67 +4608,79 @@ function pretty_epoch_reads(pp::PrettyPrinter, msg::Vector{Proto.Read}) end function pretty_read(pp::PrettyPrinter, msg::Proto.Read) - flat1529 = try_flat(pp, msg, pretty_read) - if !isnothing(flat1529) - write(pp, flat1529) + flat1541 = try_flat(pp, msg, pretty_read) + if !isnothing(flat1541) + write(pp, flat1541) return nothing else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("demand")) - _t1764 = _get_oneof_field(_dollar_dollar, :demand) + _t1784 = _get_oneof_field(_dollar_dollar, :demand) else - _t1764 = nothing + _t1784 = nothing end - deconstruct_result1527 = _t1764 - if !isnothing(deconstruct_result1527) - unwrapped1528 = deconstruct_result1527 - pretty_demand(pp, unwrapped1528) + deconstruct_result1539 = _t1784 + if !isnothing(deconstruct_result1539) + unwrapped1540 = deconstruct_result1539 + pretty_demand(pp, unwrapped1540) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("output")) - _t1765 = _get_oneof_field(_dollar_dollar, :output) + _t1785 = _get_oneof_field(_dollar_dollar, :output) else - _t1765 = nothing + _t1785 = nothing end - deconstruct_result1525 = _t1765 - if !isnothing(deconstruct_result1525) - unwrapped1526 = deconstruct_result1525 - pretty_output(pp, unwrapped1526) + deconstruct_result1537 = _t1785 + if !isnothing(deconstruct_result1537) + unwrapped1538 = deconstruct_result1537 + pretty_output(pp, unwrapped1538) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("what_if")) - _t1766 = _get_oneof_field(_dollar_dollar, :what_if) + _t1786 = _get_oneof_field(_dollar_dollar, :what_if) else - _t1766 = nothing + _t1786 = nothing end - deconstruct_result1523 = _t1766 - if !isnothing(deconstruct_result1523) - unwrapped1524 = deconstruct_result1523 - pretty_what_if(pp, unwrapped1524) + deconstruct_result1535 = _t1786 + if !isnothing(deconstruct_result1535) + unwrapped1536 = deconstruct_result1535 + pretty_what_if(pp, unwrapped1536) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("abort")) - _t1767 = _get_oneof_field(_dollar_dollar, :abort) + _t1787 = _get_oneof_field(_dollar_dollar, :abort) else - _t1767 = nothing + _t1787 = nothing end - deconstruct_result1521 = _t1767 - if !isnothing(deconstruct_result1521) - unwrapped1522 = deconstruct_result1521 - pretty_abort(pp, unwrapped1522) + deconstruct_result1533 = _t1787 + if !isnothing(deconstruct_result1533) + unwrapped1534 = deconstruct_result1533 + pretty_abort(pp, unwrapped1534) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("#export")) - _t1768 = _get_oneof_field(_dollar_dollar, :var"#export") + _t1788 = _get_oneof_field(_dollar_dollar, :var"#export") else - _t1768 = nothing + _t1788 = nothing end - deconstruct_result1519 = _t1768 - if !isnothing(deconstruct_result1519) - unwrapped1520 = deconstruct_result1519 - pretty_export(pp, unwrapped1520) + deconstruct_result1531 = _t1788 + if !isnothing(deconstruct_result1531) + unwrapped1532 = deconstruct_result1531 + pretty_export(pp, unwrapped1532) else - throw(ParseError("No matching rule for read")) + _dollar_dollar = msg + if _has_proto_field(_dollar_dollar, Symbol("export_output")) + _t1789 = _get_oneof_field(_dollar_dollar, :export_output) + else + _t1789 = nothing + end + deconstruct_result1529 = _t1789 + if !isnothing(deconstruct_result1529) + unwrapped1530 = deconstruct_result1529 + pretty_export_output(pp, unwrapped1530) + else + throw(ParseError("No matching rule for read")) + end end end end @@ -4679,18 +4691,18 @@ function pretty_read(pp::PrettyPrinter, msg::Proto.Read) end function pretty_demand(pp::PrettyPrinter, msg::Proto.Demand) - flat1532 = try_flat(pp, msg, pretty_demand) - if !isnothing(flat1532) - write(pp, flat1532) + flat1544 = try_flat(pp, msg, pretty_demand) + if !isnothing(flat1544) + write(pp, flat1544) return nothing else _dollar_dollar = msg - fields1530 = _dollar_dollar.relation_id - unwrapped_fields1531 = fields1530 + fields1542 = _dollar_dollar.relation_id + unwrapped_fields1543 = fields1542 write(pp, "(demand") indent_sexp!(pp) newline(pp) - pretty_relation_id(pp, unwrapped_fields1531) + pretty_relation_id(pp, unwrapped_fields1543) dedent!(pp) write(pp, ")") end @@ -4698,22 +4710,22 @@ function pretty_demand(pp::PrettyPrinter, msg::Proto.Demand) end function pretty_output(pp::PrettyPrinter, msg::Proto.Output) - flat1537 = try_flat(pp, msg, pretty_output) - if !isnothing(flat1537) - write(pp, flat1537) + flat1549 = try_flat(pp, msg, pretty_output) + if !isnothing(flat1549) + write(pp, flat1549) return nothing else _dollar_dollar = msg - fields1533 = (_dollar_dollar.name, _dollar_dollar.relation_id,) - unwrapped_fields1534 = fields1533 + fields1545 = (_dollar_dollar.name, _dollar_dollar.relation_id,) + unwrapped_fields1546 = fields1545 write(pp, "(output") indent_sexp!(pp) newline(pp) - field1535 = unwrapped_fields1534[1] - pretty_name(pp, field1535) + field1547 = unwrapped_fields1546[1] + pretty_name(pp, field1547) newline(pp) - field1536 = unwrapped_fields1534[2] - pretty_relation_id(pp, field1536) + field1548 = unwrapped_fields1546[2] + pretty_relation_id(pp, field1548) dedent!(pp) write(pp, ")") end @@ -4721,22 +4733,22 @@ function pretty_output(pp::PrettyPrinter, msg::Proto.Output) end function pretty_what_if(pp::PrettyPrinter, msg::Proto.WhatIf) - flat1542 = try_flat(pp, msg, pretty_what_if) - if !isnothing(flat1542) - write(pp, flat1542) + flat1554 = try_flat(pp, msg, pretty_what_if) + if !isnothing(flat1554) + write(pp, flat1554) return nothing else _dollar_dollar = msg - fields1538 = (_dollar_dollar.branch, _dollar_dollar.epoch,) - unwrapped_fields1539 = fields1538 + fields1550 = (_dollar_dollar.branch, _dollar_dollar.epoch,) + unwrapped_fields1551 = fields1550 write(pp, "(what_if") indent_sexp!(pp) newline(pp) - field1540 = unwrapped_fields1539[1] - pretty_name(pp, field1540) + field1552 = unwrapped_fields1551[1] + pretty_name(pp, field1552) newline(pp) - field1541 = unwrapped_fields1539[2] - pretty_epoch(pp, field1541) + field1553 = unwrapped_fields1551[2] + pretty_epoch(pp, field1553) dedent!(pp) write(pp, ")") end @@ -4744,30 +4756,30 @@ function pretty_what_if(pp::PrettyPrinter, msg::Proto.WhatIf) end function pretty_abort(pp::PrettyPrinter, msg::Proto.Abort) - flat1548 = try_flat(pp, msg, pretty_abort) - if !isnothing(flat1548) - write(pp, flat1548) + flat1560 = try_flat(pp, msg, pretty_abort) + if !isnothing(flat1560) + write(pp, flat1560) return nothing else _dollar_dollar = msg if _dollar_dollar.name != "abort" - _t1769 = _dollar_dollar.name + _t1790 = _dollar_dollar.name else - _t1769 = nothing + _t1790 = nothing end - fields1543 = (_t1769, _dollar_dollar.relation_id,) - unwrapped_fields1544 = fields1543 + fields1555 = (_t1790, _dollar_dollar.relation_id,) + unwrapped_fields1556 = fields1555 write(pp, "(abort") indent_sexp!(pp) - field1545 = unwrapped_fields1544[1] - if !isnothing(field1545) + field1557 = unwrapped_fields1556[1] + if !isnothing(field1557) newline(pp) - opt_val1546 = field1545 - pretty_name(pp, opt_val1546) + opt_val1558 = field1557 + pretty_name(pp, opt_val1558) end newline(pp) - field1547 = unwrapped_fields1544[2] - pretty_relation_id(pp, field1547) + field1559 = unwrapped_fields1556[2] + pretty_relation_id(pp, field1559) dedent!(pp) write(pp, ")") end @@ -4775,40 +4787,40 @@ function pretty_abort(pp::PrettyPrinter, msg::Proto.Abort) end function pretty_export(pp::PrettyPrinter, msg::Proto.Export) - flat1553 = try_flat(pp, msg, pretty_export) - if !isnothing(flat1553) - write(pp, flat1553) + flat1565 = try_flat(pp, msg, pretty_export) + if !isnothing(flat1565) + write(pp, flat1565) return nothing else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("csv_config")) - _t1770 = _get_oneof_field(_dollar_dollar, :csv_config) + _t1791 = _get_oneof_field(_dollar_dollar, :csv_config) else - _t1770 = nothing + _t1791 = nothing end - deconstruct_result1551 = _t1770 - if !isnothing(deconstruct_result1551) - unwrapped1552 = deconstruct_result1551 + deconstruct_result1563 = _t1791 + if !isnothing(deconstruct_result1563) + unwrapped1564 = deconstruct_result1563 write(pp, "(export") indent_sexp!(pp) newline(pp) - pretty_export_csv_config(pp, unwrapped1552) + pretty_export_csv_config(pp, unwrapped1564) dedent!(pp) write(pp, ")") else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("iceberg_config")) - _t1771 = _get_oneof_field(_dollar_dollar, :iceberg_config) + _t1792 = _get_oneof_field(_dollar_dollar, :iceberg_config) else - _t1771 = nothing + _t1792 = nothing end - deconstruct_result1549 = _t1771 - if !isnothing(deconstruct_result1549) - unwrapped1550 = deconstruct_result1549 + deconstruct_result1561 = _t1792 + if !isnothing(deconstruct_result1561) + unwrapped1562 = deconstruct_result1561 write(pp, "(export_iceberg") indent_sexp!(pp) newline(pp) - pretty_export_iceberg_config(pp, unwrapped1550) + pretty_export_iceberg_config(pp, unwrapped1562) dedent!(pp) write(pp, ")") else @@ -4820,55 +4832,55 @@ function pretty_export(pp::PrettyPrinter, msg::Proto.Export) end function pretty_export_csv_config(pp::PrettyPrinter, msg::Proto.ExportCSVConfig) - flat1564 = try_flat(pp, msg, pretty_export_csv_config) - if !isnothing(flat1564) - write(pp, flat1564) + flat1576 = try_flat(pp, msg, pretty_export_csv_config) + if !isnothing(flat1576) + write(pp, flat1576) return nothing else _dollar_dollar = msg if length(_dollar_dollar.data_columns) == 0 - _t1772 = (_dollar_dollar.path, _dollar_dollar.csv_source, _dollar_dollar.csv_config,) + _t1793 = (_dollar_dollar.path, _dollar_dollar.csv_source, _dollar_dollar.csv_config,) else - _t1772 = nothing + _t1793 = nothing end - deconstruct_result1559 = _t1772 - if !isnothing(deconstruct_result1559) - unwrapped1560 = deconstruct_result1559 + deconstruct_result1571 = _t1793 + if !isnothing(deconstruct_result1571) + unwrapped1572 = deconstruct_result1571 write(pp, "(export_csv_config_v2") indent_sexp!(pp) newline(pp) - field1561 = unwrapped1560[1] - pretty_export_csv_path(pp, field1561) + field1573 = unwrapped1572[1] + pretty_export_csv_path(pp, field1573) newline(pp) - field1562 = unwrapped1560[2] - pretty_export_csv_source(pp, field1562) + field1574 = unwrapped1572[2] + pretty_export_csv_source(pp, field1574) newline(pp) - field1563 = unwrapped1560[3] - pretty_csv_config(pp, field1563) + field1575 = unwrapped1572[3] + pretty_csv_config(pp, field1575) dedent!(pp) write(pp, ")") else _dollar_dollar = msg if length(_dollar_dollar.data_columns) != 0 - _t1774 = deconstruct_export_csv_config(pp, _dollar_dollar) - _t1773 = (_dollar_dollar.path, _dollar_dollar.data_columns, _t1774,) + _t1795 = deconstruct_export_csv_config(pp, _dollar_dollar) + _t1794 = (_dollar_dollar.path, _dollar_dollar.data_columns, _t1795,) else - _t1773 = nothing + _t1794 = nothing end - deconstruct_result1554 = _t1773 - if !isnothing(deconstruct_result1554) - unwrapped1555 = deconstruct_result1554 + deconstruct_result1566 = _t1794 + if !isnothing(deconstruct_result1566) + unwrapped1567 = deconstruct_result1566 write(pp, "(export_csv_config") indent_sexp!(pp) newline(pp) - field1556 = unwrapped1555[1] - pretty_export_csv_path(pp, field1556) + field1568 = unwrapped1567[1] + pretty_export_csv_path(pp, field1568) newline(pp) - field1557 = unwrapped1555[2] - pretty_export_csv_columns_list(pp, field1557) + field1569 = unwrapped1567[2] + pretty_export_csv_columns_list(pp, field1569) newline(pp) - field1558 = unwrapped1555[3] - pretty_config_dict(pp, field1558) + field1570 = unwrapped1567[3] + pretty_config_dict(pp, field1570) dedent!(pp) write(pp, ")") else @@ -4880,16 +4892,16 @@ function pretty_export_csv_config(pp::PrettyPrinter, msg::Proto.ExportCSVConfig) end function pretty_export_csv_path(pp::PrettyPrinter, msg::String) - flat1566 = try_flat(pp, msg, pretty_export_csv_path) - if !isnothing(flat1566) - write(pp, flat1566) + flat1578 = try_flat(pp, msg, pretty_export_csv_path) + if !isnothing(flat1578) + write(pp, flat1578) return nothing else - fields1565 = msg + fields1577 = msg write(pp, "(path") indent_sexp!(pp) newline(pp) - write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, fields1565)) + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, fields1577)) dedent!(pp) write(pp, ")") end @@ -4897,30 +4909,30 @@ function pretty_export_csv_path(pp::PrettyPrinter, msg::String) end function pretty_export_csv_source(pp::PrettyPrinter, msg::Proto.ExportCSVSource) - flat1573 = try_flat(pp, msg, pretty_export_csv_source) - if !isnothing(flat1573) - write(pp, flat1573) + flat1585 = try_flat(pp, msg, pretty_export_csv_source) + if !isnothing(flat1585) + write(pp, flat1585) return nothing else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("gnf_columns")) - _t1775 = _get_oneof_field(_dollar_dollar, :gnf_columns).columns + _t1796 = _get_oneof_field(_dollar_dollar, :gnf_columns).columns else - _t1775 = nothing + _t1796 = nothing end - deconstruct_result1569 = _t1775 - if !isnothing(deconstruct_result1569) - unwrapped1570 = deconstruct_result1569 + deconstruct_result1581 = _t1796 + if !isnothing(deconstruct_result1581) + unwrapped1582 = deconstruct_result1581 write(pp, "(gnf_columns") indent_sexp!(pp) - if !isempty(unwrapped1570) + if !isempty(unwrapped1582) newline(pp) - for (i1776, elem1571) in enumerate(unwrapped1570) - i1572 = i1776 - 1 - if (i1572 > 0) + for (i1797, elem1583) in enumerate(unwrapped1582) + i1584 = i1797 - 1 + if (i1584 > 0) newline(pp) end - pretty_export_csv_column(pp, elem1571) + pretty_export_csv_column(pp, elem1583) end end dedent!(pp) @@ -4928,17 +4940,17 @@ function pretty_export_csv_source(pp::PrettyPrinter, msg::Proto.ExportCSVSource) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("table_def")) - _t1777 = _get_oneof_field(_dollar_dollar, :table_def) + _t1798 = _get_oneof_field(_dollar_dollar, :table_def) else - _t1777 = nothing + _t1798 = nothing end - deconstruct_result1567 = _t1777 - if !isnothing(deconstruct_result1567) - unwrapped1568 = deconstruct_result1567 + deconstruct_result1579 = _t1798 + if !isnothing(deconstruct_result1579) + unwrapped1580 = deconstruct_result1579 write(pp, "(table_def") indent_sexp!(pp) newline(pp) - pretty_relation_id(pp, unwrapped1568) + pretty_relation_id(pp, unwrapped1580) dedent!(pp) write(pp, ")") else @@ -4950,22 +4962,22 @@ function pretty_export_csv_source(pp::PrettyPrinter, msg::Proto.ExportCSVSource) end function pretty_export_csv_column(pp::PrettyPrinter, msg::Proto.ExportCSVColumn) - flat1578 = try_flat(pp, msg, pretty_export_csv_column) - if !isnothing(flat1578) - write(pp, flat1578) + flat1590 = try_flat(pp, msg, pretty_export_csv_column) + if !isnothing(flat1590) + write(pp, flat1590) return nothing else _dollar_dollar = msg - fields1574 = (_dollar_dollar.column_name, _dollar_dollar.column_data,) - unwrapped_fields1575 = fields1574 + fields1586 = (_dollar_dollar.column_name, _dollar_dollar.column_data,) + unwrapped_fields1587 = fields1586 write(pp, "(column") indent_sexp!(pp) newline(pp) - field1576 = unwrapped_fields1575[1] - write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, field1576)) + field1588 = unwrapped_fields1587[1] + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, field1588)) newline(pp) - field1577 = unwrapped_fields1575[2] - pretty_relation_id(pp, field1577) + field1589 = unwrapped_fields1587[2] + pretty_relation_id(pp, field1589) dedent!(pp) write(pp, ")") end @@ -4973,22 +4985,22 @@ function pretty_export_csv_column(pp::PrettyPrinter, msg::Proto.ExportCSVColumn) end function pretty_export_csv_columns_list(pp::PrettyPrinter, msg::Vector{Proto.ExportCSVColumn}) - flat1582 = try_flat(pp, msg, pretty_export_csv_columns_list) - if !isnothing(flat1582) - write(pp, flat1582) + flat1594 = try_flat(pp, msg, pretty_export_csv_columns_list) + if !isnothing(flat1594) + write(pp, flat1594) return nothing else - fields1579 = msg + fields1591 = msg write(pp, "(columns") indent_sexp!(pp) - if !isempty(fields1579) + if !isempty(fields1591) newline(pp) - for (i1778, elem1580) in enumerate(fields1579) - i1581 = i1778 - 1 - if (i1581 > 0) + for (i1799, elem1592) in enumerate(fields1591) + i1593 = i1799 - 1 + if (i1593 > 0) newline(pp) end - pretty_export_csv_column(pp, elem1580) + pretty_export_csv_column(pp, elem1592) end end dedent!(pp) @@ -4998,34 +5010,34 @@ function pretty_export_csv_columns_list(pp::PrettyPrinter, msg::Vector{Proto.Exp end function pretty_export_iceberg_config(pp::PrettyPrinter, msg::Proto.ExportIcebergConfig) - flat1591 = try_flat(pp, msg, pretty_export_iceberg_config) - if !isnothing(flat1591) - write(pp, flat1591) + flat1603 = try_flat(pp, msg, pretty_export_iceberg_config) + if !isnothing(flat1603) + write(pp, flat1603) return nothing else _dollar_dollar = msg - _t1779 = deconstruct_export_iceberg_config_optional(pp, _dollar_dollar) - fields1583 = (_dollar_dollar.locator, _dollar_dollar.config, _dollar_dollar.table_def, sort([(k, v) for (k, v) in _dollar_dollar.table_properties]), _t1779,) - unwrapped_fields1584 = fields1583 + _t1800 = deconstruct_export_iceberg_config_optional(pp, _dollar_dollar) + fields1595 = (_dollar_dollar.locator, _dollar_dollar.config, _dollar_dollar.table_def, sort([(k, v) for (k, v) in _dollar_dollar.table_properties]), _t1800,) + unwrapped_fields1596 = fields1595 write(pp, "(export_iceberg_config") indent_sexp!(pp) newline(pp) - field1585 = unwrapped_fields1584[1] - pretty_iceberg_locator(pp, field1585) + field1597 = unwrapped_fields1596[1] + pretty_iceberg_locator(pp, field1597) newline(pp) - field1586 = unwrapped_fields1584[2] - pretty_iceberg_catalog_config(pp, field1586) + field1598 = unwrapped_fields1596[2] + pretty_iceberg_catalog_config(pp, field1598) newline(pp) - field1587 = unwrapped_fields1584[3] - pretty_export_iceberg_table_def(pp, field1587) + field1599 = unwrapped_fields1596[3] + pretty_export_iceberg_table_def(pp, field1599) newline(pp) - field1588 = unwrapped_fields1584[4] - pretty_iceberg_table_properties(pp, field1588) - field1589 = unwrapped_fields1584[5] - if !isnothing(field1589) + field1600 = unwrapped_fields1596[4] + pretty_iceberg_table_properties(pp, field1600) + field1601 = unwrapped_fields1596[5] + if !isnothing(field1601) newline(pp) - opt_val1590 = field1589 - pretty_config_dict(pp, opt_val1590) + opt_val1602 = field1601 + pretty_config_dict(pp, opt_val1602) end dedent!(pp) write(pp, ")") @@ -5034,16 +5046,16 @@ function pretty_export_iceberg_config(pp::PrettyPrinter, msg::Proto.ExportIceber end function pretty_export_iceberg_table_def(pp::PrettyPrinter, msg::Proto.RelationId) - flat1593 = try_flat(pp, msg, pretty_export_iceberg_table_def) - if !isnothing(flat1593) - write(pp, flat1593) + flat1605 = try_flat(pp, msg, pretty_export_iceberg_table_def) + if !isnothing(flat1605) + write(pp, flat1605) return nothing else - fields1592 = msg + fields1604 = msg write(pp, "(table_def") indent_sexp!(pp) newline(pp) - pretty_relation_id(pp, fields1592) + pretty_relation_id(pp, fields1604) dedent!(pp) write(pp, ")") end @@ -5051,22 +5063,22 @@ function pretty_export_iceberg_table_def(pp::PrettyPrinter, msg::Proto.RelationI end function pretty_iceberg_table_properties(pp::PrettyPrinter, msg::Vector{Tuple{String, String}}) - flat1597 = try_flat(pp, msg, pretty_iceberg_table_properties) - if !isnothing(flat1597) - write(pp, flat1597) + flat1609 = try_flat(pp, msg, pretty_iceberg_table_properties) + if !isnothing(flat1609) + write(pp, flat1609) return nothing else - fields1594 = msg + fields1606 = msg write(pp, "(table_properties") indent_sexp!(pp) - if !isempty(fields1594) + if !isempty(fields1606) newline(pp) - for (i1780, elem1595) in enumerate(fields1594) - i1596 = i1780 - 1 - if (i1596 > 0) + for (i1801, elem1607) in enumerate(fields1606) + i1608 = i1801 - 1 + if (i1608 > 0) newline(pp) end - pretty_iceberg_property_entry(pp, elem1595) + pretty_iceberg_property_entry(pp, elem1607) end end dedent!(pp) @@ -5075,18 +5087,65 @@ function pretty_iceberg_table_properties(pp::PrettyPrinter, msg::Vector{Tuple{St return nothing end +function pretty_export_output(pp::PrettyPrinter, msg::Proto.ExportOutput) + flat1612 = try_flat(pp, msg, pretty_export_output) + if !isnothing(flat1612) + write(pp, flat1612) + return nothing + else + _dollar_dollar = msg + if _has_proto_field(_dollar_dollar, Symbol("csv")) + _t1802 = _get_oneof_field(_dollar_dollar, :csv) + else + _t1802 = nothing + end + fields1610 = _t1802 + unwrapped_fields1611 = fields1610 + write(pp, "(output_export") + indent_sexp!(pp) + newline(pp) + pretty_export_csv_output(pp, unwrapped_fields1611) + dedent!(pp) + write(pp, ")") + end + return nothing +end + +function pretty_export_csv_output(pp::PrettyPrinter, msg::Proto.ExportCSVOutput) + flat1617 = try_flat(pp, msg, pretty_export_csv_output) + if !isnothing(flat1617) + write(pp, flat1617) + return nothing + else + _dollar_dollar = msg + fields1613 = (_dollar_dollar.csv_source, _dollar_dollar.csv_config,) + unwrapped_fields1614 = fields1613 + write(pp, "(csv") + indent_sexp!(pp) + newline(pp) + field1615 = unwrapped_fields1614[1] + pretty_export_csv_source(pp, field1615) + newline(pp) + field1616 = unwrapped_fields1614[2] + pretty_csv_config(pp, field1616) + dedent!(pp) + write(pp, ")") + end + return nothing +end + # --- Auto-generated printers for uncovered proto types --- function pretty_debug_info(pp::PrettyPrinter, msg::Proto.DebugInfo) write(pp, "(debug_info") indent_sexp!(pp) - for (i1832, _rid) in enumerate(msg.ids) - _idx = i1832 - 1 + for (i1854, _rid) in enumerate(msg.ids) + _idx = i1854 - 1 newline(pp) write(pp, "(") - _t1833 = Proto.UInt128Value(low=_rid.id_low, high=_rid.id_high) - _pprint_dispatch(pp, _t1833) + _t1855 = Proto.UInt128Value(low=_rid.id_low, high=_rid.id_high) + _pprint_dispatch(pp, _t1855) write(pp, " ") write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, msg.orig_names[_idx + 1])) write(pp, ")") @@ -5158,8 +5217,8 @@ function pretty_functional_dependency(pp::PrettyPrinter, msg::Proto.FunctionalDe _pprint_dispatch(pp, msg.guard) newline(pp) write(pp, ":keys (") - for (i1834, _elem) in enumerate(msg.keys) - _idx = i1834 - 1 + for (i1856, _elem) in enumerate(msg.keys) + _idx = i1856 - 1 if (_idx > 0) write(pp, " ") end @@ -5168,8 +5227,8 @@ function pretty_functional_dependency(pp::PrettyPrinter, msg::Proto.FunctionalDe write(pp, ")") newline(pp) write(pp, ":values (") - for (i1835, _elem) in enumerate(msg.values) - _idx = i1835 - 1 + for (i1857, _elem) in enumerate(msg.values) + _idx = i1857 - 1 if (_idx > 0) write(pp, " ") end @@ -5223,8 +5282,8 @@ function pretty_export_csv_columns(pp::PrettyPrinter, msg::Proto.ExportCSVColumn indent_sexp!(pp) newline(pp) write(pp, ":columns (") - for (i1836, _elem) in enumerate(msg.columns) - _idx = i1836 - 1 + for (i1858, _elem) in enumerate(msg.columns) + _idx = i1858 - 1 if (_idx > 0) write(pp, " ") end @@ -5374,6 +5433,8 @@ _pprint_dispatch(pp::PrettyPrinter, x::Proto.ExportCSVSource) = pretty_export_cs _pprint_dispatch(pp::PrettyPrinter, x::Proto.ExportCSVColumn) = pretty_export_csv_column(pp, x) _pprint_dispatch(pp::PrettyPrinter, x::Vector{Proto.ExportCSVColumn}) = pretty_export_csv_columns_list(pp, x) _pprint_dispatch(pp::PrettyPrinter, x::Proto.ExportIcebergConfig) = pretty_export_iceberg_config(pp, x) +_pprint_dispatch(pp::PrettyPrinter, x::Proto.ExportOutput) = pretty_export_output(pp, x) +_pprint_dispatch(pp::PrettyPrinter, x::Proto.ExportCSVOutput) = pretty_export_csv_output(pp, x) _pprint_dispatch(pp::PrettyPrinter, x::Proto.DebugInfo) = pretty_debug_info(pp, x) _pprint_dispatch(pp::PrettyPrinter, x::Proto.BeTreeConfig) = pretty_be_tree_config(pp, x) _pprint_dispatch(pp::PrettyPrinter, x::Proto.BeTreeLocator) = pretty_be_tree_locator(pp, x) diff --git a/sdks/python/src/lqp/gen/parser.py b/sdks/python/src/lqp/gen/parser.py index 3aa748e1..02845b09 100644 --- a/sdks/python/src/lqp/gen/parser.py +++ b/sdks/python/src/lqp/gen/parser.py @@ -424,196 +424,196 @@ def relation_id_to_uint128(self, msg): def _extract_value_int32(self, value: logic_pb2.Value | None, default: int) -> int: if value is not None: assert value is not None - _t2088 = value.HasField("int32_value") + _t2113 = value.HasField("int32_value") else: - _t2088 = False - if _t2088: + _t2113 = False + if _t2113: assert value is not None return value.int32_value else: - _t2089 = None + _t2114 = None return int(default) def _extract_value_int64(self, value: logic_pb2.Value | None, default: int) -> int: if value is not None: assert value is not None - _t2090 = value.HasField("int_value") + _t2115 = value.HasField("int_value") else: - _t2090 = False - if _t2090: + _t2115 = False + if _t2115: assert value is not None return value.int_value else: - _t2091 = None + _t2116 = None return default def _extract_value_string(self, value: logic_pb2.Value | None, default: str) -> str: if value is not None: assert value is not None - _t2092 = value.HasField("string_value") + _t2117 = value.HasField("string_value") else: - _t2092 = False - if _t2092: + _t2117 = False + if _t2117: assert value is not None return value.string_value else: - _t2093 = None + _t2118 = None return default def _extract_value_boolean(self, value: logic_pb2.Value | None, default: bool) -> bool: if value is not None: assert value is not None - _t2094 = value.HasField("boolean_value") + _t2119 = value.HasField("boolean_value") else: - _t2094 = False - if _t2094: + _t2119 = False + if _t2119: assert value is not None return value.boolean_value else: - _t2095 = None + _t2120 = None return default def _extract_value_string_list(self, value: logic_pb2.Value | None, default: Sequence[str]) -> Sequence[str]: if value is not None: assert value is not None - _t2096 = value.HasField("string_value") + _t2121 = value.HasField("string_value") else: - _t2096 = False - if _t2096: + _t2121 = False + if _t2121: assert value is not None return [value.string_value] else: - _t2097 = None + _t2122 = None return default def _try_extract_value_int64(self, value: logic_pb2.Value | None) -> int | None: if value is not None: assert value is not None - _t2098 = value.HasField("int_value") + _t2123 = value.HasField("int_value") else: - _t2098 = False - if _t2098: + _t2123 = False + if _t2123: assert value is not None return value.int_value else: - _t2099 = None + _t2124 = None return None def _try_extract_value_float64(self, value: logic_pb2.Value | None) -> float | None: if value is not None: assert value is not None - _t2100 = value.HasField("float_value") + _t2125 = value.HasField("float_value") else: - _t2100 = False - if _t2100: + _t2125 = False + if _t2125: assert value is not None return value.float_value else: - _t2101 = None + _t2126 = None return None def _try_extract_value_bytes(self, value: logic_pb2.Value | None) -> bytes | None: if value is not None: assert value is not None - _t2102 = value.HasField("string_value") + _t2127 = value.HasField("string_value") else: - _t2102 = False - if _t2102: + _t2127 = False + if _t2127: assert value is not None return value.string_value.encode() else: - _t2103 = None + _t2128 = None return None def _try_extract_value_uint128(self, value: logic_pb2.Value | None) -> logic_pb2.UInt128Value | None: if value is not None: assert value is not None - _t2104 = value.HasField("uint128_value") + _t2129 = value.HasField("uint128_value") else: - _t2104 = False - if _t2104: + _t2129 = False + if _t2129: assert value is not None return value.uint128_value else: - _t2105 = None + _t2130 = None return None def construct_csv_config(self, config_dict: Sequence[tuple[str, logic_pb2.Value]], storage_integration_opt: Sequence[tuple[str, logic_pb2.Value]] | None) -> logic_pb2.CSVConfig: config = dict(config_dict) - _t2106 = self._extract_value_int32(config.get("csv_header_row"), 1) - header_row = _t2106 - _t2107 = self._extract_value_int64(config.get("csv_skip"), 0) - skip = _t2107 - _t2108 = self._extract_value_string(config.get("csv_new_line"), "") - new_line = _t2108 - _t2109 = self._extract_value_string(config.get("csv_delimiter"), ",") - delimiter = _t2109 - _t2110 = self._extract_value_string(config.get("csv_quotechar"), '"') - quotechar = _t2110 - _t2111 = self._extract_value_string(config.get("csv_escapechar"), '"') - escapechar = _t2111 - _t2112 = self._extract_value_string(config.get("csv_comment"), "") - comment = _t2112 - _t2113 = self._extract_value_string_list(config.get("csv_missing_strings"), []) - missing_strings = _t2113 - _t2114 = self._extract_value_string(config.get("csv_decimal_separator"), ".") - decimal_separator = _t2114 - _t2115 = self._extract_value_string(config.get("csv_encoding"), "utf-8") - encoding = _t2115 - _t2116 = self._extract_value_string(config.get("csv_compression"), "") - compression = _t2116 - _t2117 = self._extract_value_int64(config.get("csv_partition_size_mb"), 0) - partition_size_mb = _t2117 - _t2118 = self.construct_csv_storage_integration(storage_integration_opt) - storage_integration = _t2118 - _t2119 = logic_pb2.CSVConfig(header_row=header_row, skip=skip, new_line=new_line, delimiter=delimiter, quotechar=quotechar, escapechar=escapechar, comment=comment, missing_strings=missing_strings, decimal_separator=decimal_separator, encoding=encoding, compression=compression, partition_size_mb=partition_size_mb, storage_integration=storage_integration) - return _t2119 + _t2131 = self._extract_value_int32(config.get("csv_header_row"), 1) + header_row = _t2131 + _t2132 = self._extract_value_int64(config.get("csv_skip"), 0) + skip = _t2132 + _t2133 = self._extract_value_string(config.get("csv_new_line"), "") + new_line = _t2133 + _t2134 = self._extract_value_string(config.get("csv_delimiter"), ",") + delimiter = _t2134 + _t2135 = self._extract_value_string(config.get("csv_quotechar"), '"') + quotechar = _t2135 + _t2136 = self._extract_value_string(config.get("csv_escapechar"), '"') + escapechar = _t2136 + _t2137 = self._extract_value_string(config.get("csv_comment"), "") + comment = _t2137 + _t2138 = self._extract_value_string_list(config.get("csv_missing_strings"), []) + missing_strings = _t2138 + _t2139 = self._extract_value_string(config.get("csv_decimal_separator"), ".") + decimal_separator = _t2139 + _t2140 = self._extract_value_string(config.get("csv_encoding"), "utf-8") + encoding = _t2140 + _t2141 = self._extract_value_string(config.get("csv_compression"), "") + compression = _t2141 + _t2142 = self._extract_value_int64(config.get("csv_partition_size_mb"), 0) + partition_size_mb = _t2142 + _t2143 = self.construct_csv_storage_integration(storage_integration_opt) + storage_integration = _t2143 + _t2144 = 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 _t2144 def construct_csv_storage_integration(self, storage_integration_opt: Sequence[tuple[str, logic_pb2.Value]] | None) -> logic_pb2.StorageIntegration | None: if storage_integration_opt is None: return None else: - _t2120 = None + _t2145 = None assert storage_integration_opt is not None config = dict(storage_integration_opt) - _t2121 = self._extract_value_string(config.get("provider"), "") - _t2122 = self._extract_value_string(config.get("azure_sas_token"), "") - _t2123 = self._extract_value_string(config.get("s3_region"), "") - _t2124 = self._extract_value_string(config.get("s3_access_key_id"), "") - _t2125 = self._extract_value_string(config.get("s3_secret_access_key"), "") - _t2126 = logic_pb2.StorageIntegration(provider=_t2121, azure_sas_token=_t2122, s3_region=_t2123, s3_access_key_id=_t2124, s3_secret_access_key=_t2125) - return _t2126 + _t2146 = self._extract_value_string(config.get("provider"), "") + _t2147 = self._extract_value_string(config.get("azure_sas_token"), "") + _t2148 = self._extract_value_string(config.get("s3_region"), "") + _t2149 = self._extract_value_string(config.get("s3_access_key_id"), "") + _t2150 = self._extract_value_string(config.get("s3_secret_access_key"), "") + _t2151 = logic_pb2.StorageIntegration(provider=_t2146, azure_sas_token=_t2147, s3_region=_t2148, s3_access_key_id=_t2149, s3_secret_access_key=_t2150) + return _t2151 def construct_betree_info(self, key_types: Sequence[logic_pb2.Type], value_types: Sequence[logic_pb2.Type], config_dict: Sequence[tuple[str, logic_pb2.Value]]) -> logic_pb2.BeTreeInfo: config = dict(config_dict) - _t2127 = self._try_extract_value_float64(config.get("betree_config_epsilon")) - epsilon = _t2127 - _t2128 = self._try_extract_value_int64(config.get("betree_config_max_pivots")) - max_pivots = _t2128 - _t2129 = self._try_extract_value_int64(config.get("betree_config_max_deltas")) - max_deltas = _t2129 - _t2130 = self._try_extract_value_int64(config.get("betree_config_max_leaf")) - max_leaf = _t2130 - _t2131 = logic_pb2.BeTreeConfig(epsilon=epsilon, max_pivots=max_pivots, max_deltas=max_deltas, max_leaf=max_leaf) - storage_config = _t2131 - _t2132 = self._try_extract_value_uint128(config.get("betree_locator_root_pageid")) - root_pageid = _t2132 - _t2133 = self._try_extract_value_bytes(config.get("betree_locator_inline_data")) - inline_data = _t2133 - _t2134 = self._try_extract_value_int64(config.get("betree_locator_element_count")) - element_count = _t2134 - _t2135 = self._try_extract_value_int64(config.get("betree_locator_tree_height")) - tree_height = _t2135 - _t2136 = logic_pb2.BeTreeLocator(root_pageid=root_pageid, inline_data=inline_data, element_count=element_count, tree_height=tree_height) - relation_locator = _t2136 - _t2137 = logic_pb2.BeTreeInfo(key_types=key_types, value_types=value_types, storage_config=storage_config, relation_locator=relation_locator) - return _t2137 + _t2152 = self._try_extract_value_float64(config.get("betree_config_epsilon")) + epsilon = _t2152 + _t2153 = self._try_extract_value_int64(config.get("betree_config_max_pivots")) + max_pivots = _t2153 + _t2154 = self._try_extract_value_int64(config.get("betree_config_max_deltas")) + max_deltas = _t2154 + _t2155 = self._try_extract_value_int64(config.get("betree_config_max_leaf")) + max_leaf = _t2155 + _t2156 = logic_pb2.BeTreeConfig(epsilon=epsilon, max_pivots=max_pivots, max_deltas=max_deltas, max_leaf=max_leaf) + storage_config = _t2156 + _t2157 = self._try_extract_value_uint128(config.get("betree_locator_root_pageid")) + root_pageid = _t2157 + _t2158 = self._try_extract_value_bytes(config.get("betree_locator_inline_data")) + inline_data = _t2158 + _t2159 = self._try_extract_value_int64(config.get("betree_locator_element_count")) + element_count = _t2159 + _t2160 = self._try_extract_value_int64(config.get("betree_locator_tree_height")) + tree_height = _t2160 + _t2161 = logic_pb2.BeTreeLocator(root_pageid=root_pageid, inline_data=inline_data, element_count=element_count, tree_height=tree_height) + relation_locator = _t2161 + _t2162 = logic_pb2.BeTreeInfo(key_types=key_types, value_types=value_types, storage_config=storage_config, relation_locator=relation_locator) + return _t2162 def default_configure(self) -> transactions_pb2.Configure: - _t2138 = transactions_pb2.IVMConfig(level=transactions_pb2.MaintenanceLevel.MAINTENANCE_LEVEL_OFF) - ivm_config = _t2138 - _t2139 = transactions_pb2.Configure(semantics_version=0, ivm_config=ivm_config) - return _t2139 + _t2163 = transactions_pb2.IVMConfig(level=transactions_pb2.MaintenanceLevel.MAINTENANCE_LEVEL_OFF) + ivm_config = _t2163 + _t2164 = transactions_pb2.Configure(semantics_version=0, ivm_config=ivm_config) + return _t2164 def construct_configure(self, config_dict: Sequence[tuple[str, logic_pb2.Value]]) -> transactions_pb2.Configure: config = dict(config_dict) @@ -630,3376 +630,3413 @@ def construct_configure(self, config_dict: Sequence[tuple[str, logic_pb2.Value]] maintenance_level = transactions_pb2.MaintenanceLevel.MAINTENANCE_LEVEL_ALL else: maintenance_level = transactions_pb2.MaintenanceLevel.MAINTENANCE_LEVEL_OFF - _t2140 = transactions_pb2.IVMConfig(level=maintenance_level) - ivm_config = _t2140 - _t2141 = self._extract_value_int64(config.get("semantics_version"), 0) - semantics_version = _t2141 - _t2142 = transactions_pb2.Configure(semantics_version=semantics_version, ivm_config=ivm_config) - return _t2142 + _t2165 = transactions_pb2.IVMConfig(level=maintenance_level) + ivm_config = _t2165 + _t2166 = self._extract_value_int64(config.get("semantics_version"), 0) + semantics_version = _t2166 + _t2167 = transactions_pb2.Configure(semantics_version=semantics_version, ivm_config=ivm_config) + return _t2167 def construct_export_csv_config(self, path: str, columns: Sequence[transactions_pb2.ExportCSVColumn], config_dict: Sequence[tuple[str, logic_pb2.Value]]) -> transactions_pb2.ExportCSVConfig: config = dict(config_dict) - _t2143 = self._extract_value_int64(config.get("partition_size"), 0) - partition_size = _t2143 - _t2144 = self._extract_value_string(config.get("compression"), "") - compression = _t2144 - _t2145 = self._extract_value_boolean(config.get("syntax_header_row"), True) - syntax_header_row = _t2145 - _t2146 = self._extract_value_string(config.get("syntax_missing_string"), "") - syntax_missing_string = _t2146 - _t2147 = self._extract_value_string(config.get("syntax_delim"), ",") - syntax_delim = _t2147 - _t2148 = self._extract_value_string(config.get("syntax_quotechar"), '"') - syntax_quotechar = _t2148 - _t2149 = self._extract_value_string(config.get("syntax_escapechar"), "\\") - syntax_escapechar = _t2149 - _t2150 = transactions_pb2.ExportCSVConfig(path=path, data_columns=columns, partition_size=partition_size, compression=compression, syntax_header_row=syntax_header_row, syntax_missing_string=syntax_missing_string, syntax_delim=syntax_delim, syntax_quotechar=syntax_quotechar, syntax_escapechar=syntax_escapechar) - return _t2150 + _t2168 = self._extract_value_int64(config.get("partition_size"), 0) + partition_size = _t2168 + _t2169 = self._extract_value_string(config.get("compression"), "") + compression = _t2169 + _t2170 = self._extract_value_boolean(config.get("syntax_header_row"), True) + syntax_header_row = _t2170 + _t2171 = self._extract_value_string(config.get("syntax_missing_string"), "") + syntax_missing_string = _t2171 + _t2172 = self._extract_value_string(config.get("syntax_delim"), ",") + syntax_delim = _t2172 + _t2173 = self._extract_value_string(config.get("syntax_quotechar"), '"') + syntax_quotechar = _t2173 + _t2174 = self._extract_value_string(config.get("syntax_escapechar"), "\\") + syntax_escapechar = _t2174 + _t2175 = 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 _t2175 def construct_export_csv_config_with_source(self, path: str, csv_source: transactions_pb2.ExportCSVSource, csv_config: logic_pb2.CSVConfig) -> transactions_pb2.ExportCSVConfig: - _t2151 = transactions_pb2.ExportCSVConfig(path=path, csv_source=csv_source, csv_config=csv_config) - return _t2151 + _t2176 = transactions_pb2.ExportCSVConfig(path=path, csv_source=csv_source, csv_config=csv_config) + return _t2176 def construct_iceberg_catalog_config(self, catalog_uri: str, scope_opt: str | None, property_pairs: Sequence[tuple[str, str]], auth_property_pairs: Sequence[tuple[str, str]]) -> logic_pb2.IcebergCatalogConfig: props = dict(property_pairs) auth_props = dict(auth_property_pairs) - _t2152 = logic_pb2.IcebergCatalogConfig(catalog_uri=catalog_uri, scope=(scope_opt if scope_opt is not None else ""), properties=props, auth_properties=auth_props) - return _t2152 + _t2177 = logic_pb2.IcebergCatalogConfig(catalog_uri=catalog_uri, scope=(scope_opt if scope_opt is not None else ""), properties=props, auth_properties=auth_props) + return _t2177 def construct_iceberg_data(self, locator: logic_pb2.IcebergLocator, config: logic_pb2.IcebergCatalogConfig, columns: Sequence[logic_pb2.GNFColumn], from_snapshot_opt: str | None, to_snapshot_opt: str | None, returns_delta: bool) -> logic_pb2.IcebergData: - _t2153 = logic_pb2.IcebergData(locator=locator, config=config, columns=columns, from_snapshot=(from_snapshot_opt if from_snapshot_opt is not None else ""), to_snapshot=(to_snapshot_opt if to_snapshot_opt is not None else ""), returns_delta=returns_delta) - return _t2153 + _t2178 = 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 _t2178 def construct_export_iceberg_config_full(self, locator: logic_pb2.IcebergLocator, config: logic_pb2.IcebergCatalogConfig, table_def: logic_pb2.RelationId, table_property_pairs: Sequence[tuple[str, str]], config_dict: Sequence[tuple[str, logic_pb2.Value]] | None) -> transactions_pb2.ExportIcebergConfig: cfg = dict((config_dict if config_dict is not None else [])) - _t2154 = self._extract_value_string(cfg.get("prefix"), "") - prefix = _t2154 - _t2155 = self._extract_value_int64(cfg.get("target_file_size_bytes"), 0) - target_file_size_bytes = _t2155 - _t2156 = self._extract_value_string(cfg.get("compression"), "") - compression = _t2156 + _t2179 = self._extract_value_string(cfg.get("prefix"), "") + prefix = _t2179 + _t2180 = self._extract_value_int64(cfg.get("target_file_size_bytes"), 0) + target_file_size_bytes = _t2180 + _t2181 = self._extract_value_string(cfg.get("compression"), "") + compression = _t2181 table_props = dict(table_property_pairs) - _t2157 = transactions_pb2.ExportIcebergConfig(locator=locator, config=config, table_def=table_def, prefix=prefix, target_file_size_bytes=target_file_size_bytes, compression=compression, table_properties=table_props) - return _t2157 + _t2182 = 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 _t2182 # --- Parse methods --- def parse_transaction(self) -> transactions_pb2.Transaction: - span_start673 = self.span_start() + span_start681 = self.span_start() self.consume_literal("(") self.consume_literal("transaction") if (self.match_lookahead_literal("(", 0) and self.match_lookahead_literal("configure", 1)): - _t1335 = self.parse_configure() - _t1334 = _t1335 + _t1351 = self.parse_configure() + _t1350 = _t1351 else: - _t1334 = None - configure667 = _t1334 + _t1350 = None + configure675 = _t1350 if (self.match_lookahead_literal("(", 0) and self.match_lookahead_literal("sync", 1)): - _t1337 = self.parse_sync() - _t1336 = _t1337 - else: - _t1336 = None - sync668 = _t1336 - xs669 = [] - cond670 = self.match_lookahead_literal("(", 0) - while cond670: - _t1338 = self.parse_epoch() - item671 = _t1338 - xs669.append(item671) - cond670 = self.match_lookahead_literal("(", 0) - epochs672 = xs669 - self.consume_literal(")") - _t1339 = self.default_configure() - _t1340 = transactions_pb2.Transaction(epochs=epochs672, configure=(configure667 if configure667 is not None else _t1339), sync=sync668) - result674 = _t1340 - self.record_span(span_start673, "Transaction") - return result674 + _t1353 = self.parse_sync() + _t1352 = _t1353 + else: + _t1352 = None + sync676 = _t1352 + xs677 = [] + cond678 = self.match_lookahead_literal("(", 0) + while cond678: + _t1354 = self.parse_epoch() + item679 = _t1354 + xs677.append(item679) + cond678 = self.match_lookahead_literal("(", 0) + epochs680 = xs677 + self.consume_literal(")") + _t1355 = self.default_configure() + _t1356 = transactions_pb2.Transaction(epochs=epochs680, configure=(configure675 if configure675 is not None else _t1355), sync=sync676) + result682 = _t1356 + self.record_span(span_start681, "Transaction") + return result682 def parse_configure(self) -> transactions_pb2.Configure: - span_start676 = self.span_start() + span_start684 = self.span_start() self.consume_literal("(") self.consume_literal("configure") - _t1341 = self.parse_config_dict() - config_dict675 = _t1341 + _t1357 = self.parse_config_dict() + config_dict683 = _t1357 self.consume_literal(")") - _t1342 = self.construct_configure(config_dict675) - result677 = _t1342 - self.record_span(span_start676, "Configure") - return result677 + _t1358 = self.construct_configure(config_dict683) + result685 = _t1358 + self.record_span(span_start684, "Configure") + return result685 def parse_config_dict(self) -> Sequence[tuple[str, logic_pb2.Value]]: self.consume_literal("{") - xs678 = [] - cond679 = self.match_lookahead_literal(":", 0) - while cond679: - _t1343 = self.parse_config_key_value() - item680 = _t1343 - xs678.append(item680) - cond679 = self.match_lookahead_literal(":", 0) - config_key_values681 = xs678 + xs686 = [] + cond687 = self.match_lookahead_literal(":", 0) + while cond687: + _t1359 = self.parse_config_key_value() + item688 = _t1359 + xs686.append(item688) + cond687 = self.match_lookahead_literal(":", 0) + config_key_values689 = xs686 self.consume_literal("}") - return config_key_values681 + return config_key_values689 def parse_config_key_value(self) -> tuple[str, logic_pb2.Value]: self.consume_literal(":") - symbol682 = self.consume_terminal("SYMBOL") - _t1344 = self.parse_raw_value() - raw_value683 = _t1344 - return (symbol682, raw_value683,) + symbol690 = self.consume_terminal("SYMBOL") + _t1360 = self.parse_raw_value() + raw_value691 = _t1360 + return (symbol690, raw_value691,) def parse_raw_value(self) -> logic_pb2.Value: - span_start697 = self.span_start() + span_start705 = self.span_start() if self.match_lookahead_literal("true", 0): - _t1345 = 12 + _t1361 = 12 else: if self.match_lookahead_literal("missing", 0): - _t1346 = 11 + _t1362 = 11 else: if self.match_lookahead_literal("false", 0): - _t1347 = 12 + _t1363 = 12 else: if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("datetime", 1): - _t1349 = 1 + _t1365 = 1 else: if self.match_lookahead_literal("date", 1): - _t1350 = 0 + _t1366 = 0 else: - _t1350 = -1 - _t1349 = _t1350 - _t1348 = _t1349 + _t1366 = -1 + _t1365 = _t1366 + _t1364 = _t1365 else: if self.match_lookahead_terminal("UINT32", 0): - _t1351 = 7 + _t1367 = 7 else: if self.match_lookahead_terminal("UINT128", 0): - _t1352 = 8 + _t1368 = 8 else: if self.match_lookahead_terminal("STRING", 0): - _t1353 = 2 + _t1369 = 2 else: if self.match_lookahead_terminal("INT32", 0): - _t1354 = 3 + _t1370 = 3 else: if self.match_lookahead_terminal("INT128", 0): - _t1355 = 9 + _t1371 = 9 else: if self.match_lookahead_terminal("INT", 0): - _t1356 = 4 + _t1372 = 4 else: if self.match_lookahead_terminal("FLOAT32", 0): - _t1357 = 5 + _t1373 = 5 else: if self.match_lookahead_terminal("FLOAT", 0): - _t1358 = 6 + _t1374 = 6 else: if self.match_lookahead_terminal("DECIMAL", 0): - _t1359 = 10 + _t1375 = 10 else: - _t1359 = -1 - _t1358 = _t1359 - _t1357 = _t1358 - _t1356 = _t1357 - _t1355 = _t1356 - _t1354 = _t1355 - _t1353 = _t1354 - _t1352 = _t1353 - _t1351 = _t1352 - _t1348 = _t1351 - _t1347 = _t1348 - _t1346 = _t1347 - _t1345 = _t1346 - prediction684 = _t1345 - if prediction684 == 12: - _t1361 = self.parse_boolean_value() - boolean_value696 = _t1361 - _t1362 = logic_pb2.Value(boolean_value=boolean_value696) - _t1360 = _t1362 - else: - if prediction684 == 11: + _t1375 = -1 + _t1374 = _t1375 + _t1373 = _t1374 + _t1372 = _t1373 + _t1371 = _t1372 + _t1370 = _t1371 + _t1369 = _t1370 + _t1368 = _t1369 + _t1367 = _t1368 + _t1364 = _t1367 + _t1363 = _t1364 + _t1362 = _t1363 + _t1361 = _t1362 + prediction692 = _t1361 + if prediction692 == 12: + _t1377 = self.parse_boolean_value() + boolean_value704 = _t1377 + _t1378 = logic_pb2.Value(boolean_value=boolean_value704) + _t1376 = _t1378 + else: + if prediction692 == 11: self.consume_literal("missing") - _t1364 = logic_pb2.MissingValue() - _t1365 = logic_pb2.Value(missing_value=_t1364) - _t1363 = _t1365 + _t1380 = logic_pb2.MissingValue() + _t1381 = logic_pb2.Value(missing_value=_t1380) + _t1379 = _t1381 else: - if prediction684 == 10: - decimal695 = self.consume_terminal("DECIMAL") - _t1367 = logic_pb2.Value(decimal_value=decimal695) - _t1366 = _t1367 + if prediction692 == 10: + decimal703 = self.consume_terminal("DECIMAL") + _t1383 = logic_pb2.Value(decimal_value=decimal703) + _t1382 = _t1383 else: - if prediction684 == 9: - int128694 = self.consume_terminal("INT128") - _t1369 = logic_pb2.Value(int128_value=int128694) - _t1368 = _t1369 + if prediction692 == 9: + int128702 = self.consume_terminal("INT128") + _t1385 = logic_pb2.Value(int128_value=int128702) + _t1384 = _t1385 else: - if prediction684 == 8: - uint128693 = self.consume_terminal("UINT128") - _t1371 = logic_pb2.Value(uint128_value=uint128693) - _t1370 = _t1371 + if prediction692 == 8: + uint128701 = self.consume_terminal("UINT128") + _t1387 = logic_pb2.Value(uint128_value=uint128701) + _t1386 = _t1387 else: - if prediction684 == 7: - uint32692 = self.consume_terminal("UINT32") - _t1373 = logic_pb2.Value(uint32_value=uint32692) - _t1372 = _t1373 + if prediction692 == 7: + uint32700 = self.consume_terminal("UINT32") + _t1389 = logic_pb2.Value(uint32_value=uint32700) + _t1388 = _t1389 else: - if prediction684 == 6: - float691 = self.consume_terminal("FLOAT") - _t1375 = logic_pb2.Value(float_value=float691) - _t1374 = _t1375 + if prediction692 == 6: + float699 = self.consume_terminal("FLOAT") + _t1391 = logic_pb2.Value(float_value=float699) + _t1390 = _t1391 else: - if prediction684 == 5: - float32690 = self.consume_terminal("FLOAT32") - _t1377 = logic_pb2.Value(float32_value=float32690) - _t1376 = _t1377 + if prediction692 == 5: + float32698 = self.consume_terminal("FLOAT32") + _t1393 = logic_pb2.Value(float32_value=float32698) + _t1392 = _t1393 else: - if prediction684 == 4: - int689 = self.consume_terminal("INT") - _t1379 = logic_pb2.Value(int_value=int689) - _t1378 = _t1379 + if prediction692 == 4: + int697 = self.consume_terminal("INT") + _t1395 = logic_pb2.Value(int_value=int697) + _t1394 = _t1395 else: - if prediction684 == 3: - int32688 = self.consume_terminal("INT32") - _t1381 = logic_pb2.Value(int32_value=int32688) - _t1380 = _t1381 + if prediction692 == 3: + int32696 = self.consume_terminal("INT32") + _t1397 = logic_pb2.Value(int32_value=int32696) + _t1396 = _t1397 else: - if prediction684 == 2: - string687 = self.consume_terminal("STRING") - _t1383 = logic_pb2.Value(string_value=string687) - _t1382 = _t1383 + if prediction692 == 2: + string695 = self.consume_terminal("STRING") + _t1399 = logic_pb2.Value(string_value=string695) + _t1398 = _t1399 else: - if prediction684 == 1: - _t1385 = self.parse_raw_datetime() - raw_datetime686 = _t1385 - _t1386 = logic_pb2.Value(datetime_value=raw_datetime686) - _t1384 = _t1386 + if prediction692 == 1: + _t1401 = self.parse_raw_datetime() + raw_datetime694 = _t1401 + _t1402 = logic_pb2.Value(datetime_value=raw_datetime694) + _t1400 = _t1402 else: - if prediction684 == 0: - _t1388 = self.parse_raw_date() - raw_date685 = _t1388 - _t1389 = logic_pb2.Value(date_value=raw_date685) - _t1387 = _t1389 + if prediction692 == 0: + _t1404 = self.parse_raw_date() + raw_date693 = _t1404 + _t1405 = logic_pb2.Value(date_value=raw_date693) + _t1403 = _t1405 else: raise ParseError("Unexpected token in raw_value" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1384 = _t1387 - _t1382 = _t1384 - _t1380 = _t1382 - _t1378 = _t1380 - _t1376 = _t1378 - _t1374 = _t1376 - _t1372 = _t1374 - _t1370 = _t1372 - _t1368 = _t1370 - _t1366 = _t1368 - _t1363 = _t1366 - _t1360 = _t1363 - result698 = _t1360 - self.record_span(span_start697, "Value") - return result698 + _t1400 = _t1403 + _t1398 = _t1400 + _t1396 = _t1398 + _t1394 = _t1396 + _t1392 = _t1394 + _t1390 = _t1392 + _t1388 = _t1390 + _t1386 = _t1388 + _t1384 = _t1386 + _t1382 = _t1384 + _t1379 = _t1382 + _t1376 = _t1379 + result706 = _t1376 + self.record_span(span_start705, "Value") + return result706 def parse_raw_date(self) -> logic_pb2.DateValue: - span_start702 = self.span_start() + span_start710 = self.span_start() self.consume_literal("(") self.consume_literal("date") - int699 = self.consume_terminal("INT") - int_3700 = self.consume_terminal("INT") - int_4701 = self.consume_terminal("INT") + int707 = self.consume_terminal("INT") + int_3708 = self.consume_terminal("INT") + int_4709 = self.consume_terminal("INT") self.consume_literal(")") - _t1390 = logic_pb2.DateValue(year=int(int699), month=int(int_3700), day=int(int_4701)) - result703 = _t1390 - self.record_span(span_start702, "DateValue") - return result703 + _t1406 = logic_pb2.DateValue(year=int(int707), month=int(int_3708), day=int(int_4709)) + result711 = _t1406 + self.record_span(span_start710, "DateValue") + return result711 def parse_raw_datetime(self) -> logic_pb2.DateTimeValue: - span_start711 = self.span_start() + span_start719 = self.span_start() self.consume_literal("(") self.consume_literal("datetime") - int704 = self.consume_terminal("INT") - int_3705 = self.consume_terminal("INT") - int_4706 = self.consume_terminal("INT") - int_5707 = self.consume_terminal("INT") - int_6708 = self.consume_terminal("INT") - int_7709 = self.consume_terminal("INT") + int712 = self.consume_terminal("INT") + int_3713 = self.consume_terminal("INT") + int_4714 = self.consume_terminal("INT") + int_5715 = self.consume_terminal("INT") + int_6716 = self.consume_terminal("INT") + int_7717 = self.consume_terminal("INT") if self.match_lookahead_terminal("INT", 0): - _t1391 = self.consume_terminal("INT") + _t1407 = self.consume_terminal("INT") else: - _t1391 = None - int_8710 = _t1391 + _t1407 = None + int_8718 = _t1407 self.consume_literal(")") - _t1392 = logic_pb2.DateTimeValue(year=int(int704), month=int(int_3705), day=int(int_4706), hour=int(int_5707), minute=int(int_6708), second=int(int_7709), microsecond=int((int_8710 if int_8710 is not None else 0))) - result712 = _t1392 - self.record_span(span_start711, "DateTimeValue") - return result712 + _t1408 = logic_pb2.DateTimeValue(year=int(int712), month=int(int_3713), day=int(int_4714), hour=int(int_5715), minute=int(int_6716), second=int(int_7717), microsecond=int((int_8718 if int_8718 is not None else 0))) + result720 = _t1408 + self.record_span(span_start719, "DateTimeValue") + return result720 def parse_boolean_value(self) -> bool: if self.match_lookahead_literal("true", 0): - _t1393 = 0 + _t1409 = 0 else: if self.match_lookahead_literal("false", 0): - _t1394 = 1 + _t1410 = 1 else: - _t1394 = -1 - _t1393 = _t1394 - prediction713 = _t1393 - if prediction713 == 1: + _t1410 = -1 + _t1409 = _t1410 + prediction721 = _t1409 + if prediction721 == 1: self.consume_literal("false") - _t1395 = False + _t1411 = False else: - if prediction713 == 0: + if prediction721 == 0: self.consume_literal("true") - _t1396 = True + _t1412 = True else: raise ParseError("Unexpected token in boolean_value" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1395 = _t1396 - return _t1395 + _t1411 = _t1412 + return _t1411 def parse_sync(self) -> transactions_pb2.Sync: - span_start718 = self.span_start() + span_start726 = self.span_start() self.consume_literal("(") self.consume_literal("sync") - xs714 = [] - cond715 = self.match_lookahead_literal(":", 0) - while cond715: - _t1397 = self.parse_fragment_id() - item716 = _t1397 - xs714.append(item716) - cond715 = self.match_lookahead_literal(":", 0) - fragment_ids717 = xs714 - self.consume_literal(")") - _t1398 = transactions_pb2.Sync(fragments=fragment_ids717) - result719 = _t1398 - self.record_span(span_start718, "Sync") - return result719 + xs722 = [] + cond723 = self.match_lookahead_literal(":", 0) + while cond723: + _t1413 = self.parse_fragment_id() + item724 = _t1413 + xs722.append(item724) + cond723 = self.match_lookahead_literal(":", 0) + fragment_ids725 = xs722 + self.consume_literal(")") + _t1414 = transactions_pb2.Sync(fragments=fragment_ids725) + result727 = _t1414 + self.record_span(span_start726, "Sync") + return result727 def parse_fragment_id(self) -> fragments_pb2.FragmentId: - span_start721 = self.span_start() + span_start729 = self.span_start() self.consume_literal(":") - symbol720 = self.consume_terminal("SYMBOL") - result722 = fragments_pb2.FragmentId(id=symbol720.encode()) - self.record_span(span_start721, "FragmentId") - return result722 + symbol728 = self.consume_terminal("SYMBOL") + result730 = fragments_pb2.FragmentId(id=symbol728.encode()) + self.record_span(span_start729, "FragmentId") + return result730 def parse_epoch(self) -> transactions_pb2.Epoch: - span_start725 = self.span_start() + span_start733 = self.span_start() self.consume_literal("(") self.consume_literal("epoch") if (self.match_lookahead_literal("(", 0) and self.match_lookahead_literal("writes", 1)): - _t1400 = self.parse_epoch_writes() - _t1399 = _t1400 + _t1416 = self.parse_epoch_writes() + _t1415 = _t1416 else: - _t1399 = None - epoch_writes723 = _t1399 + _t1415 = None + epoch_writes731 = _t1415 if self.match_lookahead_literal("(", 0): - _t1402 = self.parse_epoch_reads() - _t1401 = _t1402 + _t1418 = self.parse_epoch_reads() + _t1417 = _t1418 else: - _t1401 = None - epoch_reads724 = _t1401 + _t1417 = None + epoch_reads732 = _t1417 self.consume_literal(")") - _t1403 = transactions_pb2.Epoch(writes=(epoch_writes723 if epoch_writes723 is not None else []), reads=(epoch_reads724 if epoch_reads724 is not None else [])) - result726 = _t1403 - self.record_span(span_start725, "Epoch") - return result726 + _t1419 = transactions_pb2.Epoch(writes=(epoch_writes731 if epoch_writes731 is not None else []), reads=(epoch_reads732 if epoch_reads732 is not None else [])) + result734 = _t1419 + self.record_span(span_start733, "Epoch") + return result734 def parse_epoch_writes(self) -> Sequence[transactions_pb2.Write]: self.consume_literal("(") self.consume_literal("writes") - xs727 = [] - cond728 = self.match_lookahead_literal("(", 0) - while cond728: - _t1404 = self.parse_write() - item729 = _t1404 - xs727.append(item729) - cond728 = self.match_lookahead_literal("(", 0) - writes730 = xs727 + xs735 = [] + cond736 = self.match_lookahead_literal("(", 0) + while cond736: + _t1420 = self.parse_write() + item737 = _t1420 + xs735.append(item737) + cond736 = self.match_lookahead_literal("(", 0) + writes738 = xs735 self.consume_literal(")") - return writes730 + return writes738 def parse_write(self) -> transactions_pb2.Write: - span_start736 = self.span_start() + span_start744 = self.span_start() if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("undefine", 1): - _t1406 = 1 + _t1422 = 1 else: if self.match_lookahead_literal("snapshot", 1): - _t1407 = 3 + _t1423 = 3 else: if self.match_lookahead_literal("define", 1): - _t1408 = 0 + _t1424 = 0 else: if self.match_lookahead_literal("context", 1): - _t1409 = 2 + _t1425 = 2 else: - _t1409 = -1 - _t1408 = _t1409 - _t1407 = _t1408 - _t1406 = _t1407 - _t1405 = _t1406 - else: - _t1405 = -1 - prediction731 = _t1405 - if prediction731 == 3: - _t1411 = self.parse_snapshot() - snapshot735 = _t1411 - _t1412 = transactions_pb2.Write(snapshot=snapshot735) - _t1410 = _t1412 - else: - if prediction731 == 2: - _t1414 = self.parse_context() - context734 = _t1414 - _t1415 = transactions_pb2.Write(context=context734) - _t1413 = _t1415 + _t1425 = -1 + _t1424 = _t1425 + _t1423 = _t1424 + _t1422 = _t1423 + _t1421 = _t1422 + else: + _t1421 = -1 + prediction739 = _t1421 + if prediction739 == 3: + _t1427 = self.parse_snapshot() + snapshot743 = _t1427 + _t1428 = transactions_pb2.Write(snapshot=snapshot743) + _t1426 = _t1428 + else: + if prediction739 == 2: + _t1430 = self.parse_context() + context742 = _t1430 + _t1431 = transactions_pb2.Write(context=context742) + _t1429 = _t1431 else: - if prediction731 == 1: - _t1417 = self.parse_undefine() - undefine733 = _t1417 - _t1418 = transactions_pb2.Write(undefine=undefine733) - _t1416 = _t1418 + if prediction739 == 1: + _t1433 = self.parse_undefine() + undefine741 = _t1433 + _t1434 = transactions_pb2.Write(undefine=undefine741) + _t1432 = _t1434 else: - if prediction731 == 0: - _t1420 = self.parse_define() - define732 = _t1420 - _t1421 = transactions_pb2.Write(define=define732) - _t1419 = _t1421 + if prediction739 == 0: + _t1436 = self.parse_define() + define740 = _t1436 + _t1437 = transactions_pb2.Write(define=define740) + _t1435 = _t1437 else: raise ParseError("Unexpected token in write" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1416 = _t1419 - _t1413 = _t1416 - _t1410 = _t1413 - result737 = _t1410 - self.record_span(span_start736, "Write") - return result737 + _t1432 = _t1435 + _t1429 = _t1432 + _t1426 = _t1429 + result745 = _t1426 + self.record_span(span_start744, "Write") + return result745 def parse_define(self) -> transactions_pb2.Define: - span_start739 = self.span_start() + span_start747 = self.span_start() self.consume_literal("(") self.consume_literal("define") - _t1422 = self.parse_fragment() - fragment738 = _t1422 + _t1438 = self.parse_fragment() + fragment746 = _t1438 self.consume_literal(")") - _t1423 = transactions_pb2.Define(fragment=fragment738) - result740 = _t1423 - self.record_span(span_start739, "Define") - return result740 + _t1439 = transactions_pb2.Define(fragment=fragment746) + result748 = _t1439 + self.record_span(span_start747, "Define") + return result748 def parse_fragment(self) -> fragments_pb2.Fragment: - span_start746 = self.span_start() + span_start754 = self.span_start() self.consume_literal("(") self.consume_literal("fragment") - _t1424 = self.parse_new_fragment_id() - new_fragment_id741 = _t1424 - xs742 = [] - cond743 = self.match_lookahead_literal("(", 0) - while cond743: - _t1425 = self.parse_declaration() - item744 = _t1425 - xs742.append(item744) - cond743 = self.match_lookahead_literal("(", 0) - declarations745 = xs742 - self.consume_literal(")") - result747 = self.construct_fragment(new_fragment_id741, declarations745) - self.record_span(span_start746, "Fragment") - return result747 + _t1440 = self.parse_new_fragment_id() + new_fragment_id749 = _t1440 + xs750 = [] + cond751 = self.match_lookahead_literal("(", 0) + while cond751: + _t1441 = self.parse_declaration() + item752 = _t1441 + xs750.append(item752) + cond751 = self.match_lookahead_literal("(", 0) + declarations753 = xs750 + self.consume_literal(")") + result755 = self.construct_fragment(new_fragment_id749, declarations753) + self.record_span(span_start754, "Fragment") + return result755 def parse_new_fragment_id(self) -> fragments_pb2.FragmentId: - span_start749 = self.span_start() - _t1426 = self.parse_fragment_id() - fragment_id748 = _t1426 - self.start_fragment(fragment_id748) - result750 = fragment_id748 - self.record_span(span_start749, "FragmentId") - return result750 + span_start757 = self.span_start() + _t1442 = self.parse_fragment_id() + fragment_id756 = _t1442 + self.start_fragment(fragment_id756) + result758 = fragment_id756 + self.record_span(span_start757, "FragmentId") + return result758 def parse_declaration(self) -> logic_pb2.Declaration: - span_start756 = self.span_start() + span_start764 = self.span_start() if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("iceberg_data", 1): - _t1428 = 3 + _t1444 = 3 else: if self.match_lookahead_literal("functional_dependency", 1): - _t1429 = 2 + _t1445 = 2 else: if self.match_lookahead_literal("edb", 1): - _t1430 = 3 + _t1446 = 3 else: if self.match_lookahead_literal("def", 1): - _t1431 = 0 + _t1447 = 0 else: if self.match_lookahead_literal("csv_data", 1): - _t1432 = 3 + _t1448 = 3 else: if self.match_lookahead_literal("betree_relation", 1): - _t1433 = 3 + _t1449 = 3 else: if self.match_lookahead_literal("algorithm", 1): - _t1434 = 1 + _t1450 = 1 else: - _t1434 = -1 - _t1433 = _t1434 - _t1432 = _t1433 - _t1431 = _t1432 - _t1430 = _t1431 - _t1429 = _t1430 - _t1428 = _t1429 - _t1427 = _t1428 - else: - _t1427 = -1 - prediction751 = _t1427 - if prediction751 == 3: - _t1436 = self.parse_data() - data755 = _t1436 - _t1437 = logic_pb2.Declaration(data=data755) - _t1435 = _t1437 - else: - if prediction751 == 2: - _t1439 = self.parse_constraint() - constraint754 = _t1439 - _t1440 = logic_pb2.Declaration(constraint=constraint754) - _t1438 = _t1440 + _t1450 = -1 + _t1449 = _t1450 + _t1448 = _t1449 + _t1447 = _t1448 + _t1446 = _t1447 + _t1445 = _t1446 + _t1444 = _t1445 + _t1443 = _t1444 + else: + _t1443 = -1 + prediction759 = _t1443 + if prediction759 == 3: + _t1452 = self.parse_data() + data763 = _t1452 + _t1453 = logic_pb2.Declaration(data=data763) + _t1451 = _t1453 + else: + if prediction759 == 2: + _t1455 = self.parse_constraint() + constraint762 = _t1455 + _t1456 = logic_pb2.Declaration(constraint=constraint762) + _t1454 = _t1456 else: - if prediction751 == 1: - _t1442 = self.parse_algorithm() - algorithm753 = _t1442 - _t1443 = logic_pb2.Declaration(algorithm=algorithm753) - _t1441 = _t1443 + if prediction759 == 1: + _t1458 = self.parse_algorithm() + algorithm761 = _t1458 + _t1459 = logic_pb2.Declaration(algorithm=algorithm761) + _t1457 = _t1459 else: - if prediction751 == 0: - _t1445 = self.parse_def() - def752 = _t1445 - _t1446 = logic_pb2.Declaration() - getattr(_t1446, 'def').CopyFrom(def752) - _t1444 = _t1446 + if prediction759 == 0: + _t1461 = self.parse_def() + def760 = _t1461 + _t1462 = logic_pb2.Declaration() + getattr(_t1462, 'def').CopyFrom(def760) + _t1460 = _t1462 else: raise ParseError("Unexpected token in declaration" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1441 = _t1444 - _t1438 = _t1441 - _t1435 = _t1438 - result757 = _t1435 - self.record_span(span_start756, "Declaration") - return result757 + _t1457 = _t1460 + _t1454 = _t1457 + _t1451 = _t1454 + result765 = _t1451 + self.record_span(span_start764, "Declaration") + return result765 def parse_def(self) -> logic_pb2.Def: - span_start761 = self.span_start() + span_start769 = self.span_start() self.consume_literal("(") self.consume_literal("def") - _t1447 = self.parse_relation_id() - relation_id758 = _t1447 - _t1448 = self.parse_abstraction() - abstraction759 = _t1448 + _t1463 = self.parse_relation_id() + relation_id766 = _t1463 + _t1464 = self.parse_abstraction() + abstraction767 = _t1464 if self.match_lookahead_literal("(", 0): - _t1450 = self.parse_attrs() - _t1449 = _t1450 + _t1466 = self.parse_attrs() + _t1465 = _t1466 else: - _t1449 = None - attrs760 = _t1449 + _t1465 = None + attrs768 = _t1465 self.consume_literal(")") - _t1451 = logic_pb2.Def(name=relation_id758, body=abstraction759, attrs=(attrs760 if attrs760 is not None else [])) - result762 = _t1451 - self.record_span(span_start761, "Def") - return result762 + _t1467 = logic_pb2.Def(name=relation_id766, body=abstraction767, attrs=(attrs768 if attrs768 is not None else [])) + result770 = _t1467 + self.record_span(span_start769, "Def") + return result770 def parse_relation_id(self) -> logic_pb2.RelationId: - span_start766 = self.span_start() + span_start774 = self.span_start() if self.match_lookahead_literal(":", 0): - _t1452 = 0 + _t1468 = 0 else: if self.match_lookahead_terminal("UINT128", 0): - _t1453 = 1 + _t1469 = 1 else: - _t1453 = -1 - _t1452 = _t1453 - prediction763 = _t1452 - if prediction763 == 1: - uint128765 = self.consume_terminal("UINT128") - _t1454 = logic_pb2.RelationId(id_low=uint128765.low, id_high=uint128765.high) - else: - if prediction763 == 0: + _t1469 = -1 + _t1468 = _t1469 + prediction771 = _t1468 + if prediction771 == 1: + uint128773 = self.consume_terminal("UINT128") + _t1470 = logic_pb2.RelationId(id_low=uint128773.low, id_high=uint128773.high) + else: + if prediction771 == 0: self.consume_literal(":") - symbol764 = self.consume_terminal("SYMBOL") - _t1455 = self.relation_id_from_string(symbol764) + symbol772 = self.consume_terminal("SYMBOL") + _t1471 = self.relation_id_from_string(symbol772) else: raise ParseError("Unexpected token in relation_id" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1454 = _t1455 - result767 = _t1454 - self.record_span(span_start766, "RelationId") - return result767 + _t1470 = _t1471 + result775 = _t1470 + self.record_span(span_start774, "RelationId") + return result775 def parse_abstraction(self) -> logic_pb2.Abstraction: - span_start770 = self.span_start() + span_start778 = self.span_start() self.consume_literal("(") - _t1456 = self.parse_bindings() - bindings768 = _t1456 - _t1457 = self.parse_formula() - formula769 = _t1457 + _t1472 = self.parse_bindings() + bindings776 = _t1472 + _t1473 = self.parse_formula() + formula777 = _t1473 self.consume_literal(")") - _t1458 = logic_pb2.Abstraction(vars=(list(bindings768[0]) + list(bindings768[1] if bindings768[1] is not None else [])), value=formula769) - result771 = _t1458 - self.record_span(span_start770, "Abstraction") - return result771 + _t1474 = logic_pb2.Abstraction(vars=(list(bindings776[0]) + list(bindings776[1] if bindings776[1] is not None else [])), value=formula777) + result779 = _t1474 + self.record_span(span_start778, "Abstraction") + return result779 def parse_bindings(self) -> tuple[Sequence[logic_pb2.Binding], Sequence[logic_pb2.Binding]]: self.consume_literal("[") - xs772 = [] - cond773 = self.match_lookahead_terminal("SYMBOL", 0) - while cond773: - _t1459 = self.parse_binding() - item774 = _t1459 - xs772.append(item774) - cond773 = self.match_lookahead_terminal("SYMBOL", 0) - bindings775 = xs772 + xs780 = [] + cond781 = self.match_lookahead_terminal("SYMBOL", 0) + while cond781: + _t1475 = self.parse_binding() + item782 = _t1475 + xs780.append(item782) + cond781 = self.match_lookahead_terminal("SYMBOL", 0) + bindings783 = xs780 if self.match_lookahead_literal("|", 0): - _t1461 = self.parse_value_bindings() - _t1460 = _t1461 + _t1477 = self.parse_value_bindings() + _t1476 = _t1477 else: - _t1460 = None - value_bindings776 = _t1460 + _t1476 = None + value_bindings784 = _t1476 self.consume_literal("]") - return (bindings775, (value_bindings776 if value_bindings776 is not None else []),) + return (bindings783, (value_bindings784 if value_bindings784 is not None else []),) def parse_binding(self) -> logic_pb2.Binding: - span_start779 = self.span_start() - symbol777 = self.consume_terminal("SYMBOL") + span_start787 = self.span_start() + symbol785 = self.consume_terminal("SYMBOL") self.consume_literal("::") - _t1462 = self.parse_type() - type778 = _t1462 - _t1463 = logic_pb2.Var(name=symbol777) - _t1464 = logic_pb2.Binding(var=_t1463, type=type778) - result780 = _t1464 - self.record_span(span_start779, "Binding") - return result780 + _t1478 = self.parse_type() + type786 = _t1478 + _t1479 = logic_pb2.Var(name=symbol785) + _t1480 = logic_pb2.Binding(var=_t1479, type=type786) + result788 = _t1480 + self.record_span(span_start787, "Binding") + return result788 def parse_type(self) -> logic_pb2.Type: - span_start796 = self.span_start() + span_start804 = self.span_start() if self.match_lookahead_literal("UNKNOWN", 0): - _t1465 = 0 + _t1481 = 0 else: if self.match_lookahead_literal("UINT32", 0): - _t1466 = 13 + _t1482 = 13 else: if self.match_lookahead_literal("UINT128", 0): - _t1467 = 4 + _t1483 = 4 else: if self.match_lookahead_literal("STRING", 0): - _t1468 = 1 + _t1484 = 1 else: if self.match_lookahead_literal("MISSING", 0): - _t1469 = 8 + _t1485 = 8 else: if self.match_lookahead_literal("INT32", 0): - _t1470 = 11 + _t1486 = 11 else: if self.match_lookahead_literal("INT128", 0): - _t1471 = 5 + _t1487 = 5 else: if self.match_lookahead_literal("INT", 0): - _t1472 = 2 + _t1488 = 2 else: if self.match_lookahead_literal("FLOAT32", 0): - _t1473 = 12 + _t1489 = 12 else: if self.match_lookahead_literal("FLOAT", 0): - _t1474 = 3 + _t1490 = 3 else: if self.match_lookahead_literal("DATETIME", 0): - _t1475 = 7 + _t1491 = 7 else: if self.match_lookahead_literal("DATE", 0): - _t1476 = 6 + _t1492 = 6 else: if self.match_lookahead_literal("BOOLEAN", 0): - _t1477 = 10 + _t1493 = 10 else: if self.match_lookahead_literal("(", 0): - _t1478 = 9 + _t1494 = 9 else: - _t1478 = -1 - _t1477 = _t1478 - _t1476 = _t1477 - _t1475 = _t1476 - _t1474 = _t1475 - _t1473 = _t1474 - _t1472 = _t1473 - _t1471 = _t1472 - _t1470 = _t1471 - _t1469 = _t1470 - _t1468 = _t1469 - _t1467 = _t1468 - _t1466 = _t1467 - _t1465 = _t1466 - prediction781 = _t1465 - if prediction781 == 13: - _t1480 = self.parse_uint32_type() - uint32_type795 = _t1480 - _t1481 = logic_pb2.Type(uint32_type=uint32_type795) - _t1479 = _t1481 - else: - if prediction781 == 12: - _t1483 = self.parse_float32_type() - float32_type794 = _t1483 - _t1484 = logic_pb2.Type(float32_type=float32_type794) - _t1482 = _t1484 + _t1494 = -1 + _t1493 = _t1494 + _t1492 = _t1493 + _t1491 = _t1492 + _t1490 = _t1491 + _t1489 = _t1490 + _t1488 = _t1489 + _t1487 = _t1488 + _t1486 = _t1487 + _t1485 = _t1486 + _t1484 = _t1485 + _t1483 = _t1484 + _t1482 = _t1483 + _t1481 = _t1482 + prediction789 = _t1481 + if prediction789 == 13: + _t1496 = self.parse_uint32_type() + uint32_type803 = _t1496 + _t1497 = logic_pb2.Type(uint32_type=uint32_type803) + _t1495 = _t1497 + else: + if prediction789 == 12: + _t1499 = self.parse_float32_type() + float32_type802 = _t1499 + _t1500 = logic_pb2.Type(float32_type=float32_type802) + _t1498 = _t1500 else: - if prediction781 == 11: - _t1486 = self.parse_int32_type() - int32_type793 = _t1486 - _t1487 = logic_pb2.Type(int32_type=int32_type793) - _t1485 = _t1487 + if prediction789 == 11: + _t1502 = self.parse_int32_type() + int32_type801 = _t1502 + _t1503 = logic_pb2.Type(int32_type=int32_type801) + _t1501 = _t1503 else: - if prediction781 == 10: - _t1489 = self.parse_boolean_type() - boolean_type792 = _t1489 - _t1490 = logic_pb2.Type(boolean_type=boolean_type792) - _t1488 = _t1490 + if prediction789 == 10: + _t1505 = self.parse_boolean_type() + boolean_type800 = _t1505 + _t1506 = logic_pb2.Type(boolean_type=boolean_type800) + _t1504 = _t1506 else: - if prediction781 == 9: - _t1492 = self.parse_decimal_type() - decimal_type791 = _t1492 - _t1493 = logic_pb2.Type(decimal_type=decimal_type791) - _t1491 = _t1493 + if prediction789 == 9: + _t1508 = self.parse_decimal_type() + decimal_type799 = _t1508 + _t1509 = logic_pb2.Type(decimal_type=decimal_type799) + _t1507 = _t1509 else: - if prediction781 == 8: - _t1495 = self.parse_missing_type() - missing_type790 = _t1495 - _t1496 = logic_pb2.Type(missing_type=missing_type790) - _t1494 = _t1496 + if prediction789 == 8: + _t1511 = self.parse_missing_type() + missing_type798 = _t1511 + _t1512 = logic_pb2.Type(missing_type=missing_type798) + _t1510 = _t1512 else: - if prediction781 == 7: - _t1498 = self.parse_datetime_type() - datetime_type789 = _t1498 - _t1499 = logic_pb2.Type(datetime_type=datetime_type789) - _t1497 = _t1499 + if prediction789 == 7: + _t1514 = self.parse_datetime_type() + datetime_type797 = _t1514 + _t1515 = logic_pb2.Type(datetime_type=datetime_type797) + _t1513 = _t1515 else: - if prediction781 == 6: - _t1501 = self.parse_date_type() - date_type788 = _t1501 - _t1502 = logic_pb2.Type(date_type=date_type788) - _t1500 = _t1502 + if prediction789 == 6: + _t1517 = self.parse_date_type() + date_type796 = _t1517 + _t1518 = logic_pb2.Type(date_type=date_type796) + _t1516 = _t1518 else: - if prediction781 == 5: - _t1504 = self.parse_int128_type() - int128_type787 = _t1504 - _t1505 = logic_pb2.Type(int128_type=int128_type787) - _t1503 = _t1505 + if prediction789 == 5: + _t1520 = self.parse_int128_type() + int128_type795 = _t1520 + _t1521 = logic_pb2.Type(int128_type=int128_type795) + _t1519 = _t1521 else: - if prediction781 == 4: - _t1507 = self.parse_uint128_type() - uint128_type786 = _t1507 - _t1508 = logic_pb2.Type(uint128_type=uint128_type786) - _t1506 = _t1508 + if prediction789 == 4: + _t1523 = self.parse_uint128_type() + uint128_type794 = _t1523 + _t1524 = logic_pb2.Type(uint128_type=uint128_type794) + _t1522 = _t1524 else: - if prediction781 == 3: - _t1510 = self.parse_float_type() - float_type785 = _t1510 - _t1511 = logic_pb2.Type(float_type=float_type785) - _t1509 = _t1511 + if prediction789 == 3: + _t1526 = self.parse_float_type() + float_type793 = _t1526 + _t1527 = logic_pb2.Type(float_type=float_type793) + _t1525 = _t1527 else: - if prediction781 == 2: - _t1513 = self.parse_int_type() - int_type784 = _t1513 - _t1514 = logic_pb2.Type(int_type=int_type784) - _t1512 = _t1514 + if prediction789 == 2: + _t1529 = self.parse_int_type() + int_type792 = _t1529 + _t1530 = logic_pb2.Type(int_type=int_type792) + _t1528 = _t1530 else: - if prediction781 == 1: - _t1516 = self.parse_string_type() - string_type783 = _t1516 - _t1517 = logic_pb2.Type(string_type=string_type783) - _t1515 = _t1517 + if prediction789 == 1: + _t1532 = self.parse_string_type() + string_type791 = _t1532 + _t1533 = logic_pb2.Type(string_type=string_type791) + _t1531 = _t1533 else: - if prediction781 == 0: - _t1519 = self.parse_unspecified_type() - unspecified_type782 = _t1519 - _t1520 = logic_pb2.Type(unspecified_type=unspecified_type782) - _t1518 = _t1520 + if prediction789 == 0: + _t1535 = self.parse_unspecified_type() + unspecified_type790 = _t1535 + _t1536 = logic_pb2.Type(unspecified_type=unspecified_type790) + _t1534 = _t1536 else: raise ParseError("Unexpected token in type" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1515 = _t1518 - _t1512 = _t1515 - _t1509 = _t1512 - _t1506 = _t1509 - _t1503 = _t1506 - _t1500 = _t1503 - _t1497 = _t1500 - _t1494 = _t1497 - _t1491 = _t1494 - _t1488 = _t1491 - _t1485 = _t1488 - _t1482 = _t1485 - _t1479 = _t1482 - result797 = _t1479 - self.record_span(span_start796, "Type") - return result797 + _t1531 = _t1534 + _t1528 = _t1531 + _t1525 = _t1528 + _t1522 = _t1525 + _t1519 = _t1522 + _t1516 = _t1519 + _t1513 = _t1516 + _t1510 = _t1513 + _t1507 = _t1510 + _t1504 = _t1507 + _t1501 = _t1504 + _t1498 = _t1501 + _t1495 = _t1498 + result805 = _t1495 + self.record_span(span_start804, "Type") + return result805 def parse_unspecified_type(self) -> logic_pb2.UnspecifiedType: - span_start798 = self.span_start() + span_start806 = self.span_start() self.consume_literal("UNKNOWN") - _t1521 = logic_pb2.UnspecifiedType() - result799 = _t1521 - self.record_span(span_start798, "UnspecifiedType") - return result799 + _t1537 = logic_pb2.UnspecifiedType() + result807 = _t1537 + self.record_span(span_start806, "UnspecifiedType") + return result807 def parse_string_type(self) -> logic_pb2.StringType: - span_start800 = self.span_start() + span_start808 = self.span_start() self.consume_literal("STRING") - _t1522 = logic_pb2.StringType() - result801 = _t1522 - self.record_span(span_start800, "StringType") - return result801 + _t1538 = logic_pb2.StringType() + result809 = _t1538 + self.record_span(span_start808, "StringType") + return result809 def parse_int_type(self) -> logic_pb2.IntType: - span_start802 = self.span_start() + span_start810 = self.span_start() self.consume_literal("INT") - _t1523 = logic_pb2.IntType() - result803 = _t1523 - self.record_span(span_start802, "IntType") - return result803 + _t1539 = logic_pb2.IntType() + result811 = _t1539 + self.record_span(span_start810, "IntType") + return result811 def parse_float_type(self) -> logic_pb2.FloatType: - span_start804 = self.span_start() + span_start812 = self.span_start() self.consume_literal("FLOAT") - _t1524 = logic_pb2.FloatType() - result805 = _t1524 - self.record_span(span_start804, "FloatType") - return result805 + _t1540 = logic_pb2.FloatType() + result813 = _t1540 + self.record_span(span_start812, "FloatType") + return result813 def parse_uint128_type(self) -> logic_pb2.UInt128Type: - span_start806 = self.span_start() + span_start814 = self.span_start() self.consume_literal("UINT128") - _t1525 = logic_pb2.UInt128Type() - result807 = _t1525 - self.record_span(span_start806, "UInt128Type") - return result807 + _t1541 = logic_pb2.UInt128Type() + result815 = _t1541 + self.record_span(span_start814, "UInt128Type") + return result815 def parse_int128_type(self) -> logic_pb2.Int128Type: - span_start808 = self.span_start() + span_start816 = self.span_start() self.consume_literal("INT128") - _t1526 = logic_pb2.Int128Type() - result809 = _t1526 - self.record_span(span_start808, "Int128Type") - return result809 + _t1542 = logic_pb2.Int128Type() + result817 = _t1542 + self.record_span(span_start816, "Int128Type") + return result817 def parse_date_type(self) -> logic_pb2.DateType: - span_start810 = self.span_start() + span_start818 = self.span_start() self.consume_literal("DATE") - _t1527 = logic_pb2.DateType() - result811 = _t1527 - self.record_span(span_start810, "DateType") - return result811 + _t1543 = logic_pb2.DateType() + result819 = _t1543 + self.record_span(span_start818, "DateType") + return result819 def parse_datetime_type(self) -> logic_pb2.DateTimeType: - span_start812 = self.span_start() + span_start820 = self.span_start() self.consume_literal("DATETIME") - _t1528 = logic_pb2.DateTimeType() - result813 = _t1528 - self.record_span(span_start812, "DateTimeType") - return result813 + _t1544 = logic_pb2.DateTimeType() + result821 = _t1544 + self.record_span(span_start820, "DateTimeType") + return result821 def parse_missing_type(self) -> logic_pb2.MissingType: - span_start814 = self.span_start() + span_start822 = self.span_start() self.consume_literal("MISSING") - _t1529 = logic_pb2.MissingType() - result815 = _t1529 - self.record_span(span_start814, "MissingType") - return result815 + _t1545 = logic_pb2.MissingType() + result823 = _t1545 + self.record_span(span_start822, "MissingType") + return result823 def parse_decimal_type(self) -> logic_pb2.DecimalType: - span_start818 = self.span_start() + span_start826 = self.span_start() self.consume_literal("(") self.consume_literal("DECIMAL") - int816 = self.consume_terminal("INT") - int_3817 = self.consume_terminal("INT") + int824 = self.consume_terminal("INT") + int_3825 = self.consume_terminal("INT") self.consume_literal(")") - _t1530 = logic_pb2.DecimalType(precision=int(int816), scale=int(int_3817)) - result819 = _t1530 - self.record_span(span_start818, "DecimalType") - return result819 + _t1546 = logic_pb2.DecimalType(precision=int(int824), scale=int(int_3825)) + result827 = _t1546 + self.record_span(span_start826, "DecimalType") + return result827 def parse_boolean_type(self) -> logic_pb2.BooleanType: - span_start820 = self.span_start() + span_start828 = self.span_start() self.consume_literal("BOOLEAN") - _t1531 = logic_pb2.BooleanType() - result821 = _t1531 - self.record_span(span_start820, "BooleanType") - return result821 + _t1547 = logic_pb2.BooleanType() + result829 = _t1547 + self.record_span(span_start828, "BooleanType") + return result829 def parse_int32_type(self) -> logic_pb2.Int32Type: - span_start822 = self.span_start() + span_start830 = self.span_start() self.consume_literal("INT32") - _t1532 = logic_pb2.Int32Type() - result823 = _t1532 - self.record_span(span_start822, "Int32Type") - return result823 + _t1548 = logic_pb2.Int32Type() + result831 = _t1548 + self.record_span(span_start830, "Int32Type") + return result831 def parse_float32_type(self) -> logic_pb2.Float32Type: - span_start824 = self.span_start() + span_start832 = self.span_start() self.consume_literal("FLOAT32") - _t1533 = logic_pb2.Float32Type() - result825 = _t1533 - self.record_span(span_start824, "Float32Type") - return result825 + _t1549 = logic_pb2.Float32Type() + result833 = _t1549 + self.record_span(span_start832, "Float32Type") + return result833 def parse_uint32_type(self) -> logic_pb2.UInt32Type: - span_start826 = self.span_start() + span_start834 = self.span_start() self.consume_literal("UINT32") - _t1534 = logic_pb2.UInt32Type() - result827 = _t1534 - self.record_span(span_start826, "UInt32Type") - return result827 + _t1550 = logic_pb2.UInt32Type() + result835 = _t1550 + self.record_span(span_start834, "UInt32Type") + return result835 def parse_value_bindings(self) -> Sequence[logic_pb2.Binding]: self.consume_literal("|") - xs828 = [] - cond829 = self.match_lookahead_terminal("SYMBOL", 0) - while cond829: - _t1535 = self.parse_binding() - item830 = _t1535 - xs828.append(item830) - cond829 = self.match_lookahead_terminal("SYMBOL", 0) - bindings831 = xs828 - return bindings831 + xs836 = [] + cond837 = self.match_lookahead_terminal("SYMBOL", 0) + while cond837: + _t1551 = self.parse_binding() + item838 = _t1551 + xs836.append(item838) + cond837 = self.match_lookahead_terminal("SYMBOL", 0) + bindings839 = xs836 + return bindings839 def parse_formula(self) -> logic_pb2.Formula: - span_start846 = self.span_start() + span_start854 = self.span_start() if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("true", 1): - _t1537 = 0 + _t1553 = 0 else: if self.match_lookahead_literal("relatom", 1): - _t1538 = 11 + _t1554 = 11 else: if self.match_lookahead_literal("reduce", 1): - _t1539 = 3 + _t1555 = 3 else: if self.match_lookahead_literal("primitive", 1): - _t1540 = 10 + _t1556 = 10 else: if self.match_lookahead_literal("pragma", 1): - _t1541 = 9 + _t1557 = 9 else: if self.match_lookahead_literal("or", 1): - _t1542 = 5 + _t1558 = 5 else: if self.match_lookahead_literal("not", 1): - _t1543 = 6 + _t1559 = 6 else: if self.match_lookahead_literal("ffi", 1): - _t1544 = 7 + _t1560 = 7 else: if self.match_lookahead_literal("false", 1): - _t1545 = 1 + _t1561 = 1 else: if self.match_lookahead_literal("exists", 1): - _t1546 = 2 + _t1562 = 2 else: if self.match_lookahead_literal("cast", 1): - _t1547 = 12 + _t1563 = 12 else: if self.match_lookahead_literal("atom", 1): - _t1548 = 8 + _t1564 = 8 else: if self.match_lookahead_literal("and", 1): - _t1549 = 4 + _t1565 = 4 else: if self.match_lookahead_literal(">=", 1): - _t1550 = 10 + _t1566 = 10 else: if self.match_lookahead_literal(">", 1): - _t1551 = 10 + _t1567 = 10 else: if self.match_lookahead_literal("=", 1): - _t1552 = 10 + _t1568 = 10 else: if self.match_lookahead_literal("<=", 1): - _t1553 = 10 + _t1569 = 10 else: if self.match_lookahead_literal("<", 1): - _t1554 = 10 + _t1570 = 10 else: if self.match_lookahead_literal("/", 1): - _t1555 = 10 + _t1571 = 10 else: if self.match_lookahead_literal("-", 1): - _t1556 = 10 + _t1572 = 10 else: if self.match_lookahead_literal("+", 1): - _t1557 = 10 + _t1573 = 10 else: if self.match_lookahead_literal("*", 1): - _t1558 = 10 + _t1574 = 10 else: - _t1558 = -1 - _t1557 = _t1558 - _t1556 = _t1557 - _t1555 = _t1556 - _t1554 = _t1555 - _t1553 = _t1554 - _t1552 = _t1553 - _t1551 = _t1552 - _t1550 = _t1551 - _t1549 = _t1550 - _t1548 = _t1549 - _t1547 = _t1548 - _t1546 = _t1547 - _t1545 = _t1546 - _t1544 = _t1545 - _t1543 = _t1544 - _t1542 = _t1543 - _t1541 = _t1542 - _t1540 = _t1541 - _t1539 = _t1540 - _t1538 = _t1539 - _t1537 = _t1538 - _t1536 = _t1537 - else: - _t1536 = -1 - prediction832 = _t1536 - if prediction832 == 12: - _t1560 = self.parse_cast() - cast845 = _t1560 - _t1561 = logic_pb2.Formula(cast=cast845) - _t1559 = _t1561 - else: - if prediction832 == 11: - _t1563 = self.parse_rel_atom() - rel_atom844 = _t1563 - _t1564 = logic_pb2.Formula(rel_atom=rel_atom844) - _t1562 = _t1564 + _t1574 = -1 + _t1573 = _t1574 + _t1572 = _t1573 + _t1571 = _t1572 + _t1570 = _t1571 + _t1569 = _t1570 + _t1568 = _t1569 + _t1567 = _t1568 + _t1566 = _t1567 + _t1565 = _t1566 + _t1564 = _t1565 + _t1563 = _t1564 + _t1562 = _t1563 + _t1561 = _t1562 + _t1560 = _t1561 + _t1559 = _t1560 + _t1558 = _t1559 + _t1557 = _t1558 + _t1556 = _t1557 + _t1555 = _t1556 + _t1554 = _t1555 + _t1553 = _t1554 + _t1552 = _t1553 + else: + _t1552 = -1 + prediction840 = _t1552 + if prediction840 == 12: + _t1576 = self.parse_cast() + cast853 = _t1576 + _t1577 = logic_pb2.Formula(cast=cast853) + _t1575 = _t1577 + else: + if prediction840 == 11: + _t1579 = self.parse_rel_atom() + rel_atom852 = _t1579 + _t1580 = logic_pb2.Formula(rel_atom=rel_atom852) + _t1578 = _t1580 else: - if prediction832 == 10: - _t1566 = self.parse_primitive() - primitive843 = _t1566 - _t1567 = logic_pb2.Formula(primitive=primitive843) - _t1565 = _t1567 + if prediction840 == 10: + _t1582 = self.parse_primitive() + primitive851 = _t1582 + _t1583 = logic_pb2.Formula(primitive=primitive851) + _t1581 = _t1583 else: - if prediction832 == 9: - _t1569 = self.parse_pragma() - pragma842 = _t1569 - _t1570 = logic_pb2.Formula(pragma=pragma842) - _t1568 = _t1570 + if prediction840 == 9: + _t1585 = self.parse_pragma() + pragma850 = _t1585 + _t1586 = logic_pb2.Formula(pragma=pragma850) + _t1584 = _t1586 else: - if prediction832 == 8: - _t1572 = self.parse_atom() - atom841 = _t1572 - _t1573 = logic_pb2.Formula(atom=atom841) - _t1571 = _t1573 + if prediction840 == 8: + _t1588 = self.parse_atom() + atom849 = _t1588 + _t1589 = logic_pb2.Formula(atom=atom849) + _t1587 = _t1589 else: - if prediction832 == 7: - _t1575 = self.parse_ffi() - ffi840 = _t1575 - _t1576 = logic_pb2.Formula(ffi=ffi840) - _t1574 = _t1576 + if prediction840 == 7: + _t1591 = self.parse_ffi() + ffi848 = _t1591 + _t1592 = logic_pb2.Formula(ffi=ffi848) + _t1590 = _t1592 else: - if prediction832 == 6: - _t1578 = self.parse_not() - not839 = _t1578 - _t1579 = logic_pb2.Formula() - getattr(_t1579, 'not').CopyFrom(not839) - _t1577 = _t1579 + if prediction840 == 6: + _t1594 = self.parse_not() + not847 = _t1594 + _t1595 = logic_pb2.Formula() + getattr(_t1595, 'not').CopyFrom(not847) + _t1593 = _t1595 else: - if prediction832 == 5: - _t1581 = self.parse_disjunction() - disjunction838 = _t1581 - _t1582 = logic_pb2.Formula(disjunction=disjunction838) - _t1580 = _t1582 + if prediction840 == 5: + _t1597 = self.parse_disjunction() + disjunction846 = _t1597 + _t1598 = logic_pb2.Formula(disjunction=disjunction846) + _t1596 = _t1598 else: - if prediction832 == 4: - _t1584 = self.parse_conjunction() - conjunction837 = _t1584 - _t1585 = logic_pb2.Formula(conjunction=conjunction837) - _t1583 = _t1585 + if prediction840 == 4: + _t1600 = self.parse_conjunction() + conjunction845 = _t1600 + _t1601 = logic_pb2.Formula(conjunction=conjunction845) + _t1599 = _t1601 else: - if prediction832 == 3: - _t1587 = self.parse_reduce() - reduce836 = _t1587 - _t1588 = logic_pb2.Formula(reduce=reduce836) - _t1586 = _t1588 + if prediction840 == 3: + _t1603 = self.parse_reduce() + reduce844 = _t1603 + _t1604 = logic_pb2.Formula(reduce=reduce844) + _t1602 = _t1604 else: - if prediction832 == 2: - _t1590 = self.parse_exists() - exists835 = _t1590 - _t1591 = logic_pb2.Formula(exists=exists835) - _t1589 = _t1591 + if prediction840 == 2: + _t1606 = self.parse_exists() + exists843 = _t1606 + _t1607 = logic_pb2.Formula(exists=exists843) + _t1605 = _t1607 else: - if prediction832 == 1: - _t1593 = self.parse_false() - false834 = _t1593 - _t1594 = logic_pb2.Formula(disjunction=false834) - _t1592 = _t1594 + if prediction840 == 1: + _t1609 = self.parse_false() + false842 = _t1609 + _t1610 = logic_pb2.Formula(disjunction=false842) + _t1608 = _t1610 else: - if prediction832 == 0: - _t1596 = self.parse_true() - true833 = _t1596 - _t1597 = logic_pb2.Formula(conjunction=true833) - _t1595 = _t1597 + if prediction840 == 0: + _t1612 = self.parse_true() + true841 = _t1612 + _t1613 = logic_pb2.Formula(conjunction=true841) + _t1611 = _t1613 else: raise ParseError("Unexpected token in formula" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1592 = _t1595 - _t1589 = _t1592 - _t1586 = _t1589 - _t1583 = _t1586 - _t1580 = _t1583 - _t1577 = _t1580 - _t1574 = _t1577 - _t1571 = _t1574 - _t1568 = _t1571 - _t1565 = _t1568 - _t1562 = _t1565 - _t1559 = _t1562 - result847 = _t1559 - self.record_span(span_start846, "Formula") - return result847 + _t1608 = _t1611 + _t1605 = _t1608 + _t1602 = _t1605 + _t1599 = _t1602 + _t1596 = _t1599 + _t1593 = _t1596 + _t1590 = _t1593 + _t1587 = _t1590 + _t1584 = _t1587 + _t1581 = _t1584 + _t1578 = _t1581 + _t1575 = _t1578 + result855 = _t1575 + self.record_span(span_start854, "Formula") + return result855 def parse_true(self) -> logic_pb2.Conjunction: - span_start848 = self.span_start() + span_start856 = self.span_start() self.consume_literal("(") self.consume_literal("true") self.consume_literal(")") - _t1598 = logic_pb2.Conjunction(args=[]) - result849 = _t1598 - self.record_span(span_start848, "Conjunction") - return result849 + _t1614 = logic_pb2.Conjunction(args=[]) + result857 = _t1614 + self.record_span(span_start856, "Conjunction") + return result857 def parse_false(self) -> logic_pb2.Disjunction: - span_start850 = self.span_start() + span_start858 = self.span_start() self.consume_literal("(") self.consume_literal("false") self.consume_literal(")") - _t1599 = logic_pb2.Disjunction(args=[]) - result851 = _t1599 - self.record_span(span_start850, "Disjunction") - return result851 + _t1615 = logic_pb2.Disjunction(args=[]) + result859 = _t1615 + self.record_span(span_start858, "Disjunction") + return result859 def parse_exists(self) -> logic_pb2.Exists: - span_start854 = self.span_start() + span_start862 = self.span_start() self.consume_literal("(") self.consume_literal("exists") - _t1600 = self.parse_bindings() - bindings852 = _t1600 - _t1601 = self.parse_formula() - formula853 = _t1601 - self.consume_literal(")") - _t1602 = logic_pb2.Abstraction(vars=(list(bindings852[0]) + list(bindings852[1] if bindings852[1] is not None else [])), value=formula853) - _t1603 = logic_pb2.Exists(body=_t1602) - result855 = _t1603 - self.record_span(span_start854, "Exists") - return result855 + _t1616 = self.parse_bindings() + bindings860 = _t1616 + _t1617 = self.parse_formula() + formula861 = _t1617 + self.consume_literal(")") + _t1618 = logic_pb2.Abstraction(vars=(list(bindings860[0]) + list(bindings860[1] if bindings860[1] is not None else [])), value=formula861) + _t1619 = logic_pb2.Exists(body=_t1618) + result863 = _t1619 + self.record_span(span_start862, "Exists") + return result863 def parse_reduce(self) -> logic_pb2.Reduce: - span_start859 = self.span_start() + span_start867 = self.span_start() self.consume_literal("(") self.consume_literal("reduce") - _t1604 = self.parse_abstraction() - abstraction856 = _t1604 - _t1605 = self.parse_abstraction() - abstraction_3857 = _t1605 - _t1606 = self.parse_terms() - terms858 = _t1606 - self.consume_literal(")") - _t1607 = logic_pb2.Reduce(op=abstraction856, body=abstraction_3857, terms=terms858) - result860 = _t1607 - self.record_span(span_start859, "Reduce") - return result860 + _t1620 = self.parse_abstraction() + abstraction864 = _t1620 + _t1621 = self.parse_abstraction() + abstraction_3865 = _t1621 + _t1622 = self.parse_terms() + terms866 = _t1622 + self.consume_literal(")") + _t1623 = logic_pb2.Reduce(op=abstraction864, body=abstraction_3865, terms=terms866) + result868 = _t1623 + self.record_span(span_start867, "Reduce") + return result868 def parse_terms(self) -> Sequence[logic_pb2.Term]: self.consume_literal("(") self.consume_literal("terms") - xs861 = [] - cond862 = (((((((((((((self.match_lookahead_literal("(", 0) or self.match_lookahead_literal("false", 0)) or self.match_lookahead_literal("missing", 0)) or self.match_lookahead_literal("true", 0)) or self.match_lookahead_terminal("DECIMAL", 0)) or self.match_lookahead_terminal("FLOAT", 0)) or self.match_lookahead_terminal("FLOAT32", 0)) or self.match_lookahead_terminal("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("INT32", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("UINT128", 0)) or self.match_lookahead_terminal("UINT32", 0)) or self.match_lookahead_terminal("SYMBOL", 0)) - while cond862: - _t1608 = self.parse_term() - item863 = _t1608 - xs861.append(item863) - cond862 = (((((((((((((self.match_lookahead_literal("(", 0) or self.match_lookahead_literal("false", 0)) or self.match_lookahead_literal("missing", 0)) or self.match_lookahead_literal("true", 0)) or self.match_lookahead_terminal("DECIMAL", 0)) or self.match_lookahead_terminal("FLOAT", 0)) or self.match_lookahead_terminal("FLOAT32", 0)) or self.match_lookahead_terminal("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("INT32", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("UINT128", 0)) or self.match_lookahead_terminal("UINT32", 0)) or self.match_lookahead_terminal("SYMBOL", 0)) - terms864 = xs861 + xs869 = [] + cond870 = (((((((((((((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 cond870: + _t1624 = self.parse_term() + item871 = _t1624 + xs869.append(item871) + cond870 = (((((((((((((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)) + terms872 = xs869 self.consume_literal(")") - return terms864 + return terms872 def parse_term(self) -> logic_pb2.Term: - span_start868 = self.span_start() + span_start876 = self.span_start() if self.match_lookahead_literal("true", 0): - _t1609 = 1 + _t1625 = 1 else: if self.match_lookahead_literal("missing", 0): - _t1610 = 1 + _t1626 = 1 else: if self.match_lookahead_literal("false", 0): - _t1611 = 1 + _t1627 = 1 else: if self.match_lookahead_literal("(", 0): - _t1612 = 1 + _t1628 = 1 else: if self.match_lookahead_terminal("SYMBOL", 0): - _t1613 = 0 + _t1629 = 0 else: if self.match_lookahead_terminal("UINT32", 0): - _t1614 = 1 + _t1630 = 1 else: if self.match_lookahead_terminal("UINT128", 0): - _t1615 = 1 + _t1631 = 1 else: if self.match_lookahead_terminal("STRING", 0): - _t1616 = 1 + _t1632 = 1 else: if self.match_lookahead_terminal("INT32", 0): - _t1617 = 1 + _t1633 = 1 else: if self.match_lookahead_terminal("INT128", 0): - _t1618 = 1 + _t1634 = 1 else: if self.match_lookahead_terminal("INT", 0): - _t1619 = 1 + _t1635 = 1 else: if self.match_lookahead_terminal("FLOAT32", 0): - _t1620 = 1 + _t1636 = 1 else: if self.match_lookahead_terminal("FLOAT", 0): - _t1621 = 1 + _t1637 = 1 else: if self.match_lookahead_terminal("DECIMAL", 0): - _t1622 = 1 + _t1638 = 1 else: - _t1622 = -1 - _t1621 = _t1622 - _t1620 = _t1621 - _t1619 = _t1620 - _t1618 = _t1619 - _t1617 = _t1618 - _t1616 = _t1617 - _t1615 = _t1616 - _t1614 = _t1615 - _t1613 = _t1614 - _t1612 = _t1613 - _t1611 = _t1612 - _t1610 = _t1611 - _t1609 = _t1610 - prediction865 = _t1609 - if prediction865 == 1: - _t1624 = self.parse_value() - value867 = _t1624 - _t1625 = logic_pb2.Term(constant=value867) - _t1623 = _t1625 - else: - if prediction865 == 0: - _t1627 = self.parse_var() - var866 = _t1627 - _t1628 = logic_pb2.Term(var=var866) - _t1626 = _t1628 + _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 + prediction873 = _t1625 + if prediction873 == 1: + _t1640 = self.parse_value() + value875 = _t1640 + _t1641 = logic_pb2.Term(constant=value875) + _t1639 = _t1641 + else: + if prediction873 == 0: + _t1643 = self.parse_var() + var874 = _t1643 + _t1644 = logic_pb2.Term(var=var874) + _t1642 = _t1644 else: raise ParseError("Unexpected token in term" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1623 = _t1626 - result869 = _t1623 - self.record_span(span_start868, "Term") - return result869 + _t1639 = _t1642 + result877 = _t1639 + self.record_span(span_start876, "Term") + return result877 def parse_var(self) -> logic_pb2.Var: - span_start871 = self.span_start() - symbol870 = self.consume_terminal("SYMBOL") - _t1629 = logic_pb2.Var(name=symbol870) - result872 = _t1629 - self.record_span(span_start871, "Var") - return result872 + span_start879 = self.span_start() + symbol878 = self.consume_terminal("SYMBOL") + _t1645 = logic_pb2.Var(name=symbol878) + result880 = _t1645 + self.record_span(span_start879, "Var") + return result880 def parse_value(self) -> logic_pb2.Value: - span_start886 = self.span_start() + span_start894 = self.span_start() if self.match_lookahead_literal("true", 0): - _t1630 = 12 + _t1646 = 12 else: if self.match_lookahead_literal("missing", 0): - _t1631 = 11 + _t1647 = 11 else: if self.match_lookahead_literal("false", 0): - _t1632 = 12 + _t1648 = 12 else: if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("datetime", 1): - _t1634 = 1 + _t1650 = 1 else: if self.match_lookahead_literal("date", 1): - _t1635 = 0 + _t1651 = 0 else: - _t1635 = -1 - _t1634 = _t1635 - _t1633 = _t1634 + _t1651 = -1 + _t1650 = _t1651 + _t1649 = _t1650 else: if self.match_lookahead_terminal("UINT32", 0): - _t1636 = 7 + _t1652 = 7 else: if self.match_lookahead_terminal("UINT128", 0): - _t1637 = 8 + _t1653 = 8 else: if self.match_lookahead_terminal("STRING", 0): - _t1638 = 2 + _t1654 = 2 else: if self.match_lookahead_terminal("INT32", 0): - _t1639 = 3 + _t1655 = 3 else: if self.match_lookahead_terminal("INT128", 0): - _t1640 = 9 + _t1656 = 9 else: if self.match_lookahead_terminal("INT", 0): - _t1641 = 4 + _t1657 = 4 else: if self.match_lookahead_terminal("FLOAT32", 0): - _t1642 = 5 + _t1658 = 5 else: if self.match_lookahead_terminal("FLOAT", 0): - _t1643 = 6 + _t1659 = 6 else: if self.match_lookahead_terminal("DECIMAL", 0): - _t1644 = 10 + _t1660 = 10 else: - _t1644 = -1 - _t1643 = _t1644 - _t1642 = _t1643 - _t1641 = _t1642 - _t1640 = _t1641 - _t1639 = _t1640 - _t1638 = _t1639 - _t1637 = _t1638 - _t1636 = _t1637 - _t1633 = _t1636 - _t1632 = _t1633 - _t1631 = _t1632 - _t1630 = _t1631 - prediction873 = _t1630 - if prediction873 == 12: - _t1646 = self.parse_boolean_value() - boolean_value885 = _t1646 - _t1647 = logic_pb2.Value(boolean_value=boolean_value885) - _t1645 = _t1647 - else: - if prediction873 == 11: + _t1660 = -1 + _t1659 = _t1660 + _t1658 = _t1659 + _t1657 = _t1658 + _t1656 = _t1657 + _t1655 = _t1656 + _t1654 = _t1655 + _t1653 = _t1654 + _t1652 = _t1653 + _t1649 = _t1652 + _t1648 = _t1649 + _t1647 = _t1648 + _t1646 = _t1647 + prediction881 = _t1646 + if prediction881 == 12: + _t1662 = self.parse_boolean_value() + boolean_value893 = _t1662 + _t1663 = logic_pb2.Value(boolean_value=boolean_value893) + _t1661 = _t1663 + else: + if prediction881 == 11: self.consume_literal("missing") - _t1649 = logic_pb2.MissingValue() - _t1650 = logic_pb2.Value(missing_value=_t1649) - _t1648 = _t1650 + _t1665 = logic_pb2.MissingValue() + _t1666 = logic_pb2.Value(missing_value=_t1665) + _t1664 = _t1666 else: - if prediction873 == 10: - formatted_decimal884 = self.consume_terminal("DECIMAL") - _t1652 = logic_pb2.Value(decimal_value=formatted_decimal884) - _t1651 = _t1652 + if prediction881 == 10: + formatted_decimal892 = self.consume_terminal("DECIMAL") + _t1668 = logic_pb2.Value(decimal_value=formatted_decimal892) + _t1667 = _t1668 else: - if prediction873 == 9: - formatted_int128883 = self.consume_terminal("INT128") - _t1654 = logic_pb2.Value(int128_value=formatted_int128883) - _t1653 = _t1654 + if prediction881 == 9: + formatted_int128891 = self.consume_terminal("INT128") + _t1670 = logic_pb2.Value(int128_value=formatted_int128891) + _t1669 = _t1670 else: - if prediction873 == 8: - formatted_uint128882 = self.consume_terminal("UINT128") - _t1656 = logic_pb2.Value(uint128_value=formatted_uint128882) - _t1655 = _t1656 + if prediction881 == 8: + formatted_uint128890 = self.consume_terminal("UINT128") + _t1672 = logic_pb2.Value(uint128_value=formatted_uint128890) + _t1671 = _t1672 else: - if prediction873 == 7: - formatted_uint32881 = self.consume_terminal("UINT32") - _t1658 = logic_pb2.Value(uint32_value=formatted_uint32881) - _t1657 = _t1658 + if prediction881 == 7: + formatted_uint32889 = self.consume_terminal("UINT32") + _t1674 = logic_pb2.Value(uint32_value=formatted_uint32889) + _t1673 = _t1674 else: - if prediction873 == 6: - formatted_float880 = self.consume_terminal("FLOAT") - _t1660 = logic_pb2.Value(float_value=formatted_float880) - _t1659 = _t1660 + if prediction881 == 6: + formatted_float888 = self.consume_terminal("FLOAT") + _t1676 = logic_pb2.Value(float_value=formatted_float888) + _t1675 = _t1676 else: - if prediction873 == 5: - formatted_float32879 = self.consume_terminal("FLOAT32") - _t1662 = logic_pb2.Value(float32_value=formatted_float32879) - _t1661 = _t1662 + if prediction881 == 5: + formatted_float32887 = self.consume_terminal("FLOAT32") + _t1678 = logic_pb2.Value(float32_value=formatted_float32887) + _t1677 = _t1678 else: - if prediction873 == 4: - formatted_int878 = self.consume_terminal("INT") - _t1664 = logic_pb2.Value(int_value=formatted_int878) - _t1663 = _t1664 + if prediction881 == 4: + formatted_int886 = self.consume_terminal("INT") + _t1680 = logic_pb2.Value(int_value=formatted_int886) + _t1679 = _t1680 else: - if prediction873 == 3: - formatted_int32877 = self.consume_terminal("INT32") - _t1666 = logic_pb2.Value(int32_value=formatted_int32877) - _t1665 = _t1666 + if prediction881 == 3: + formatted_int32885 = self.consume_terminal("INT32") + _t1682 = logic_pb2.Value(int32_value=formatted_int32885) + _t1681 = _t1682 else: - if prediction873 == 2: - formatted_string876 = self.consume_terminal("STRING") - _t1668 = logic_pb2.Value(string_value=formatted_string876) - _t1667 = _t1668 + if prediction881 == 2: + formatted_string884 = self.consume_terminal("STRING") + _t1684 = logic_pb2.Value(string_value=formatted_string884) + _t1683 = _t1684 else: - if prediction873 == 1: - _t1670 = self.parse_datetime() - datetime875 = _t1670 - _t1671 = logic_pb2.Value(datetime_value=datetime875) - _t1669 = _t1671 + if prediction881 == 1: + _t1686 = self.parse_datetime() + datetime883 = _t1686 + _t1687 = logic_pb2.Value(datetime_value=datetime883) + _t1685 = _t1687 else: - if prediction873 == 0: - _t1673 = self.parse_date() - date874 = _t1673 - _t1674 = logic_pb2.Value(date_value=date874) - _t1672 = _t1674 + if prediction881 == 0: + _t1689 = self.parse_date() + date882 = _t1689 + _t1690 = logic_pb2.Value(date_value=date882) + _t1688 = _t1690 else: raise ParseError("Unexpected token in value" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1669 = _t1672 - _t1667 = _t1669 - _t1665 = _t1667 - _t1663 = _t1665 - _t1661 = _t1663 - _t1659 = _t1661 - _t1657 = _t1659 - _t1655 = _t1657 - _t1653 = _t1655 - _t1651 = _t1653 - _t1648 = _t1651 - _t1645 = _t1648 - result887 = _t1645 - self.record_span(span_start886, "Value") - return result887 + _t1685 = _t1688 + _t1683 = _t1685 + _t1681 = _t1683 + _t1679 = _t1681 + _t1677 = _t1679 + _t1675 = _t1677 + _t1673 = _t1675 + _t1671 = _t1673 + _t1669 = _t1671 + _t1667 = _t1669 + _t1664 = _t1667 + _t1661 = _t1664 + result895 = _t1661 + self.record_span(span_start894, "Value") + return result895 def parse_date(self) -> logic_pb2.DateValue: - span_start891 = self.span_start() + span_start899 = self.span_start() self.consume_literal("(") self.consume_literal("date") - formatted_int888 = self.consume_terminal("INT") - formatted_int_3889 = self.consume_terminal("INT") - formatted_int_4890 = self.consume_terminal("INT") + formatted_int896 = self.consume_terminal("INT") + formatted_int_3897 = self.consume_terminal("INT") + formatted_int_4898 = self.consume_terminal("INT") self.consume_literal(")") - _t1675 = logic_pb2.DateValue(year=int(formatted_int888), month=int(formatted_int_3889), day=int(formatted_int_4890)) - result892 = _t1675 - self.record_span(span_start891, "DateValue") - return result892 + _t1691 = logic_pb2.DateValue(year=int(formatted_int896), month=int(formatted_int_3897), day=int(formatted_int_4898)) + result900 = _t1691 + self.record_span(span_start899, "DateValue") + return result900 def parse_datetime(self) -> logic_pb2.DateTimeValue: - span_start900 = self.span_start() + span_start908 = self.span_start() self.consume_literal("(") self.consume_literal("datetime") - formatted_int893 = self.consume_terminal("INT") - formatted_int_3894 = self.consume_terminal("INT") - formatted_int_4895 = self.consume_terminal("INT") - formatted_int_5896 = self.consume_terminal("INT") - formatted_int_6897 = self.consume_terminal("INT") - formatted_int_7898 = self.consume_terminal("INT") + formatted_int901 = self.consume_terminal("INT") + formatted_int_3902 = self.consume_terminal("INT") + formatted_int_4903 = self.consume_terminal("INT") + formatted_int_5904 = self.consume_terminal("INT") + formatted_int_6905 = self.consume_terminal("INT") + formatted_int_7906 = self.consume_terminal("INT") if self.match_lookahead_terminal("INT", 0): - _t1676 = self.consume_terminal("INT") + _t1692 = self.consume_terminal("INT") else: - _t1676 = None - formatted_int_8899 = _t1676 + _t1692 = None + formatted_int_8907 = _t1692 self.consume_literal(")") - _t1677 = logic_pb2.DateTimeValue(year=int(formatted_int893), month=int(formatted_int_3894), day=int(formatted_int_4895), hour=int(formatted_int_5896), minute=int(formatted_int_6897), second=int(formatted_int_7898), microsecond=int((formatted_int_8899 if formatted_int_8899 is not None else 0))) - result901 = _t1677 - self.record_span(span_start900, "DateTimeValue") - return result901 + _t1693 = logic_pb2.DateTimeValue(year=int(formatted_int901), month=int(formatted_int_3902), day=int(formatted_int_4903), hour=int(formatted_int_5904), minute=int(formatted_int_6905), second=int(formatted_int_7906), microsecond=int((formatted_int_8907 if formatted_int_8907 is not None else 0))) + result909 = _t1693 + self.record_span(span_start908, "DateTimeValue") + return result909 def parse_conjunction(self) -> logic_pb2.Conjunction: - span_start906 = self.span_start() + span_start914 = self.span_start() self.consume_literal("(") self.consume_literal("and") - xs902 = [] - cond903 = self.match_lookahead_literal("(", 0) - while cond903: - _t1678 = self.parse_formula() - item904 = _t1678 - xs902.append(item904) - cond903 = self.match_lookahead_literal("(", 0) - formulas905 = xs902 - self.consume_literal(")") - _t1679 = logic_pb2.Conjunction(args=formulas905) - result907 = _t1679 - self.record_span(span_start906, "Conjunction") - return result907 + xs910 = [] + cond911 = self.match_lookahead_literal("(", 0) + while cond911: + _t1694 = self.parse_formula() + item912 = _t1694 + xs910.append(item912) + cond911 = self.match_lookahead_literal("(", 0) + formulas913 = xs910 + self.consume_literal(")") + _t1695 = logic_pb2.Conjunction(args=formulas913) + result915 = _t1695 + self.record_span(span_start914, "Conjunction") + return result915 def parse_disjunction(self) -> logic_pb2.Disjunction: - span_start912 = self.span_start() + span_start920 = self.span_start() self.consume_literal("(") self.consume_literal("or") - xs908 = [] - cond909 = self.match_lookahead_literal("(", 0) - while cond909: - _t1680 = self.parse_formula() - item910 = _t1680 - xs908.append(item910) - cond909 = self.match_lookahead_literal("(", 0) - formulas911 = xs908 - self.consume_literal(")") - _t1681 = logic_pb2.Disjunction(args=formulas911) - result913 = _t1681 - self.record_span(span_start912, "Disjunction") - return result913 + xs916 = [] + cond917 = self.match_lookahead_literal("(", 0) + while cond917: + _t1696 = self.parse_formula() + item918 = _t1696 + xs916.append(item918) + cond917 = self.match_lookahead_literal("(", 0) + formulas919 = xs916 + self.consume_literal(")") + _t1697 = logic_pb2.Disjunction(args=formulas919) + result921 = _t1697 + self.record_span(span_start920, "Disjunction") + return result921 def parse_not(self) -> logic_pb2.Not: - span_start915 = self.span_start() + span_start923 = self.span_start() self.consume_literal("(") self.consume_literal("not") - _t1682 = self.parse_formula() - formula914 = _t1682 + _t1698 = self.parse_formula() + formula922 = _t1698 self.consume_literal(")") - _t1683 = logic_pb2.Not(arg=formula914) - result916 = _t1683 - self.record_span(span_start915, "Not") - return result916 + _t1699 = logic_pb2.Not(arg=formula922) + result924 = _t1699 + self.record_span(span_start923, "Not") + return result924 def parse_ffi(self) -> logic_pb2.FFI: - span_start920 = self.span_start() + span_start928 = self.span_start() self.consume_literal("(") self.consume_literal("ffi") - _t1684 = self.parse_name() - name917 = _t1684 - _t1685 = self.parse_ffi_args() - ffi_args918 = _t1685 - _t1686 = self.parse_terms() - terms919 = _t1686 - self.consume_literal(")") - _t1687 = logic_pb2.FFI(name=name917, args=ffi_args918, terms=terms919) - result921 = _t1687 - self.record_span(span_start920, "FFI") - return result921 + _t1700 = self.parse_name() + name925 = _t1700 + _t1701 = self.parse_ffi_args() + ffi_args926 = _t1701 + _t1702 = self.parse_terms() + terms927 = _t1702 + self.consume_literal(")") + _t1703 = logic_pb2.FFI(name=name925, args=ffi_args926, terms=terms927) + result929 = _t1703 + self.record_span(span_start928, "FFI") + return result929 def parse_name(self) -> str: self.consume_literal(":") - symbol922 = self.consume_terminal("SYMBOL") - return symbol922 + symbol930 = self.consume_terminal("SYMBOL") + return symbol930 def parse_ffi_args(self) -> Sequence[logic_pb2.Abstraction]: self.consume_literal("(") self.consume_literal("args") - xs923 = [] - cond924 = self.match_lookahead_literal("(", 0) - while cond924: - _t1688 = self.parse_abstraction() - item925 = _t1688 - xs923.append(item925) - cond924 = self.match_lookahead_literal("(", 0) - abstractions926 = xs923 + xs931 = [] + cond932 = self.match_lookahead_literal("(", 0) + while cond932: + _t1704 = self.parse_abstraction() + item933 = _t1704 + xs931.append(item933) + cond932 = self.match_lookahead_literal("(", 0) + abstractions934 = xs931 self.consume_literal(")") - return abstractions926 + return abstractions934 def parse_atom(self) -> logic_pb2.Atom: - span_start932 = self.span_start() + span_start940 = self.span_start() self.consume_literal("(") self.consume_literal("atom") - _t1689 = self.parse_relation_id() - relation_id927 = _t1689 - xs928 = [] - cond929 = (((((((((((((self.match_lookahead_literal("(", 0) or self.match_lookahead_literal("false", 0)) or self.match_lookahead_literal("missing", 0)) or self.match_lookahead_literal("true", 0)) or self.match_lookahead_terminal("DECIMAL", 0)) or self.match_lookahead_terminal("FLOAT", 0)) or self.match_lookahead_terminal("FLOAT32", 0)) or self.match_lookahead_terminal("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("INT32", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("UINT128", 0)) or self.match_lookahead_terminal("UINT32", 0)) or self.match_lookahead_terminal("SYMBOL", 0)) - while cond929: - _t1690 = self.parse_term() - item930 = _t1690 - xs928.append(item930) - cond929 = (((((((((((((self.match_lookahead_literal("(", 0) or self.match_lookahead_literal("false", 0)) or self.match_lookahead_literal("missing", 0)) or self.match_lookahead_literal("true", 0)) or self.match_lookahead_terminal("DECIMAL", 0)) or self.match_lookahead_terminal("FLOAT", 0)) or self.match_lookahead_terminal("FLOAT32", 0)) or self.match_lookahead_terminal("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("INT32", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("UINT128", 0)) or self.match_lookahead_terminal("UINT32", 0)) or self.match_lookahead_terminal("SYMBOL", 0)) - terms931 = xs928 - self.consume_literal(")") - _t1691 = logic_pb2.Atom(name=relation_id927, terms=terms931) - result933 = _t1691 - self.record_span(span_start932, "Atom") - return result933 + _t1705 = self.parse_relation_id() + relation_id935 = _t1705 + xs936 = [] + cond937 = (((((((((((((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 cond937: + _t1706 = self.parse_term() + item938 = _t1706 + xs936.append(item938) + cond937 = (((((((((((((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)) + terms939 = xs936 + self.consume_literal(")") + _t1707 = logic_pb2.Atom(name=relation_id935, terms=terms939) + result941 = _t1707 + self.record_span(span_start940, "Atom") + return result941 def parse_pragma(self) -> logic_pb2.Pragma: - span_start939 = self.span_start() + span_start947 = self.span_start() self.consume_literal("(") self.consume_literal("pragma") - _t1692 = self.parse_name() - name934 = _t1692 - xs935 = [] - cond936 = (((((((((((((self.match_lookahead_literal("(", 0) or self.match_lookahead_literal("false", 0)) or self.match_lookahead_literal("missing", 0)) or self.match_lookahead_literal("true", 0)) or self.match_lookahead_terminal("DECIMAL", 0)) or self.match_lookahead_terminal("FLOAT", 0)) or self.match_lookahead_terminal("FLOAT32", 0)) or self.match_lookahead_terminal("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("INT32", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("UINT128", 0)) or self.match_lookahead_terminal("UINT32", 0)) or self.match_lookahead_terminal("SYMBOL", 0)) - while cond936: - _t1693 = self.parse_term() - item937 = _t1693 - xs935.append(item937) - cond936 = (((((((((((((self.match_lookahead_literal("(", 0) or self.match_lookahead_literal("false", 0)) or self.match_lookahead_literal("missing", 0)) or self.match_lookahead_literal("true", 0)) or self.match_lookahead_terminal("DECIMAL", 0)) or self.match_lookahead_terminal("FLOAT", 0)) or self.match_lookahead_terminal("FLOAT32", 0)) or self.match_lookahead_terminal("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("INT32", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("UINT128", 0)) or self.match_lookahead_terminal("UINT32", 0)) or self.match_lookahead_terminal("SYMBOL", 0)) - terms938 = xs935 - self.consume_literal(")") - _t1694 = logic_pb2.Pragma(name=name934, terms=terms938) - result940 = _t1694 - self.record_span(span_start939, "Pragma") - return result940 + _t1708 = self.parse_name() + name942 = _t1708 + xs943 = [] + cond944 = (((((((((((((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 cond944: + _t1709 = self.parse_term() + item945 = _t1709 + xs943.append(item945) + cond944 = (((((((((((((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)) + terms946 = xs943 + self.consume_literal(")") + _t1710 = logic_pb2.Pragma(name=name942, terms=terms946) + result948 = _t1710 + self.record_span(span_start947, "Pragma") + return result948 def parse_primitive(self) -> logic_pb2.Primitive: - span_start956 = self.span_start() + span_start964 = self.span_start() if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("primitive", 1): - _t1696 = 9 + _t1712 = 9 else: if self.match_lookahead_literal(">=", 1): - _t1697 = 4 + _t1713 = 4 else: if self.match_lookahead_literal(">", 1): - _t1698 = 3 + _t1714 = 3 else: if self.match_lookahead_literal("=", 1): - _t1699 = 0 + _t1715 = 0 else: if self.match_lookahead_literal("<=", 1): - _t1700 = 2 + _t1716 = 2 else: if self.match_lookahead_literal("<", 1): - _t1701 = 1 + _t1717 = 1 else: if self.match_lookahead_literal("/", 1): - _t1702 = 8 + _t1718 = 8 else: if self.match_lookahead_literal("-", 1): - _t1703 = 6 + _t1719 = 6 else: if self.match_lookahead_literal("+", 1): - _t1704 = 5 + _t1720 = 5 else: if self.match_lookahead_literal("*", 1): - _t1705 = 7 + _t1721 = 7 else: - _t1705 = -1 - _t1704 = _t1705 - _t1703 = _t1704 - _t1702 = _t1703 - _t1701 = _t1702 - _t1700 = _t1701 - _t1699 = _t1700 - _t1698 = _t1699 - _t1697 = _t1698 - _t1696 = _t1697 - _t1695 = _t1696 - else: - _t1695 = -1 - prediction941 = _t1695 - if prediction941 == 9: + _t1721 = -1 + _t1720 = _t1721 + _t1719 = _t1720 + _t1718 = _t1719 + _t1717 = _t1718 + _t1716 = _t1717 + _t1715 = _t1716 + _t1714 = _t1715 + _t1713 = _t1714 + _t1712 = _t1713 + _t1711 = _t1712 + else: + _t1711 = -1 + prediction949 = _t1711 + if prediction949 == 9: self.consume_literal("(") self.consume_literal("primitive") - _t1707 = self.parse_name() - name951 = _t1707 - xs952 = [] - cond953 = ((((((((((((((self.match_lookahead_literal("#", 0) or self.match_lookahead_literal("(", 0)) or self.match_lookahead_literal("false", 0)) or self.match_lookahead_literal("missing", 0)) or self.match_lookahead_literal("true", 0)) or self.match_lookahead_terminal("DECIMAL", 0)) or self.match_lookahead_terminal("FLOAT", 0)) or self.match_lookahead_terminal("FLOAT32", 0)) or self.match_lookahead_terminal("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("INT32", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("UINT128", 0)) or self.match_lookahead_terminal("UINT32", 0)) or self.match_lookahead_terminal("SYMBOL", 0)) - while cond953: - _t1708 = self.parse_rel_term() - item954 = _t1708 - xs952.append(item954) - cond953 = ((((((((((((((self.match_lookahead_literal("#", 0) or self.match_lookahead_literal("(", 0)) or self.match_lookahead_literal("false", 0)) or self.match_lookahead_literal("missing", 0)) or self.match_lookahead_literal("true", 0)) or self.match_lookahead_terminal("DECIMAL", 0)) or self.match_lookahead_terminal("FLOAT", 0)) or self.match_lookahead_terminal("FLOAT32", 0)) or self.match_lookahead_terminal("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("INT32", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("UINT128", 0)) or self.match_lookahead_terminal("UINT32", 0)) or self.match_lookahead_terminal("SYMBOL", 0)) - rel_terms955 = xs952 + _t1723 = self.parse_name() + name959 = _t1723 + xs960 = [] + cond961 = ((((((((((((((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 cond961: + _t1724 = self.parse_rel_term() + item962 = _t1724 + xs960.append(item962) + cond961 = ((((((((((((((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_terms963 = xs960 self.consume_literal(")") - _t1709 = logic_pb2.Primitive(name=name951, terms=rel_terms955) - _t1706 = _t1709 + _t1725 = logic_pb2.Primitive(name=name959, terms=rel_terms963) + _t1722 = _t1725 else: - if prediction941 == 8: - _t1711 = self.parse_divide() - divide950 = _t1711 - _t1710 = divide950 + if prediction949 == 8: + _t1727 = self.parse_divide() + divide958 = _t1727 + _t1726 = divide958 else: - if prediction941 == 7: - _t1713 = self.parse_multiply() - multiply949 = _t1713 - _t1712 = multiply949 + if prediction949 == 7: + _t1729 = self.parse_multiply() + multiply957 = _t1729 + _t1728 = multiply957 else: - if prediction941 == 6: - _t1715 = self.parse_minus() - minus948 = _t1715 - _t1714 = minus948 + if prediction949 == 6: + _t1731 = self.parse_minus() + minus956 = _t1731 + _t1730 = minus956 else: - if prediction941 == 5: - _t1717 = self.parse_add() - add947 = _t1717 - _t1716 = add947 + if prediction949 == 5: + _t1733 = self.parse_add() + add955 = _t1733 + _t1732 = add955 else: - if prediction941 == 4: - _t1719 = self.parse_gt_eq() - gt_eq946 = _t1719 - _t1718 = gt_eq946 + if prediction949 == 4: + _t1735 = self.parse_gt_eq() + gt_eq954 = _t1735 + _t1734 = gt_eq954 else: - if prediction941 == 3: - _t1721 = self.parse_gt() - gt945 = _t1721 - _t1720 = gt945 + if prediction949 == 3: + _t1737 = self.parse_gt() + gt953 = _t1737 + _t1736 = gt953 else: - if prediction941 == 2: - _t1723 = self.parse_lt_eq() - lt_eq944 = _t1723 - _t1722 = lt_eq944 + if prediction949 == 2: + _t1739 = self.parse_lt_eq() + lt_eq952 = _t1739 + _t1738 = lt_eq952 else: - if prediction941 == 1: - _t1725 = self.parse_lt() - lt943 = _t1725 - _t1724 = lt943 + if prediction949 == 1: + _t1741 = self.parse_lt() + lt951 = _t1741 + _t1740 = lt951 else: - if prediction941 == 0: - _t1727 = self.parse_eq() - eq942 = _t1727 - _t1726 = eq942 + if prediction949 == 0: + _t1743 = self.parse_eq() + eq950 = _t1743 + _t1742 = eq950 else: raise ParseError("Unexpected token in primitive" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1724 = _t1726 - _t1722 = _t1724 - _t1720 = _t1722 - _t1718 = _t1720 - _t1716 = _t1718 - _t1714 = _t1716 - _t1712 = _t1714 - _t1710 = _t1712 - _t1706 = _t1710 - result957 = _t1706 - self.record_span(span_start956, "Primitive") - return result957 + _t1740 = _t1742 + _t1738 = _t1740 + _t1736 = _t1738 + _t1734 = _t1736 + _t1732 = _t1734 + _t1730 = _t1732 + _t1728 = _t1730 + _t1726 = _t1728 + _t1722 = _t1726 + result965 = _t1722 + self.record_span(span_start964, "Primitive") + return result965 def parse_eq(self) -> logic_pb2.Primitive: - span_start960 = self.span_start() + span_start968 = self.span_start() self.consume_literal("(") self.consume_literal("=") - _t1728 = self.parse_term() - term958 = _t1728 - _t1729 = self.parse_term() - term_3959 = _t1729 - self.consume_literal(")") - _t1730 = logic_pb2.RelTerm(term=term958) - _t1731 = logic_pb2.RelTerm(term=term_3959) - _t1732 = logic_pb2.Primitive(name="rel_primitive_eq", terms=[_t1730, _t1731]) - result961 = _t1732 - self.record_span(span_start960, "Primitive") - return result961 + _t1744 = self.parse_term() + term966 = _t1744 + _t1745 = self.parse_term() + term_3967 = _t1745 + self.consume_literal(")") + _t1746 = logic_pb2.RelTerm(term=term966) + _t1747 = logic_pb2.RelTerm(term=term_3967) + _t1748 = logic_pb2.Primitive(name="rel_primitive_eq", terms=[_t1746, _t1747]) + result969 = _t1748 + self.record_span(span_start968, "Primitive") + return result969 def parse_lt(self) -> logic_pb2.Primitive: - span_start964 = self.span_start() + span_start972 = self.span_start() self.consume_literal("(") self.consume_literal("<") - _t1733 = self.parse_term() - term962 = _t1733 - _t1734 = self.parse_term() - term_3963 = _t1734 - self.consume_literal(")") - _t1735 = logic_pb2.RelTerm(term=term962) - _t1736 = logic_pb2.RelTerm(term=term_3963) - _t1737 = logic_pb2.Primitive(name="rel_primitive_lt_monotype", terms=[_t1735, _t1736]) - result965 = _t1737 - self.record_span(span_start964, "Primitive") - return result965 + _t1749 = self.parse_term() + term970 = _t1749 + _t1750 = self.parse_term() + term_3971 = _t1750 + self.consume_literal(")") + _t1751 = logic_pb2.RelTerm(term=term970) + _t1752 = logic_pb2.RelTerm(term=term_3971) + _t1753 = logic_pb2.Primitive(name="rel_primitive_lt_monotype", terms=[_t1751, _t1752]) + result973 = _t1753 + self.record_span(span_start972, "Primitive") + return result973 def parse_lt_eq(self) -> logic_pb2.Primitive: - span_start968 = self.span_start() + span_start976 = self.span_start() self.consume_literal("(") self.consume_literal("<=") - _t1738 = self.parse_term() - term966 = _t1738 - _t1739 = self.parse_term() - term_3967 = _t1739 - self.consume_literal(")") - _t1740 = logic_pb2.RelTerm(term=term966) - _t1741 = logic_pb2.RelTerm(term=term_3967) - _t1742 = logic_pb2.Primitive(name="rel_primitive_lt_eq_monotype", terms=[_t1740, _t1741]) - result969 = _t1742 - self.record_span(span_start968, "Primitive") - return result969 + _t1754 = self.parse_term() + term974 = _t1754 + _t1755 = self.parse_term() + term_3975 = _t1755 + self.consume_literal(")") + _t1756 = logic_pb2.RelTerm(term=term974) + _t1757 = logic_pb2.RelTerm(term=term_3975) + _t1758 = logic_pb2.Primitive(name="rel_primitive_lt_eq_monotype", terms=[_t1756, _t1757]) + result977 = _t1758 + self.record_span(span_start976, "Primitive") + return result977 def parse_gt(self) -> logic_pb2.Primitive: - span_start972 = self.span_start() + span_start980 = self.span_start() self.consume_literal("(") self.consume_literal(">") - _t1743 = self.parse_term() - term970 = _t1743 - _t1744 = self.parse_term() - term_3971 = _t1744 + _t1759 = self.parse_term() + term978 = _t1759 + _t1760 = self.parse_term() + term_3979 = _t1760 self.consume_literal(")") - _t1745 = logic_pb2.RelTerm(term=term970) - _t1746 = logic_pb2.RelTerm(term=term_3971) - _t1747 = logic_pb2.Primitive(name="rel_primitive_gt_monotype", terms=[_t1745, _t1746]) - result973 = _t1747 - self.record_span(span_start972, "Primitive") - return result973 + _t1761 = logic_pb2.RelTerm(term=term978) + _t1762 = logic_pb2.RelTerm(term=term_3979) + _t1763 = logic_pb2.Primitive(name="rel_primitive_gt_monotype", terms=[_t1761, _t1762]) + result981 = _t1763 + self.record_span(span_start980, "Primitive") + return result981 def parse_gt_eq(self) -> logic_pb2.Primitive: - span_start976 = self.span_start() + span_start984 = self.span_start() self.consume_literal("(") self.consume_literal(">=") - _t1748 = self.parse_term() - term974 = _t1748 - _t1749 = self.parse_term() - term_3975 = _t1749 - self.consume_literal(")") - _t1750 = logic_pb2.RelTerm(term=term974) - _t1751 = logic_pb2.RelTerm(term=term_3975) - _t1752 = logic_pb2.Primitive(name="rel_primitive_gt_eq_monotype", terms=[_t1750, _t1751]) - result977 = _t1752 - self.record_span(span_start976, "Primitive") - return result977 + _t1764 = self.parse_term() + term982 = _t1764 + _t1765 = self.parse_term() + term_3983 = _t1765 + self.consume_literal(")") + _t1766 = logic_pb2.RelTerm(term=term982) + _t1767 = logic_pb2.RelTerm(term=term_3983) + _t1768 = logic_pb2.Primitive(name="rel_primitive_gt_eq_monotype", terms=[_t1766, _t1767]) + result985 = _t1768 + self.record_span(span_start984, "Primitive") + return result985 def parse_add(self) -> logic_pb2.Primitive: - span_start981 = self.span_start() + span_start989 = self.span_start() self.consume_literal("(") self.consume_literal("+") - _t1753 = self.parse_term() - term978 = _t1753 - _t1754 = self.parse_term() - term_3979 = _t1754 - _t1755 = self.parse_term() - term_4980 = _t1755 - self.consume_literal(")") - _t1756 = logic_pb2.RelTerm(term=term978) - _t1757 = logic_pb2.RelTerm(term=term_3979) - _t1758 = logic_pb2.RelTerm(term=term_4980) - _t1759 = logic_pb2.Primitive(name="rel_primitive_add_monotype", terms=[_t1756, _t1757, _t1758]) - result982 = _t1759 - self.record_span(span_start981, "Primitive") - return result982 + _t1769 = self.parse_term() + term986 = _t1769 + _t1770 = self.parse_term() + term_3987 = _t1770 + _t1771 = self.parse_term() + term_4988 = _t1771 + self.consume_literal(")") + _t1772 = logic_pb2.RelTerm(term=term986) + _t1773 = logic_pb2.RelTerm(term=term_3987) + _t1774 = logic_pb2.RelTerm(term=term_4988) + _t1775 = logic_pb2.Primitive(name="rel_primitive_add_monotype", terms=[_t1772, _t1773, _t1774]) + result990 = _t1775 + self.record_span(span_start989, "Primitive") + return result990 def parse_minus(self) -> logic_pb2.Primitive: - span_start986 = self.span_start() + span_start994 = self.span_start() self.consume_literal("(") self.consume_literal("-") - _t1760 = self.parse_term() - term983 = _t1760 - _t1761 = self.parse_term() - term_3984 = _t1761 - _t1762 = self.parse_term() - term_4985 = _t1762 - self.consume_literal(")") - _t1763 = logic_pb2.RelTerm(term=term983) - _t1764 = logic_pb2.RelTerm(term=term_3984) - _t1765 = logic_pb2.RelTerm(term=term_4985) - _t1766 = logic_pb2.Primitive(name="rel_primitive_subtract_monotype", terms=[_t1763, _t1764, _t1765]) - result987 = _t1766 - self.record_span(span_start986, "Primitive") - return result987 + _t1776 = self.parse_term() + term991 = _t1776 + _t1777 = self.parse_term() + term_3992 = _t1777 + _t1778 = self.parse_term() + term_4993 = _t1778 + self.consume_literal(")") + _t1779 = logic_pb2.RelTerm(term=term991) + _t1780 = logic_pb2.RelTerm(term=term_3992) + _t1781 = logic_pb2.RelTerm(term=term_4993) + _t1782 = logic_pb2.Primitive(name="rel_primitive_subtract_monotype", terms=[_t1779, _t1780, _t1781]) + result995 = _t1782 + self.record_span(span_start994, "Primitive") + return result995 def parse_multiply(self) -> logic_pb2.Primitive: - span_start991 = self.span_start() + span_start999 = self.span_start() self.consume_literal("(") self.consume_literal("*") - _t1767 = self.parse_term() - term988 = _t1767 - _t1768 = self.parse_term() - term_3989 = _t1768 - _t1769 = self.parse_term() - term_4990 = _t1769 - self.consume_literal(")") - _t1770 = logic_pb2.RelTerm(term=term988) - _t1771 = logic_pb2.RelTerm(term=term_3989) - _t1772 = logic_pb2.RelTerm(term=term_4990) - _t1773 = logic_pb2.Primitive(name="rel_primitive_multiply_monotype", terms=[_t1770, _t1771, _t1772]) - result992 = _t1773 - self.record_span(span_start991, "Primitive") - return result992 + _t1783 = self.parse_term() + term996 = _t1783 + _t1784 = self.parse_term() + term_3997 = _t1784 + _t1785 = self.parse_term() + term_4998 = _t1785 + self.consume_literal(")") + _t1786 = logic_pb2.RelTerm(term=term996) + _t1787 = logic_pb2.RelTerm(term=term_3997) + _t1788 = logic_pb2.RelTerm(term=term_4998) + _t1789 = logic_pb2.Primitive(name="rel_primitive_multiply_monotype", terms=[_t1786, _t1787, _t1788]) + result1000 = _t1789 + self.record_span(span_start999, "Primitive") + return result1000 def parse_divide(self) -> logic_pb2.Primitive: - span_start996 = self.span_start() + span_start1004 = self.span_start() self.consume_literal("(") self.consume_literal("/") - _t1774 = self.parse_term() - term993 = _t1774 - _t1775 = self.parse_term() - term_3994 = _t1775 - _t1776 = self.parse_term() - term_4995 = _t1776 - self.consume_literal(")") - _t1777 = logic_pb2.RelTerm(term=term993) - _t1778 = logic_pb2.RelTerm(term=term_3994) - _t1779 = logic_pb2.RelTerm(term=term_4995) - _t1780 = logic_pb2.Primitive(name="rel_primitive_divide_monotype", terms=[_t1777, _t1778, _t1779]) - result997 = _t1780 - self.record_span(span_start996, "Primitive") - return result997 + _t1790 = self.parse_term() + term1001 = _t1790 + _t1791 = self.parse_term() + term_31002 = _t1791 + _t1792 = self.parse_term() + term_41003 = _t1792 + self.consume_literal(")") + _t1793 = logic_pb2.RelTerm(term=term1001) + _t1794 = logic_pb2.RelTerm(term=term_31002) + _t1795 = logic_pb2.RelTerm(term=term_41003) + _t1796 = logic_pb2.Primitive(name="rel_primitive_divide_monotype", terms=[_t1793, _t1794, _t1795]) + result1005 = _t1796 + self.record_span(span_start1004, "Primitive") + return result1005 def parse_rel_term(self) -> logic_pb2.RelTerm: - span_start1001 = self.span_start() + span_start1009 = self.span_start() if self.match_lookahead_literal("true", 0): - _t1781 = 1 + _t1797 = 1 else: if self.match_lookahead_literal("missing", 0): - _t1782 = 1 + _t1798 = 1 else: if self.match_lookahead_literal("false", 0): - _t1783 = 1 + _t1799 = 1 else: if self.match_lookahead_literal("(", 0): - _t1784 = 1 + _t1800 = 1 else: if self.match_lookahead_literal("#", 0): - _t1785 = 0 + _t1801 = 0 else: if self.match_lookahead_terminal("SYMBOL", 0): - _t1786 = 1 + _t1802 = 1 else: if self.match_lookahead_terminal("UINT32", 0): - _t1787 = 1 + _t1803 = 1 else: if self.match_lookahead_terminal("UINT128", 0): - _t1788 = 1 + _t1804 = 1 else: if self.match_lookahead_terminal("STRING", 0): - _t1789 = 1 + _t1805 = 1 else: if self.match_lookahead_terminal("INT32", 0): - _t1790 = 1 + _t1806 = 1 else: if self.match_lookahead_terminal("INT128", 0): - _t1791 = 1 + _t1807 = 1 else: if self.match_lookahead_terminal("INT", 0): - _t1792 = 1 + _t1808 = 1 else: if self.match_lookahead_terminal("FLOAT32", 0): - _t1793 = 1 + _t1809 = 1 else: if self.match_lookahead_terminal("FLOAT", 0): - _t1794 = 1 + _t1810 = 1 else: if self.match_lookahead_terminal("DECIMAL", 0): - _t1795 = 1 + _t1811 = 1 else: - _t1795 = -1 - _t1794 = _t1795 - _t1793 = _t1794 - _t1792 = _t1793 - _t1791 = _t1792 - _t1790 = _t1791 - _t1789 = _t1790 - _t1788 = _t1789 - _t1787 = _t1788 - _t1786 = _t1787 - _t1785 = _t1786 - _t1784 = _t1785 - _t1783 = _t1784 - _t1782 = _t1783 - _t1781 = _t1782 - prediction998 = _t1781 - if prediction998 == 1: - _t1797 = self.parse_term() - term1000 = _t1797 - _t1798 = logic_pb2.RelTerm(term=term1000) - _t1796 = _t1798 - else: - if prediction998 == 0: - _t1800 = self.parse_specialized_value() - specialized_value999 = _t1800 - _t1801 = logic_pb2.RelTerm(specialized_value=specialized_value999) - _t1799 = _t1801 + _t1811 = -1 + _t1810 = _t1811 + _t1809 = _t1810 + _t1808 = _t1809 + _t1807 = _t1808 + _t1806 = _t1807 + _t1805 = _t1806 + _t1804 = _t1805 + _t1803 = _t1804 + _t1802 = _t1803 + _t1801 = _t1802 + _t1800 = _t1801 + _t1799 = _t1800 + _t1798 = _t1799 + _t1797 = _t1798 + prediction1006 = _t1797 + if prediction1006 == 1: + _t1813 = self.parse_term() + term1008 = _t1813 + _t1814 = logic_pb2.RelTerm(term=term1008) + _t1812 = _t1814 + else: + if prediction1006 == 0: + _t1816 = self.parse_specialized_value() + specialized_value1007 = _t1816 + _t1817 = logic_pb2.RelTerm(specialized_value=specialized_value1007) + _t1815 = _t1817 else: raise ParseError("Unexpected token in rel_term" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1796 = _t1799 - result1002 = _t1796 - self.record_span(span_start1001, "RelTerm") - return result1002 + _t1812 = _t1815 + result1010 = _t1812 + self.record_span(span_start1009, "RelTerm") + return result1010 def parse_specialized_value(self) -> logic_pb2.Value: - span_start1004 = self.span_start() + span_start1012 = self.span_start() self.consume_literal("#") - _t1802 = self.parse_raw_value() - raw_value1003 = _t1802 - result1005 = raw_value1003 - self.record_span(span_start1004, "Value") - return result1005 + _t1818 = self.parse_raw_value() + raw_value1011 = _t1818 + result1013 = raw_value1011 + self.record_span(span_start1012, "Value") + return result1013 def parse_rel_atom(self) -> logic_pb2.RelAtom: - span_start1011 = self.span_start() + span_start1019 = self.span_start() self.consume_literal("(") self.consume_literal("relatom") - _t1803 = self.parse_name() - name1006 = _t1803 - xs1007 = [] - cond1008 = ((((((((((((((self.match_lookahead_literal("#", 0) or self.match_lookahead_literal("(", 0)) or self.match_lookahead_literal("false", 0)) or self.match_lookahead_literal("missing", 0)) or self.match_lookahead_literal("true", 0)) or self.match_lookahead_terminal("DECIMAL", 0)) or self.match_lookahead_terminal("FLOAT", 0)) or self.match_lookahead_terminal("FLOAT32", 0)) or self.match_lookahead_terminal("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("INT32", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("UINT128", 0)) or self.match_lookahead_terminal("UINT32", 0)) or self.match_lookahead_terminal("SYMBOL", 0)) - while cond1008: - _t1804 = self.parse_rel_term() - item1009 = _t1804 - xs1007.append(item1009) - cond1008 = ((((((((((((((self.match_lookahead_literal("#", 0) or self.match_lookahead_literal("(", 0)) or self.match_lookahead_literal("false", 0)) or self.match_lookahead_literal("missing", 0)) or self.match_lookahead_literal("true", 0)) or self.match_lookahead_terminal("DECIMAL", 0)) or self.match_lookahead_terminal("FLOAT", 0)) or self.match_lookahead_terminal("FLOAT32", 0)) or self.match_lookahead_terminal("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("INT32", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("UINT128", 0)) or self.match_lookahead_terminal("UINT32", 0)) or self.match_lookahead_terminal("SYMBOL", 0)) - rel_terms1010 = xs1007 - self.consume_literal(")") - _t1805 = logic_pb2.RelAtom(name=name1006, terms=rel_terms1010) - result1012 = _t1805 - self.record_span(span_start1011, "RelAtom") - return result1012 + _t1819 = self.parse_name() + name1014 = _t1819 + xs1015 = [] + cond1016 = ((((((((((((((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 cond1016: + _t1820 = self.parse_rel_term() + item1017 = _t1820 + xs1015.append(item1017) + cond1016 = ((((((((((((((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_terms1018 = xs1015 + self.consume_literal(")") + _t1821 = logic_pb2.RelAtom(name=name1014, terms=rel_terms1018) + result1020 = _t1821 + self.record_span(span_start1019, "RelAtom") + return result1020 def parse_cast(self) -> logic_pb2.Cast: - span_start1015 = self.span_start() + span_start1023 = self.span_start() self.consume_literal("(") self.consume_literal("cast") - _t1806 = self.parse_term() - term1013 = _t1806 - _t1807 = self.parse_term() - term_31014 = _t1807 + _t1822 = self.parse_term() + term1021 = _t1822 + _t1823 = self.parse_term() + term_31022 = _t1823 self.consume_literal(")") - _t1808 = logic_pb2.Cast(input=term1013, result=term_31014) - result1016 = _t1808 - self.record_span(span_start1015, "Cast") - return result1016 + _t1824 = logic_pb2.Cast(input=term1021, result=term_31022) + result1024 = _t1824 + self.record_span(span_start1023, "Cast") + return result1024 def parse_attrs(self) -> Sequence[logic_pb2.Attribute]: self.consume_literal("(") self.consume_literal("attrs") - xs1017 = [] - cond1018 = self.match_lookahead_literal("(", 0) - while cond1018: - _t1809 = self.parse_attribute() - item1019 = _t1809 - xs1017.append(item1019) - cond1018 = self.match_lookahead_literal("(", 0) - attributes1020 = xs1017 + xs1025 = [] + cond1026 = self.match_lookahead_literal("(", 0) + while cond1026: + _t1825 = self.parse_attribute() + item1027 = _t1825 + xs1025.append(item1027) + cond1026 = self.match_lookahead_literal("(", 0) + attributes1028 = xs1025 self.consume_literal(")") - return attributes1020 + return attributes1028 def parse_attribute(self) -> logic_pb2.Attribute: - span_start1026 = self.span_start() + span_start1034 = self.span_start() self.consume_literal("(") self.consume_literal("attribute") - _t1810 = self.parse_name() - name1021 = _t1810 - xs1022 = [] - cond1023 = ((((((((((((self.match_lookahead_literal("(", 0) or self.match_lookahead_literal("false", 0)) or self.match_lookahead_literal("missing", 0)) or self.match_lookahead_literal("true", 0)) or self.match_lookahead_terminal("DECIMAL", 0)) or self.match_lookahead_terminal("FLOAT", 0)) or self.match_lookahead_terminal("FLOAT32", 0)) or self.match_lookahead_terminal("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("INT32", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("UINT128", 0)) or self.match_lookahead_terminal("UINT32", 0)) - while cond1023: - _t1811 = self.parse_raw_value() - item1024 = _t1811 - xs1022.append(item1024) - cond1023 = ((((((((((((self.match_lookahead_literal("(", 0) or self.match_lookahead_literal("false", 0)) or self.match_lookahead_literal("missing", 0)) or self.match_lookahead_literal("true", 0)) or self.match_lookahead_terminal("DECIMAL", 0)) or self.match_lookahead_terminal("FLOAT", 0)) or self.match_lookahead_terminal("FLOAT32", 0)) or self.match_lookahead_terminal("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("INT32", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("UINT128", 0)) or self.match_lookahead_terminal("UINT32", 0)) - raw_values1025 = xs1022 - self.consume_literal(")") - _t1812 = logic_pb2.Attribute(name=name1021, args=raw_values1025) - result1027 = _t1812 - self.record_span(span_start1026, "Attribute") - return result1027 + _t1826 = self.parse_name() + name1029 = _t1826 + xs1030 = [] + cond1031 = ((((((((((((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 cond1031: + _t1827 = self.parse_raw_value() + item1032 = _t1827 + xs1030.append(item1032) + cond1031 = ((((((((((((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_values1033 = xs1030 + self.consume_literal(")") + _t1828 = logic_pb2.Attribute(name=name1029, args=raw_values1033) + result1035 = _t1828 + self.record_span(span_start1034, "Attribute") + return result1035 def parse_algorithm(self) -> logic_pb2.Algorithm: - span_start1034 = self.span_start() + span_start1042 = self.span_start() self.consume_literal("(") self.consume_literal("algorithm") - xs1028 = [] - cond1029 = (self.match_lookahead_literal(":", 0) or self.match_lookahead_terminal("UINT128", 0)) - while cond1029: - _t1813 = self.parse_relation_id() - item1030 = _t1813 - xs1028.append(item1030) - cond1029 = (self.match_lookahead_literal(":", 0) or self.match_lookahead_terminal("UINT128", 0)) - relation_ids1031 = xs1028 - _t1814 = self.parse_script() - script1032 = _t1814 + xs1036 = [] + cond1037 = (self.match_lookahead_literal(":", 0) or self.match_lookahead_terminal("UINT128", 0)) + while cond1037: + _t1829 = self.parse_relation_id() + item1038 = _t1829 + xs1036.append(item1038) + cond1037 = (self.match_lookahead_literal(":", 0) or self.match_lookahead_terminal("UINT128", 0)) + relation_ids1039 = xs1036 + _t1830 = self.parse_script() + script1040 = _t1830 if self.match_lookahead_literal("(", 0): - _t1816 = self.parse_attrs() - _t1815 = _t1816 + _t1832 = self.parse_attrs() + _t1831 = _t1832 else: - _t1815 = None - attrs1033 = _t1815 + _t1831 = None + attrs1041 = _t1831 self.consume_literal(")") - _t1817 = logic_pb2.Algorithm(body=script1032, attrs=(attrs1033 if attrs1033 is not None else [])) - getattr(_t1817, 'global').extend(relation_ids1031) - result1035 = _t1817 - self.record_span(span_start1034, "Algorithm") - return result1035 + _t1833 = logic_pb2.Algorithm(body=script1040, attrs=(attrs1041 if attrs1041 is not None else [])) + getattr(_t1833, 'global').extend(relation_ids1039) + result1043 = _t1833 + self.record_span(span_start1042, "Algorithm") + return result1043 def parse_script(self) -> logic_pb2.Script: - span_start1040 = self.span_start() + span_start1048 = self.span_start() self.consume_literal("(") self.consume_literal("script") - xs1036 = [] - cond1037 = self.match_lookahead_literal("(", 0) - while cond1037: - _t1818 = self.parse_construct() - item1038 = _t1818 - xs1036.append(item1038) - cond1037 = self.match_lookahead_literal("(", 0) - constructs1039 = xs1036 - self.consume_literal(")") - _t1819 = logic_pb2.Script(constructs=constructs1039) - result1041 = _t1819 - self.record_span(span_start1040, "Script") - return result1041 + xs1044 = [] + cond1045 = self.match_lookahead_literal("(", 0) + while cond1045: + _t1834 = self.parse_construct() + item1046 = _t1834 + xs1044.append(item1046) + cond1045 = self.match_lookahead_literal("(", 0) + constructs1047 = xs1044 + self.consume_literal(")") + _t1835 = logic_pb2.Script(constructs=constructs1047) + result1049 = _t1835 + self.record_span(span_start1048, "Script") + return result1049 def parse_construct(self) -> logic_pb2.Construct: - span_start1045 = self.span_start() + span_start1053 = self.span_start() if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("upsert", 1): - _t1821 = 1 + _t1837 = 1 else: if self.match_lookahead_literal("monus", 1): - _t1822 = 1 + _t1838 = 1 else: if self.match_lookahead_literal("monoid", 1): - _t1823 = 1 + _t1839 = 1 else: if self.match_lookahead_literal("loop", 1): - _t1824 = 0 + _t1840 = 0 else: if self.match_lookahead_literal("break", 1): - _t1825 = 1 + _t1841 = 1 else: if self.match_lookahead_literal("assign", 1): - _t1826 = 1 + _t1842 = 1 else: - _t1826 = -1 - _t1825 = _t1826 - _t1824 = _t1825 - _t1823 = _t1824 - _t1822 = _t1823 - _t1821 = _t1822 - _t1820 = _t1821 - else: - _t1820 = -1 - prediction1042 = _t1820 - if prediction1042 == 1: - _t1828 = self.parse_instruction() - instruction1044 = _t1828 - _t1829 = logic_pb2.Construct(instruction=instruction1044) - _t1827 = _t1829 - else: - if prediction1042 == 0: - _t1831 = self.parse_loop() - loop1043 = _t1831 - _t1832 = logic_pb2.Construct(loop=loop1043) - _t1830 = _t1832 + _t1842 = -1 + _t1841 = _t1842 + _t1840 = _t1841 + _t1839 = _t1840 + _t1838 = _t1839 + _t1837 = _t1838 + _t1836 = _t1837 + else: + _t1836 = -1 + prediction1050 = _t1836 + if prediction1050 == 1: + _t1844 = self.parse_instruction() + instruction1052 = _t1844 + _t1845 = logic_pb2.Construct(instruction=instruction1052) + _t1843 = _t1845 + else: + if prediction1050 == 0: + _t1847 = self.parse_loop() + loop1051 = _t1847 + _t1848 = logic_pb2.Construct(loop=loop1051) + _t1846 = _t1848 else: raise ParseError("Unexpected token in construct" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1827 = _t1830 - result1046 = _t1827 - self.record_span(span_start1045, "Construct") - return result1046 + _t1843 = _t1846 + result1054 = _t1843 + self.record_span(span_start1053, "Construct") + return result1054 def parse_loop(self) -> logic_pb2.Loop: - span_start1050 = self.span_start() + span_start1058 = self.span_start() self.consume_literal("(") self.consume_literal("loop") - _t1833 = self.parse_init() - init1047 = _t1833 - _t1834 = self.parse_script() - script1048 = _t1834 + _t1849 = self.parse_init() + init1055 = _t1849 + _t1850 = self.parse_script() + script1056 = _t1850 if self.match_lookahead_literal("(", 0): - _t1836 = self.parse_attrs() - _t1835 = _t1836 + _t1852 = self.parse_attrs() + _t1851 = _t1852 else: - _t1835 = None - attrs1049 = _t1835 + _t1851 = None + attrs1057 = _t1851 self.consume_literal(")") - _t1837 = logic_pb2.Loop(init=init1047, body=script1048, attrs=(attrs1049 if attrs1049 is not None else [])) - result1051 = _t1837 - self.record_span(span_start1050, "Loop") - return result1051 + _t1853 = logic_pb2.Loop(init=init1055, body=script1056, attrs=(attrs1057 if attrs1057 is not None else [])) + result1059 = _t1853 + self.record_span(span_start1058, "Loop") + return result1059 def parse_init(self) -> Sequence[logic_pb2.Instruction]: self.consume_literal("(") self.consume_literal("init") - xs1052 = [] - cond1053 = self.match_lookahead_literal("(", 0) - while cond1053: - _t1838 = self.parse_instruction() - item1054 = _t1838 - xs1052.append(item1054) - cond1053 = self.match_lookahead_literal("(", 0) - instructions1055 = xs1052 + xs1060 = [] + cond1061 = self.match_lookahead_literal("(", 0) + while cond1061: + _t1854 = self.parse_instruction() + item1062 = _t1854 + xs1060.append(item1062) + cond1061 = self.match_lookahead_literal("(", 0) + instructions1063 = xs1060 self.consume_literal(")") - return instructions1055 + return instructions1063 def parse_instruction(self) -> logic_pb2.Instruction: - span_start1062 = self.span_start() + span_start1070 = self.span_start() if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("upsert", 1): - _t1840 = 1 + _t1856 = 1 else: if self.match_lookahead_literal("monus", 1): - _t1841 = 4 + _t1857 = 4 else: if self.match_lookahead_literal("monoid", 1): - _t1842 = 3 + _t1858 = 3 else: if self.match_lookahead_literal("break", 1): - _t1843 = 2 + _t1859 = 2 else: if self.match_lookahead_literal("assign", 1): - _t1844 = 0 + _t1860 = 0 else: - _t1844 = -1 - _t1843 = _t1844 - _t1842 = _t1843 - _t1841 = _t1842 - _t1840 = _t1841 - _t1839 = _t1840 - else: - _t1839 = -1 - prediction1056 = _t1839 - if prediction1056 == 4: - _t1846 = self.parse_monus_def() - monus_def1061 = _t1846 - _t1847 = logic_pb2.Instruction(monus_def=monus_def1061) - _t1845 = _t1847 - else: - if prediction1056 == 3: - _t1849 = self.parse_monoid_def() - monoid_def1060 = _t1849 - _t1850 = logic_pb2.Instruction(monoid_def=monoid_def1060) - _t1848 = _t1850 + _t1860 = -1 + _t1859 = _t1860 + _t1858 = _t1859 + _t1857 = _t1858 + _t1856 = _t1857 + _t1855 = _t1856 + else: + _t1855 = -1 + prediction1064 = _t1855 + if prediction1064 == 4: + _t1862 = self.parse_monus_def() + monus_def1069 = _t1862 + _t1863 = logic_pb2.Instruction(monus_def=monus_def1069) + _t1861 = _t1863 + else: + if prediction1064 == 3: + _t1865 = self.parse_monoid_def() + monoid_def1068 = _t1865 + _t1866 = logic_pb2.Instruction(monoid_def=monoid_def1068) + _t1864 = _t1866 else: - if prediction1056 == 2: - _t1852 = self.parse_break() - break1059 = _t1852 - _t1853 = logic_pb2.Instruction() - getattr(_t1853, 'break').CopyFrom(break1059) - _t1851 = _t1853 + if prediction1064 == 2: + _t1868 = self.parse_break() + break1067 = _t1868 + _t1869 = logic_pb2.Instruction() + getattr(_t1869, 'break').CopyFrom(break1067) + _t1867 = _t1869 else: - if prediction1056 == 1: - _t1855 = self.parse_upsert() - upsert1058 = _t1855 - _t1856 = logic_pb2.Instruction(upsert=upsert1058) - _t1854 = _t1856 + if prediction1064 == 1: + _t1871 = self.parse_upsert() + upsert1066 = _t1871 + _t1872 = logic_pb2.Instruction(upsert=upsert1066) + _t1870 = _t1872 else: - if prediction1056 == 0: - _t1858 = self.parse_assign() - assign1057 = _t1858 - _t1859 = logic_pb2.Instruction(assign=assign1057) - _t1857 = _t1859 + if prediction1064 == 0: + _t1874 = self.parse_assign() + assign1065 = _t1874 + _t1875 = logic_pb2.Instruction(assign=assign1065) + _t1873 = _t1875 else: raise ParseError("Unexpected token in instruction" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1854 = _t1857 - _t1851 = _t1854 - _t1848 = _t1851 - _t1845 = _t1848 - result1063 = _t1845 - self.record_span(span_start1062, "Instruction") - return result1063 + _t1870 = _t1873 + _t1867 = _t1870 + _t1864 = _t1867 + _t1861 = _t1864 + result1071 = _t1861 + self.record_span(span_start1070, "Instruction") + return result1071 def parse_assign(self) -> logic_pb2.Assign: - span_start1067 = self.span_start() + span_start1075 = self.span_start() self.consume_literal("(") self.consume_literal("assign") - _t1860 = self.parse_relation_id() - relation_id1064 = _t1860 - _t1861 = self.parse_abstraction() - abstraction1065 = _t1861 + _t1876 = self.parse_relation_id() + relation_id1072 = _t1876 + _t1877 = self.parse_abstraction() + abstraction1073 = _t1877 if self.match_lookahead_literal("(", 0): - _t1863 = self.parse_attrs() - _t1862 = _t1863 + _t1879 = self.parse_attrs() + _t1878 = _t1879 else: - _t1862 = None - attrs1066 = _t1862 + _t1878 = None + attrs1074 = _t1878 self.consume_literal(")") - _t1864 = logic_pb2.Assign(name=relation_id1064, body=abstraction1065, attrs=(attrs1066 if attrs1066 is not None else [])) - result1068 = _t1864 - self.record_span(span_start1067, "Assign") - return result1068 + _t1880 = logic_pb2.Assign(name=relation_id1072, body=abstraction1073, attrs=(attrs1074 if attrs1074 is not None else [])) + result1076 = _t1880 + self.record_span(span_start1075, "Assign") + return result1076 def parse_upsert(self) -> logic_pb2.Upsert: - span_start1072 = self.span_start() + span_start1080 = self.span_start() self.consume_literal("(") self.consume_literal("upsert") - _t1865 = self.parse_relation_id() - relation_id1069 = _t1865 - _t1866 = self.parse_abstraction_with_arity() - abstraction_with_arity1070 = _t1866 + _t1881 = self.parse_relation_id() + relation_id1077 = _t1881 + _t1882 = self.parse_abstraction_with_arity() + abstraction_with_arity1078 = _t1882 if self.match_lookahead_literal("(", 0): - _t1868 = self.parse_attrs() - _t1867 = _t1868 + _t1884 = self.parse_attrs() + _t1883 = _t1884 else: - _t1867 = None - attrs1071 = _t1867 + _t1883 = None + attrs1079 = _t1883 self.consume_literal(")") - _t1869 = logic_pb2.Upsert(name=relation_id1069, body=abstraction_with_arity1070[0], attrs=(attrs1071 if attrs1071 is not None else []), value_arity=abstraction_with_arity1070[1]) - result1073 = _t1869 - self.record_span(span_start1072, "Upsert") - return result1073 + _t1885 = logic_pb2.Upsert(name=relation_id1077, body=abstraction_with_arity1078[0], attrs=(attrs1079 if attrs1079 is not None else []), value_arity=abstraction_with_arity1078[1]) + result1081 = _t1885 + self.record_span(span_start1080, "Upsert") + return result1081 def parse_abstraction_with_arity(self) -> tuple[logic_pb2.Abstraction, int]: self.consume_literal("(") - _t1870 = self.parse_bindings() - bindings1074 = _t1870 - _t1871 = self.parse_formula() - formula1075 = _t1871 + _t1886 = self.parse_bindings() + bindings1082 = _t1886 + _t1887 = self.parse_formula() + formula1083 = _t1887 self.consume_literal(")") - _t1872 = logic_pb2.Abstraction(vars=(list(bindings1074[0]) + list(bindings1074[1] if bindings1074[1] is not None else [])), value=formula1075) - return (_t1872, len(bindings1074[1]),) + _t1888 = logic_pb2.Abstraction(vars=(list(bindings1082[0]) + list(bindings1082[1] if bindings1082[1] is not None else [])), value=formula1083) + return (_t1888, len(bindings1082[1]),) def parse_break(self) -> logic_pb2.Break: - span_start1079 = self.span_start() + span_start1087 = self.span_start() self.consume_literal("(") self.consume_literal("break") - _t1873 = self.parse_relation_id() - relation_id1076 = _t1873 - _t1874 = self.parse_abstraction() - abstraction1077 = _t1874 + _t1889 = self.parse_relation_id() + relation_id1084 = _t1889 + _t1890 = self.parse_abstraction() + abstraction1085 = _t1890 if self.match_lookahead_literal("(", 0): - _t1876 = self.parse_attrs() - _t1875 = _t1876 + _t1892 = self.parse_attrs() + _t1891 = _t1892 else: - _t1875 = None - attrs1078 = _t1875 + _t1891 = None + attrs1086 = _t1891 self.consume_literal(")") - _t1877 = logic_pb2.Break(name=relation_id1076, body=abstraction1077, attrs=(attrs1078 if attrs1078 is not None else [])) - result1080 = _t1877 - self.record_span(span_start1079, "Break") - return result1080 + _t1893 = logic_pb2.Break(name=relation_id1084, body=abstraction1085, attrs=(attrs1086 if attrs1086 is not None else [])) + result1088 = _t1893 + self.record_span(span_start1087, "Break") + return result1088 def parse_monoid_def(self) -> logic_pb2.MonoidDef: - span_start1085 = self.span_start() + span_start1093 = self.span_start() self.consume_literal("(") self.consume_literal("monoid") - _t1878 = self.parse_monoid() - monoid1081 = _t1878 - _t1879 = self.parse_relation_id() - relation_id1082 = _t1879 - _t1880 = self.parse_abstraction_with_arity() - abstraction_with_arity1083 = _t1880 + _t1894 = self.parse_monoid() + monoid1089 = _t1894 + _t1895 = self.parse_relation_id() + relation_id1090 = _t1895 + _t1896 = self.parse_abstraction_with_arity() + abstraction_with_arity1091 = _t1896 if self.match_lookahead_literal("(", 0): - _t1882 = self.parse_attrs() - _t1881 = _t1882 + _t1898 = self.parse_attrs() + _t1897 = _t1898 else: - _t1881 = None - attrs1084 = _t1881 + _t1897 = None + attrs1092 = _t1897 self.consume_literal(")") - _t1883 = logic_pb2.MonoidDef(monoid=monoid1081, name=relation_id1082, body=abstraction_with_arity1083[0], attrs=(attrs1084 if attrs1084 is not None else []), value_arity=abstraction_with_arity1083[1]) - result1086 = _t1883 - self.record_span(span_start1085, "MonoidDef") - return result1086 + _t1899 = logic_pb2.MonoidDef(monoid=monoid1089, name=relation_id1090, body=abstraction_with_arity1091[0], attrs=(attrs1092 if attrs1092 is not None else []), value_arity=abstraction_with_arity1091[1]) + result1094 = _t1899 + self.record_span(span_start1093, "MonoidDef") + return result1094 def parse_monoid(self) -> logic_pb2.Monoid: - span_start1092 = self.span_start() + span_start1100 = self.span_start() if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("sum", 1): - _t1885 = 3 + _t1901 = 3 else: if self.match_lookahead_literal("or", 1): - _t1886 = 0 + _t1902 = 0 else: if self.match_lookahead_literal("min", 1): - _t1887 = 1 + _t1903 = 1 else: if self.match_lookahead_literal("max", 1): - _t1888 = 2 + _t1904 = 2 else: - _t1888 = -1 - _t1887 = _t1888 - _t1886 = _t1887 - _t1885 = _t1886 - _t1884 = _t1885 - else: - _t1884 = -1 - prediction1087 = _t1884 - if prediction1087 == 3: - _t1890 = self.parse_sum_monoid() - sum_monoid1091 = _t1890 - _t1891 = logic_pb2.Monoid(sum_monoid=sum_monoid1091) - _t1889 = _t1891 - else: - if prediction1087 == 2: - _t1893 = self.parse_max_monoid() - max_monoid1090 = _t1893 - _t1894 = logic_pb2.Monoid(max_monoid=max_monoid1090) - _t1892 = _t1894 + _t1904 = -1 + _t1903 = _t1904 + _t1902 = _t1903 + _t1901 = _t1902 + _t1900 = _t1901 + else: + _t1900 = -1 + prediction1095 = _t1900 + if prediction1095 == 3: + _t1906 = self.parse_sum_monoid() + sum_monoid1099 = _t1906 + _t1907 = logic_pb2.Monoid(sum_monoid=sum_monoid1099) + _t1905 = _t1907 + else: + if prediction1095 == 2: + _t1909 = self.parse_max_monoid() + max_monoid1098 = _t1909 + _t1910 = logic_pb2.Monoid(max_monoid=max_monoid1098) + _t1908 = _t1910 else: - if prediction1087 == 1: - _t1896 = self.parse_min_monoid() - min_monoid1089 = _t1896 - _t1897 = logic_pb2.Monoid(min_monoid=min_monoid1089) - _t1895 = _t1897 + if prediction1095 == 1: + _t1912 = self.parse_min_monoid() + min_monoid1097 = _t1912 + _t1913 = logic_pb2.Monoid(min_monoid=min_monoid1097) + _t1911 = _t1913 else: - if prediction1087 == 0: - _t1899 = self.parse_or_monoid() - or_monoid1088 = _t1899 - _t1900 = logic_pb2.Monoid(or_monoid=or_monoid1088) - _t1898 = _t1900 + if prediction1095 == 0: + _t1915 = self.parse_or_monoid() + or_monoid1096 = _t1915 + _t1916 = logic_pb2.Monoid(or_monoid=or_monoid1096) + _t1914 = _t1916 else: raise ParseError("Unexpected token in monoid" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1895 = _t1898 - _t1892 = _t1895 - _t1889 = _t1892 - result1093 = _t1889 - self.record_span(span_start1092, "Monoid") - return result1093 + _t1911 = _t1914 + _t1908 = _t1911 + _t1905 = _t1908 + result1101 = _t1905 + self.record_span(span_start1100, "Monoid") + return result1101 def parse_or_monoid(self) -> logic_pb2.OrMonoid: - span_start1094 = self.span_start() + span_start1102 = self.span_start() self.consume_literal("(") self.consume_literal("or") self.consume_literal(")") - _t1901 = logic_pb2.OrMonoid() - result1095 = _t1901 - self.record_span(span_start1094, "OrMonoid") - return result1095 + _t1917 = logic_pb2.OrMonoid() + result1103 = _t1917 + self.record_span(span_start1102, "OrMonoid") + return result1103 def parse_min_monoid(self) -> logic_pb2.MinMonoid: - span_start1097 = self.span_start() + span_start1105 = self.span_start() self.consume_literal("(") self.consume_literal("min") - _t1902 = self.parse_type() - type1096 = _t1902 + _t1918 = self.parse_type() + type1104 = _t1918 self.consume_literal(")") - _t1903 = logic_pb2.MinMonoid(type=type1096) - result1098 = _t1903 - self.record_span(span_start1097, "MinMonoid") - return result1098 + _t1919 = logic_pb2.MinMonoid(type=type1104) + result1106 = _t1919 + self.record_span(span_start1105, "MinMonoid") + return result1106 def parse_max_monoid(self) -> logic_pb2.MaxMonoid: - span_start1100 = self.span_start() + span_start1108 = self.span_start() self.consume_literal("(") self.consume_literal("max") - _t1904 = self.parse_type() - type1099 = _t1904 + _t1920 = self.parse_type() + type1107 = _t1920 self.consume_literal(")") - _t1905 = logic_pb2.MaxMonoid(type=type1099) - result1101 = _t1905 - self.record_span(span_start1100, "MaxMonoid") - return result1101 + _t1921 = logic_pb2.MaxMonoid(type=type1107) + result1109 = _t1921 + self.record_span(span_start1108, "MaxMonoid") + return result1109 def parse_sum_monoid(self) -> logic_pb2.SumMonoid: - span_start1103 = self.span_start() + span_start1111 = self.span_start() self.consume_literal("(") self.consume_literal("sum") - _t1906 = self.parse_type() - type1102 = _t1906 + _t1922 = self.parse_type() + type1110 = _t1922 self.consume_literal(")") - _t1907 = logic_pb2.SumMonoid(type=type1102) - result1104 = _t1907 - self.record_span(span_start1103, "SumMonoid") - return result1104 + _t1923 = logic_pb2.SumMonoid(type=type1110) + result1112 = _t1923 + self.record_span(span_start1111, "SumMonoid") + return result1112 def parse_monus_def(self) -> logic_pb2.MonusDef: - span_start1109 = self.span_start() + span_start1117 = self.span_start() self.consume_literal("(") self.consume_literal("monus") - _t1908 = self.parse_monoid() - monoid1105 = _t1908 - _t1909 = self.parse_relation_id() - relation_id1106 = _t1909 - _t1910 = self.parse_abstraction_with_arity() - abstraction_with_arity1107 = _t1910 + _t1924 = self.parse_monoid() + monoid1113 = _t1924 + _t1925 = self.parse_relation_id() + relation_id1114 = _t1925 + _t1926 = self.parse_abstraction_with_arity() + abstraction_with_arity1115 = _t1926 if self.match_lookahead_literal("(", 0): - _t1912 = self.parse_attrs() - _t1911 = _t1912 + _t1928 = self.parse_attrs() + _t1927 = _t1928 else: - _t1911 = None - attrs1108 = _t1911 + _t1927 = None + attrs1116 = _t1927 self.consume_literal(")") - _t1913 = logic_pb2.MonusDef(monoid=monoid1105, name=relation_id1106, body=abstraction_with_arity1107[0], attrs=(attrs1108 if attrs1108 is not None else []), value_arity=abstraction_with_arity1107[1]) - result1110 = _t1913 - self.record_span(span_start1109, "MonusDef") - return result1110 + _t1929 = logic_pb2.MonusDef(monoid=monoid1113, name=relation_id1114, body=abstraction_with_arity1115[0], attrs=(attrs1116 if attrs1116 is not None else []), value_arity=abstraction_with_arity1115[1]) + result1118 = _t1929 + self.record_span(span_start1117, "MonusDef") + return result1118 def parse_constraint(self) -> logic_pb2.Constraint: - span_start1115 = self.span_start() + span_start1123 = self.span_start() self.consume_literal("(") self.consume_literal("functional_dependency") - _t1914 = self.parse_relation_id() - relation_id1111 = _t1914 - _t1915 = self.parse_abstraction() - abstraction1112 = _t1915 - _t1916 = self.parse_functional_dependency_keys() - functional_dependency_keys1113 = _t1916 - _t1917 = self.parse_functional_dependency_values() - functional_dependency_values1114 = _t1917 - self.consume_literal(")") - _t1918 = logic_pb2.FunctionalDependency(guard=abstraction1112, keys=functional_dependency_keys1113, values=functional_dependency_values1114) - _t1919 = logic_pb2.Constraint(name=relation_id1111, functional_dependency=_t1918) - result1116 = _t1919 - self.record_span(span_start1115, "Constraint") - return result1116 + _t1930 = self.parse_relation_id() + relation_id1119 = _t1930 + _t1931 = self.parse_abstraction() + abstraction1120 = _t1931 + _t1932 = self.parse_functional_dependency_keys() + functional_dependency_keys1121 = _t1932 + _t1933 = self.parse_functional_dependency_values() + functional_dependency_values1122 = _t1933 + self.consume_literal(")") + _t1934 = logic_pb2.FunctionalDependency(guard=abstraction1120, keys=functional_dependency_keys1121, values=functional_dependency_values1122) + _t1935 = logic_pb2.Constraint(name=relation_id1119, functional_dependency=_t1934) + result1124 = _t1935 + self.record_span(span_start1123, "Constraint") + return result1124 def parse_functional_dependency_keys(self) -> Sequence[logic_pb2.Var]: self.consume_literal("(") self.consume_literal("keys") - xs1117 = [] - cond1118 = self.match_lookahead_terminal("SYMBOL", 0) - while cond1118: - _t1920 = self.parse_var() - item1119 = _t1920 - xs1117.append(item1119) - cond1118 = self.match_lookahead_terminal("SYMBOL", 0) - vars1120 = xs1117 + xs1125 = [] + cond1126 = self.match_lookahead_terminal("SYMBOL", 0) + while cond1126: + _t1936 = self.parse_var() + item1127 = _t1936 + xs1125.append(item1127) + cond1126 = self.match_lookahead_terminal("SYMBOL", 0) + vars1128 = xs1125 self.consume_literal(")") - return vars1120 + return vars1128 def parse_functional_dependency_values(self) -> Sequence[logic_pb2.Var]: self.consume_literal("(") self.consume_literal("values") - xs1121 = [] - cond1122 = self.match_lookahead_terminal("SYMBOL", 0) - while cond1122: - _t1921 = self.parse_var() - item1123 = _t1921 - xs1121.append(item1123) - cond1122 = self.match_lookahead_terminal("SYMBOL", 0) - vars1124 = xs1121 + xs1129 = [] + cond1130 = self.match_lookahead_terminal("SYMBOL", 0) + while cond1130: + _t1937 = self.parse_var() + item1131 = _t1937 + xs1129.append(item1131) + cond1130 = self.match_lookahead_terminal("SYMBOL", 0) + vars1132 = xs1129 self.consume_literal(")") - return vars1124 + return vars1132 def parse_data(self) -> logic_pb2.Data: - span_start1130 = self.span_start() + span_start1138 = self.span_start() if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("iceberg_data", 1): - _t1923 = 3 + _t1939 = 3 else: if self.match_lookahead_literal("edb", 1): - _t1924 = 0 + _t1940 = 0 else: if self.match_lookahead_literal("csv_data", 1): - _t1925 = 2 + _t1941 = 2 else: if self.match_lookahead_literal("betree_relation", 1): - _t1926 = 1 + _t1942 = 1 else: - _t1926 = -1 - _t1925 = _t1926 - _t1924 = _t1925 - _t1923 = _t1924 - _t1922 = _t1923 - else: - _t1922 = -1 - prediction1125 = _t1922 - if prediction1125 == 3: - _t1928 = self.parse_iceberg_data() - iceberg_data1129 = _t1928 - _t1929 = logic_pb2.Data(iceberg_data=iceberg_data1129) - _t1927 = _t1929 - else: - if prediction1125 == 2: - _t1931 = self.parse_csv_data() - csv_data1128 = _t1931 - _t1932 = logic_pb2.Data(csv_data=csv_data1128) - _t1930 = _t1932 + _t1942 = -1 + _t1941 = _t1942 + _t1940 = _t1941 + _t1939 = _t1940 + _t1938 = _t1939 + else: + _t1938 = -1 + prediction1133 = _t1938 + if prediction1133 == 3: + _t1944 = self.parse_iceberg_data() + iceberg_data1137 = _t1944 + _t1945 = logic_pb2.Data(iceberg_data=iceberg_data1137) + _t1943 = _t1945 + else: + if prediction1133 == 2: + _t1947 = self.parse_csv_data() + csv_data1136 = _t1947 + _t1948 = logic_pb2.Data(csv_data=csv_data1136) + _t1946 = _t1948 else: - if prediction1125 == 1: - _t1934 = self.parse_betree_relation() - betree_relation1127 = _t1934 - _t1935 = logic_pb2.Data(betree_relation=betree_relation1127) - _t1933 = _t1935 + if prediction1133 == 1: + _t1950 = self.parse_betree_relation() + betree_relation1135 = _t1950 + _t1951 = logic_pb2.Data(betree_relation=betree_relation1135) + _t1949 = _t1951 else: - if prediction1125 == 0: - _t1937 = self.parse_edb() - edb1126 = _t1937 - _t1938 = logic_pb2.Data(edb=edb1126) - _t1936 = _t1938 + if prediction1133 == 0: + _t1953 = self.parse_edb() + edb1134 = _t1953 + _t1954 = logic_pb2.Data(edb=edb1134) + _t1952 = _t1954 else: raise ParseError("Unexpected token in data" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1933 = _t1936 - _t1930 = _t1933 - _t1927 = _t1930 - result1131 = _t1927 - self.record_span(span_start1130, "Data") - return result1131 + _t1949 = _t1952 + _t1946 = _t1949 + _t1943 = _t1946 + result1139 = _t1943 + self.record_span(span_start1138, "Data") + return result1139 def parse_edb(self) -> logic_pb2.EDB: - span_start1135 = self.span_start() + span_start1143 = self.span_start() self.consume_literal("(") self.consume_literal("edb") - _t1939 = self.parse_relation_id() - relation_id1132 = _t1939 - _t1940 = self.parse_edb_path() - edb_path1133 = _t1940 - _t1941 = self.parse_edb_types() - edb_types1134 = _t1941 - self.consume_literal(")") - _t1942 = logic_pb2.EDB(target_id=relation_id1132, path=edb_path1133, types=edb_types1134) - result1136 = _t1942 - self.record_span(span_start1135, "EDB") - return result1136 + _t1955 = self.parse_relation_id() + relation_id1140 = _t1955 + _t1956 = self.parse_edb_path() + edb_path1141 = _t1956 + _t1957 = self.parse_edb_types() + edb_types1142 = _t1957 + self.consume_literal(")") + _t1958 = logic_pb2.EDB(target_id=relation_id1140, path=edb_path1141, types=edb_types1142) + result1144 = _t1958 + self.record_span(span_start1143, "EDB") + return result1144 def parse_edb_path(self) -> Sequence[str]: self.consume_literal("[") - xs1137 = [] - cond1138 = self.match_lookahead_terminal("STRING", 0) - while cond1138: - item1139 = self.consume_terminal("STRING") - xs1137.append(item1139) - cond1138 = self.match_lookahead_terminal("STRING", 0) - strings1140 = xs1137 + xs1145 = [] + cond1146 = self.match_lookahead_terminal("STRING", 0) + while cond1146: + item1147 = self.consume_terminal("STRING") + xs1145.append(item1147) + cond1146 = self.match_lookahead_terminal("STRING", 0) + strings1148 = xs1145 self.consume_literal("]") - return strings1140 + return strings1148 def parse_edb_types(self) -> Sequence[logic_pb2.Type]: self.consume_literal("[") - xs1141 = [] - cond1142 = (((((((((((((self.match_lookahead_literal("(", 0) or self.match_lookahead_literal("BOOLEAN", 0)) or self.match_lookahead_literal("DATE", 0)) or self.match_lookahead_literal("DATETIME", 0)) or self.match_lookahead_literal("FLOAT", 0)) or self.match_lookahead_literal("FLOAT32", 0)) or self.match_lookahead_literal("INT", 0)) or self.match_lookahead_literal("INT128", 0)) or self.match_lookahead_literal("INT32", 0)) or self.match_lookahead_literal("MISSING", 0)) or self.match_lookahead_literal("STRING", 0)) or self.match_lookahead_literal("UINT128", 0)) or self.match_lookahead_literal("UINT32", 0)) or self.match_lookahead_literal("UNKNOWN", 0)) - while cond1142: - _t1943 = self.parse_type() - item1143 = _t1943 - xs1141.append(item1143) - cond1142 = (((((((((((((self.match_lookahead_literal("(", 0) or self.match_lookahead_literal("BOOLEAN", 0)) or self.match_lookahead_literal("DATE", 0)) or self.match_lookahead_literal("DATETIME", 0)) or self.match_lookahead_literal("FLOAT", 0)) or self.match_lookahead_literal("FLOAT32", 0)) or self.match_lookahead_literal("INT", 0)) or self.match_lookahead_literal("INT128", 0)) or self.match_lookahead_literal("INT32", 0)) or self.match_lookahead_literal("MISSING", 0)) or self.match_lookahead_literal("STRING", 0)) or self.match_lookahead_literal("UINT128", 0)) or self.match_lookahead_literal("UINT32", 0)) or self.match_lookahead_literal("UNKNOWN", 0)) - types1144 = xs1141 + xs1149 = [] + cond1150 = (((((((((((((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 cond1150: + _t1959 = self.parse_type() + item1151 = _t1959 + xs1149.append(item1151) + cond1150 = (((((((((((((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)) + types1152 = xs1149 self.consume_literal("]") - return types1144 + return types1152 def parse_betree_relation(self) -> logic_pb2.BeTreeRelation: - span_start1147 = self.span_start() + span_start1155 = self.span_start() self.consume_literal("(") self.consume_literal("betree_relation") - _t1944 = self.parse_relation_id() - relation_id1145 = _t1944 - _t1945 = self.parse_betree_info() - betree_info1146 = _t1945 + _t1960 = self.parse_relation_id() + relation_id1153 = _t1960 + _t1961 = self.parse_betree_info() + betree_info1154 = _t1961 self.consume_literal(")") - _t1946 = logic_pb2.BeTreeRelation(name=relation_id1145, relation_info=betree_info1146) - result1148 = _t1946 - self.record_span(span_start1147, "BeTreeRelation") - return result1148 + _t1962 = logic_pb2.BeTreeRelation(name=relation_id1153, relation_info=betree_info1154) + result1156 = _t1962 + self.record_span(span_start1155, "BeTreeRelation") + return result1156 def parse_betree_info(self) -> logic_pb2.BeTreeInfo: - span_start1152 = self.span_start() + span_start1160 = self.span_start() self.consume_literal("(") self.consume_literal("betree_info") - _t1947 = self.parse_betree_info_key_types() - betree_info_key_types1149 = _t1947 - _t1948 = self.parse_betree_info_value_types() - betree_info_value_types1150 = _t1948 - _t1949 = self.parse_config_dict() - config_dict1151 = _t1949 - self.consume_literal(")") - _t1950 = self.construct_betree_info(betree_info_key_types1149, betree_info_value_types1150, config_dict1151) - result1153 = _t1950 - self.record_span(span_start1152, "BeTreeInfo") - return result1153 + _t1963 = self.parse_betree_info_key_types() + betree_info_key_types1157 = _t1963 + _t1964 = self.parse_betree_info_value_types() + betree_info_value_types1158 = _t1964 + _t1965 = self.parse_config_dict() + config_dict1159 = _t1965 + self.consume_literal(")") + _t1966 = self.construct_betree_info(betree_info_key_types1157, betree_info_value_types1158, config_dict1159) + result1161 = _t1966 + self.record_span(span_start1160, "BeTreeInfo") + return result1161 def parse_betree_info_key_types(self) -> Sequence[logic_pb2.Type]: self.consume_literal("(") self.consume_literal("key_types") - xs1154 = [] - cond1155 = (((((((((((((self.match_lookahead_literal("(", 0) or self.match_lookahead_literal("BOOLEAN", 0)) or self.match_lookahead_literal("DATE", 0)) or self.match_lookahead_literal("DATETIME", 0)) or self.match_lookahead_literal("FLOAT", 0)) or self.match_lookahead_literal("FLOAT32", 0)) or self.match_lookahead_literal("INT", 0)) or self.match_lookahead_literal("INT128", 0)) or self.match_lookahead_literal("INT32", 0)) or self.match_lookahead_literal("MISSING", 0)) or self.match_lookahead_literal("STRING", 0)) or self.match_lookahead_literal("UINT128", 0)) or self.match_lookahead_literal("UINT32", 0)) or self.match_lookahead_literal("UNKNOWN", 0)) - while cond1155: - _t1951 = self.parse_type() - item1156 = _t1951 - xs1154.append(item1156) - cond1155 = (((((((((((((self.match_lookahead_literal("(", 0) or self.match_lookahead_literal("BOOLEAN", 0)) or self.match_lookahead_literal("DATE", 0)) or self.match_lookahead_literal("DATETIME", 0)) or self.match_lookahead_literal("FLOAT", 0)) or self.match_lookahead_literal("FLOAT32", 0)) or self.match_lookahead_literal("INT", 0)) or self.match_lookahead_literal("INT128", 0)) or self.match_lookahead_literal("INT32", 0)) or self.match_lookahead_literal("MISSING", 0)) or self.match_lookahead_literal("STRING", 0)) or self.match_lookahead_literal("UINT128", 0)) or self.match_lookahead_literal("UINT32", 0)) or self.match_lookahead_literal("UNKNOWN", 0)) - types1157 = xs1154 + xs1162 = [] + cond1163 = (((((((((((((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 cond1163: + _t1967 = self.parse_type() + item1164 = _t1967 + xs1162.append(item1164) + cond1163 = (((((((((((((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)) + types1165 = xs1162 self.consume_literal(")") - return types1157 + return types1165 def parse_betree_info_value_types(self) -> Sequence[logic_pb2.Type]: self.consume_literal("(") self.consume_literal("value_types") - xs1158 = [] - cond1159 = (((((((((((((self.match_lookahead_literal("(", 0) or self.match_lookahead_literal("BOOLEAN", 0)) or self.match_lookahead_literal("DATE", 0)) or self.match_lookahead_literal("DATETIME", 0)) or self.match_lookahead_literal("FLOAT", 0)) or self.match_lookahead_literal("FLOAT32", 0)) or self.match_lookahead_literal("INT", 0)) or self.match_lookahead_literal("INT128", 0)) or self.match_lookahead_literal("INT32", 0)) or self.match_lookahead_literal("MISSING", 0)) or self.match_lookahead_literal("STRING", 0)) or self.match_lookahead_literal("UINT128", 0)) or self.match_lookahead_literal("UINT32", 0)) or self.match_lookahead_literal("UNKNOWN", 0)) - while cond1159: - _t1952 = self.parse_type() - item1160 = _t1952 - xs1158.append(item1160) - cond1159 = (((((((((((((self.match_lookahead_literal("(", 0) or self.match_lookahead_literal("BOOLEAN", 0)) or self.match_lookahead_literal("DATE", 0)) or self.match_lookahead_literal("DATETIME", 0)) or self.match_lookahead_literal("FLOAT", 0)) or self.match_lookahead_literal("FLOAT32", 0)) or self.match_lookahead_literal("INT", 0)) or self.match_lookahead_literal("INT128", 0)) or self.match_lookahead_literal("INT32", 0)) or self.match_lookahead_literal("MISSING", 0)) or self.match_lookahead_literal("STRING", 0)) or self.match_lookahead_literal("UINT128", 0)) or self.match_lookahead_literal("UINT32", 0)) or self.match_lookahead_literal("UNKNOWN", 0)) - types1161 = xs1158 + xs1166 = [] + cond1167 = (((((((((((((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 cond1167: + _t1968 = self.parse_type() + item1168 = _t1968 + xs1166.append(item1168) + cond1167 = (((((((((((((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)) + types1169 = xs1166 self.consume_literal(")") - return types1161 + return types1169 def parse_csv_data(self) -> logic_pb2.CSVData: - span_start1166 = self.span_start() + span_start1174 = self.span_start() self.consume_literal("(") self.consume_literal("csv_data") - _t1953 = self.parse_csvlocator() - csvlocator1162 = _t1953 - _t1954 = self.parse_csv_config() - csv_config1163 = _t1954 - _t1955 = self.parse_gnf_columns() - gnf_columns1164 = _t1955 - _t1956 = self.parse_csv_asof() - csv_asof1165 = _t1956 - self.consume_literal(")") - _t1957 = logic_pb2.CSVData(locator=csvlocator1162, config=csv_config1163, columns=gnf_columns1164, asof=csv_asof1165) - result1167 = _t1957 - self.record_span(span_start1166, "CSVData") - return result1167 + _t1969 = self.parse_csvlocator() + csvlocator1170 = _t1969 + _t1970 = self.parse_csv_config() + csv_config1171 = _t1970 + _t1971 = self.parse_gnf_columns() + gnf_columns1172 = _t1971 + _t1972 = self.parse_csv_asof() + csv_asof1173 = _t1972 + self.consume_literal(")") + _t1973 = logic_pb2.CSVData(locator=csvlocator1170, config=csv_config1171, columns=gnf_columns1172, asof=csv_asof1173) + result1175 = _t1973 + self.record_span(span_start1174, "CSVData") + return result1175 def parse_csvlocator(self) -> logic_pb2.CSVLocator: - span_start1170 = self.span_start() + span_start1178 = self.span_start() self.consume_literal("(") self.consume_literal("csv_locator") if (self.match_lookahead_literal("(", 0) and self.match_lookahead_literal("paths", 1)): - _t1959 = self.parse_csv_locator_paths() - _t1958 = _t1959 + _t1975 = self.parse_csv_locator_paths() + _t1974 = _t1975 else: - _t1958 = None - csv_locator_paths1168 = _t1958 + _t1974 = None + csv_locator_paths1176 = _t1974 if self.match_lookahead_literal("(", 0): - _t1961 = self.parse_csv_locator_inline_data() - _t1960 = _t1961 + _t1977 = self.parse_csv_locator_inline_data() + _t1976 = _t1977 else: - _t1960 = None - csv_locator_inline_data1169 = _t1960 + _t1976 = None + csv_locator_inline_data1177 = _t1976 self.consume_literal(")") - _t1962 = logic_pb2.CSVLocator(paths=(csv_locator_paths1168 if csv_locator_paths1168 is not None else []), inline_data=(csv_locator_inline_data1169 if csv_locator_inline_data1169 is not None else "").encode()) - result1171 = _t1962 - self.record_span(span_start1170, "CSVLocator") - return result1171 + _t1978 = logic_pb2.CSVLocator(paths=(csv_locator_paths1176 if csv_locator_paths1176 is not None else []), inline_data=(csv_locator_inline_data1177 if csv_locator_inline_data1177 is not None else "").encode()) + result1179 = _t1978 + self.record_span(span_start1178, "CSVLocator") + return result1179 def parse_csv_locator_paths(self) -> Sequence[str]: self.consume_literal("(") self.consume_literal("paths") - xs1172 = [] - cond1173 = self.match_lookahead_terminal("STRING", 0) - while cond1173: - item1174 = self.consume_terminal("STRING") - xs1172.append(item1174) - cond1173 = self.match_lookahead_terminal("STRING", 0) - strings1175 = xs1172 + xs1180 = [] + cond1181 = self.match_lookahead_terminal("STRING", 0) + while cond1181: + item1182 = self.consume_terminal("STRING") + xs1180.append(item1182) + cond1181 = self.match_lookahead_terminal("STRING", 0) + strings1183 = xs1180 self.consume_literal(")") - return strings1175 + return strings1183 def parse_csv_locator_inline_data(self) -> str: self.consume_literal("(") self.consume_literal("inline_data") - formatted_string1176 = self.consume_terminal("STRING") + formatted_string1184 = self.consume_terminal("STRING") self.consume_literal(")") - return formatted_string1176 + return formatted_string1184 def parse_csv_config(self) -> logic_pb2.CSVConfig: - span_start1179 = self.span_start() + span_start1187 = self.span_start() self.consume_literal("(") self.consume_literal("csv_config") - _t1963 = self.parse_config_dict() - config_dict1177 = _t1963 + _t1979 = self.parse_config_dict() + config_dict1185 = _t1979 if self.match_lookahead_literal("(", 0): - _t1965 = self.parse__storage_integration() - _t1964 = _t1965 + _t1981 = self.parse__storage_integration() + _t1980 = _t1981 else: - _t1964 = None - _storage_integration1178 = _t1964 + _t1980 = None + _storage_integration1186 = _t1980 self.consume_literal(")") - _t1966 = self.construct_csv_config(config_dict1177, _storage_integration1178) - result1180 = _t1966 - self.record_span(span_start1179, "CSVConfig") - return result1180 + _t1982 = self.construct_csv_config(config_dict1185, _storage_integration1186) + result1188 = _t1982 + self.record_span(span_start1187, "CSVConfig") + return result1188 def parse__storage_integration(self) -> Sequence[tuple[str, logic_pb2.Value]]: self.consume_literal("(") self.consume_literal("storage_integration") - _t1967 = self.parse_config_dict() - config_dict1181 = _t1967 + _t1983 = self.parse_config_dict() + config_dict1189 = _t1983 self.consume_literal(")") - return config_dict1181 + return config_dict1189 def parse_gnf_columns(self) -> Sequence[logic_pb2.GNFColumn]: self.consume_literal("(") self.consume_literal("columns") - xs1182 = [] - cond1183 = self.match_lookahead_literal("(", 0) - while cond1183: - _t1968 = self.parse_gnf_column() - item1184 = _t1968 - xs1182.append(item1184) - cond1183 = self.match_lookahead_literal("(", 0) - gnf_columns1185 = xs1182 + xs1190 = [] + cond1191 = self.match_lookahead_literal("(", 0) + while cond1191: + _t1984 = self.parse_gnf_column() + item1192 = _t1984 + xs1190.append(item1192) + cond1191 = self.match_lookahead_literal("(", 0) + gnf_columns1193 = xs1190 self.consume_literal(")") - return gnf_columns1185 + return gnf_columns1193 def parse_gnf_column(self) -> logic_pb2.GNFColumn: - span_start1192 = self.span_start() + span_start1200 = self.span_start() self.consume_literal("(") self.consume_literal("column") - _t1969 = self.parse_gnf_column_path() - gnf_column_path1186 = _t1969 + _t1985 = self.parse_gnf_column_path() + gnf_column_path1194 = _t1985 if (self.match_lookahead_literal(":", 0) or self.match_lookahead_terminal("UINT128", 0)): - _t1971 = self.parse_relation_id() - _t1970 = _t1971 + _t1987 = self.parse_relation_id() + _t1986 = _t1987 else: - _t1970 = None - relation_id1187 = _t1970 + _t1986 = None + relation_id1195 = _t1986 self.consume_literal("[") - xs1188 = [] - cond1189 = (((((((((((((self.match_lookahead_literal("(", 0) or self.match_lookahead_literal("BOOLEAN", 0)) or self.match_lookahead_literal("DATE", 0)) or self.match_lookahead_literal("DATETIME", 0)) or self.match_lookahead_literal("FLOAT", 0)) or self.match_lookahead_literal("FLOAT32", 0)) or self.match_lookahead_literal("INT", 0)) or self.match_lookahead_literal("INT128", 0)) or self.match_lookahead_literal("INT32", 0)) or self.match_lookahead_literal("MISSING", 0)) or self.match_lookahead_literal("STRING", 0)) or self.match_lookahead_literal("UINT128", 0)) or self.match_lookahead_literal("UINT32", 0)) or self.match_lookahead_literal("UNKNOWN", 0)) - while cond1189: - _t1972 = self.parse_type() - item1190 = _t1972 - xs1188.append(item1190) - cond1189 = (((((((((((((self.match_lookahead_literal("(", 0) or self.match_lookahead_literal("BOOLEAN", 0)) or self.match_lookahead_literal("DATE", 0)) or self.match_lookahead_literal("DATETIME", 0)) or self.match_lookahead_literal("FLOAT", 0)) or self.match_lookahead_literal("FLOAT32", 0)) or self.match_lookahead_literal("INT", 0)) or self.match_lookahead_literal("INT128", 0)) or self.match_lookahead_literal("INT32", 0)) or self.match_lookahead_literal("MISSING", 0)) or self.match_lookahead_literal("STRING", 0)) or self.match_lookahead_literal("UINT128", 0)) or self.match_lookahead_literal("UINT32", 0)) or self.match_lookahead_literal("UNKNOWN", 0)) - types1191 = xs1188 + xs1196 = [] + cond1197 = (((((((((((((self.match_lookahead_literal("(", 0) or self.match_lookahead_literal("BOOLEAN", 0)) or self.match_lookahead_literal("DATE", 0)) or self.match_lookahead_literal("DATETIME", 0)) or self.match_lookahead_literal("FLOAT", 0)) or self.match_lookahead_literal("FLOAT32", 0)) or self.match_lookahead_literal("INT", 0)) or self.match_lookahead_literal("INT128", 0)) or self.match_lookahead_literal("INT32", 0)) or self.match_lookahead_literal("MISSING", 0)) or self.match_lookahead_literal("STRING", 0)) or self.match_lookahead_literal("UINT128", 0)) or self.match_lookahead_literal("UINT32", 0)) or self.match_lookahead_literal("UNKNOWN", 0)) + while cond1197: + _t1988 = self.parse_type() + item1198 = _t1988 + xs1196.append(item1198) + cond1197 = (((((((((((((self.match_lookahead_literal("(", 0) or self.match_lookahead_literal("BOOLEAN", 0)) or self.match_lookahead_literal("DATE", 0)) or self.match_lookahead_literal("DATETIME", 0)) or self.match_lookahead_literal("FLOAT", 0)) or self.match_lookahead_literal("FLOAT32", 0)) or self.match_lookahead_literal("INT", 0)) or self.match_lookahead_literal("INT128", 0)) or self.match_lookahead_literal("INT32", 0)) or self.match_lookahead_literal("MISSING", 0)) or self.match_lookahead_literal("STRING", 0)) or self.match_lookahead_literal("UINT128", 0)) or self.match_lookahead_literal("UINT32", 0)) or self.match_lookahead_literal("UNKNOWN", 0)) + types1199 = xs1196 self.consume_literal("]") self.consume_literal(")") - _t1973 = logic_pb2.GNFColumn(column_path=gnf_column_path1186, target_id=relation_id1187, types=types1191) - result1193 = _t1973 - self.record_span(span_start1192, "GNFColumn") - return result1193 + _t1989 = logic_pb2.GNFColumn(column_path=gnf_column_path1194, target_id=relation_id1195, types=types1199) + result1201 = _t1989 + self.record_span(span_start1200, "GNFColumn") + return result1201 def parse_gnf_column_path(self) -> Sequence[str]: if self.match_lookahead_literal("[", 0): - _t1974 = 1 + _t1990 = 1 else: if self.match_lookahead_terminal("STRING", 0): - _t1975 = 0 + _t1991 = 0 else: - _t1975 = -1 - _t1974 = _t1975 - prediction1194 = _t1974 - if prediction1194 == 1: + _t1991 = -1 + _t1990 = _t1991 + prediction1202 = _t1990 + if prediction1202 == 1: self.consume_literal("[") - xs1196 = [] - cond1197 = self.match_lookahead_terminal("STRING", 0) - while cond1197: - item1198 = self.consume_terminal("STRING") - xs1196.append(item1198) - cond1197 = self.match_lookahead_terminal("STRING", 0) - strings1199 = xs1196 + xs1204 = [] + cond1205 = self.match_lookahead_terminal("STRING", 0) + while cond1205: + item1206 = self.consume_terminal("STRING") + xs1204.append(item1206) + cond1205 = self.match_lookahead_terminal("STRING", 0) + strings1207 = xs1204 self.consume_literal("]") - _t1976 = strings1199 + _t1992 = strings1207 else: - if prediction1194 == 0: - string1195 = self.consume_terminal("STRING") - _t1977 = [string1195] + if prediction1202 == 0: + string1203 = self.consume_terminal("STRING") + _t1993 = [string1203] else: raise ParseError("Unexpected token in gnf_column_path" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1976 = _t1977 - return _t1976 + _t1992 = _t1993 + return _t1992 def parse_csv_asof(self) -> str: self.consume_literal("(") self.consume_literal("asof") - string1200 = self.consume_terminal("STRING") + string1208 = self.consume_terminal("STRING") self.consume_literal(")") - return string1200 + return string1208 def parse_iceberg_data(self) -> logic_pb2.IcebergData: - span_start1207 = self.span_start() + span_start1215 = self.span_start() self.consume_literal("(") self.consume_literal("iceberg_data") - _t1978 = self.parse_iceberg_locator() - iceberg_locator1201 = _t1978 - _t1979 = self.parse_iceberg_catalog_config() - iceberg_catalog_config1202 = _t1979 - _t1980 = self.parse_gnf_columns() - gnf_columns1203 = _t1980 + _t1994 = self.parse_iceberg_locator() + iceberg_locator1209 = _t1994 + _t1995 = self.parse_iceberg_catalog_config() + iceberg_catalog_config1210 = _t1995 + _t1996 = self.parse_gnf_columns() + gnf_columns1211 = _t1996 if (self.match_lookahead_literal("(", 0) and self.match_lookahead_literal("from_snapshot", 1)): - _t1982 = self.parse_iceberg_from_snapshot() - _t1981 = _t1982 + _t1998 = self.parse_iceberg_from_snapshot() + _t1997 = _t1998 else: - _t1981 = None - iceberg_from_snapshot1204 = _t1981 + _t1997 = None + iceberg_from_snapshot1212 = _t1997 if self.match_lookahead_literal("(", 0): - _t1984 = self.parse_iceberg_to_snapshot() - _t1983 = _t1984 + _t2000 = self.parse_iceberg_to_snapshot() + _t1999 = _t2000 else: - _t1983 = None - iceberg_to_snapshot1205 = _t1983 - _t1985 = self.parse_boolean_value() - boolean_value1206 = _t1985 + _t1999 = None + iceberg_to_snapshot1213 = _t1999 + _t2001 = self.parse_boolean_value() + boolean_value1214 = _t2001 self.consume_literal(")") - _t1986 = self.construct_iceberg_data(iceberg_locator1201, iceberg_catalog_config1202, gnf_columns1203, iceberg_from_snapshot1204, iceberg_to_snapshot1205, boolean_value1206) - result1208 = _t1986 - self.record_span(span_start1207, "IcebergData") - return result1208 + _t2002 = self.construct_iceberg_data(iceberg_locator1209, iceberg_catalog_config1210, gnf_columns1211, iceberg_from_snapshot1212, iceberg_to_snapshot1213, boolean_value1214) + result1216 = _t2002 + self.record_span(span_start1215, "IcebergData") + return result1216 def parse_iceberg_locator(self) -> logic_pb2.IcebergLocator: - span_start1212 = self.span_start() + span_start1220 = self.span_start() self.consume_literal("(") self.consume_literal("iceberg_locator") - _t1987 = self.parse_iceberg_locator_table_name() - iceberg_locator_table_name1209 = _t1987 - _t1988 = self.parse_iceberg_locator_namespace() - iceberg_locator_namespace1210 = _t1988 - _t1989 = self.parse_iceberg_locator_warehouse() - iceberg_locator_warehouse1211 = _t1989 - self.consume_literal(")") - _t1990 = logic_pb2.IcebergLocator(table_name=iceberg_locator_table_name1209, namespace=iceberg_locator_namespace1210, warehouse=iceberg_locator_warehouse1211) - result1213 = _t1990 - self.record_span(span_start1212, "IcebergLocator") - return result1213 + _t2003 = self.parse_iceberg_locator_table_name() + iceberg_locator_table_name1217 = _t2003 + _t2004 = self.parse_iceberg_locator_namespace() + iceberg_locator_namespace1218 = _t2004 + _t2005 = self.parse_iceberg_locator_warehouse() + iceberg_locator_warehouse1219 = _t2005 + self.consume_literal(")") + _t2006 = logic_pb2.IcebergLocator(table_name=iceberg_locator_table_name1217, namespace=iceberg_locator_namespace1218, warehouse=iceberg_locator_warehouse1219) + result1221 = _t2006 + self.record_span(span_start1220, "IcebergLocator") + return result1221 def parse_iceberg_locator_table_name(self) -> str: self.consume_literal("(") self.consume_literal("table_name") - string1214 = self.consume_terminal("STRING") + string1222 = self.consume_terminal("STRING") self.consume_literal(")") - return string1214 + return string1222 def parse_iceberg_locator_namespace(self) -> Sequence[str]: self.consume_literal("(") self.consume_literal("namespace") - xs1215 = [] - cond1216 = self.match_lookahead_terminal("STRING", 0) - while cond1216: - item1217 = self.consume_terminal("STRING") - xs1215.append(item1217) - cond1216 = self.match_lookahead_terminal("STRING", 0) - strings1218 = xs1215 + xs1223 = [] + cond1224 = self.match_lookahead_terminal("STRING", 0) + while cond1224: + item1225 = self.consume_terminal("STRING") + xs1223.append(item1225) + cond1224 = self.match_lookahead_terminal("STRING", 0) + strings1226 = xs1223 self.consume_literal(")") - return strings1218 + return strings1226 def parse_iceberg_locator_warehouse(self) -> str: self.consume_literal("(") self.consume_literal("warehouse") - string1219 = self.consume_terminal("STRING") + string1227 = self.consume_terminal("STRING") self.consume_literal(")") - return string1219 + return string1227 def parse_iceberg_catalog_config(self) -> logic_pb2.IcebergCatalogConfig: - span_start1224 = self.span_start() + span_start1232 = self.span_start() self.consume_literal("(") self.consume_literal("iceberg_catalog_config") - _t1991 = self.parse_iceberg_catalog_uri() - iceberg_catalog_uri1220 = _t1991 + _t2007 = self.parse_iceberg_catalog_uri() + iceberg_catalog_uri1228 = _t2007 if (self.match_lookahead_literal("(", 0) and self.match_lookahead_literal("scope", 1)): - _t1993 = self.parse_iceberg_catalog_config_scope() - _t1992 = _t1993 + _t2009 = self.parse_iceberg_catalog_config_scope() + _t2008 = _t2009 else: - _t1992 = None - iceberg_catalog_config_scope1221 = _t1992 - _t1994 = self.parse_iceberg_properties() - iceberg_properties1222 = _t1994 - _t1995 = self.parse_iceberg_auth_properties() - iceberg_auth_properties1223 = _t1995 + _t2008 = None + iceberg_catalog_config_scope1229 = _t2008 + _t2010 = self.parse_iceberg_properties() + iceberg_properties1230 = _t2010 + _t2011 = self.parse_iceberg_auth_properties() + iceberg_auth_properties1231 = _t2011 self.consume_literal(")") - _t1996 = self.construct_iceberg_catalog_config(iceberg_catalog_uri1220, iceberg_catalog_config_scope1221, iceberg_properties1222, iceberg_auth_properties1223) - result1225 = _t1996 - self.record_span(span_start1224, "IcebergCatalogConfig") - return result1225 + _t2012 = self.construct_iceberg_catalog_config(iceberg_catalog_uri1228, iceberg_catalog_config_scope1229, iceberg_properties1230, iceberg_auth_properties1231) + result1233 = _t2012 + self.record_span(span_start1232, "IcebergCatalogConfig") + return result1233 def parse_iceberg_catalog_uri(self) -> str: self.consume_literal("(") self.consume_literal("catalog_uri") - string1226 = self.consume_terminal("STRING") + string1234 = self.consume_terminal("STRING") self.consume_literal(")") - return string1226 + return string1234 def parse_iceberg_catalog_config_scope(self) -> str: self.consume_literal("(") self.consume_literal("scope") - string1227 = self.consume_terminal("STRING") + string1235 = self.consume_terminal("STRING") self.consume_literal(")") - return string1227 + return string1235 def parse_iceberg_properties(self) -> Sequence[tuple[str, str]]: self.consume_literal("(") self.consume_literal("properties") - xs1228 = [] - cond1229 = self.match_lookahead_literal("(", 0) - while cond1229: - _t1997 = self.parse_iceberg_property_entry() - item1230 = _t1997 - xs1228.append(item1230) - cond1229 = self.match_lookahead_literal("(", 0) - iceberg_property_entrys1231 = xs1228 + xs1236 = [] + cond1237 = self.match_lookahead_literal("(", 0) + while cond1237: + _t2013 = self.parse_iceberg_property_entry() + item1238 = _t2013 + xs1236.append(item1238) + cond1237 = self.match_lookahead_literal("(", 0) + iceberg_property_entrys1239 = xs1236 self.consume_literal(")") - return iceberg_property_entrys1231 + return iceberg_property_entrys1239 def parse_iceberg_property_entry(self) -> tuple[str, str]: self.consume_literal("(") self.consume_literal("prop") - string1232 = self.consume_terminal("STRING") - string_31233 = self.consume_terminal("STRING") + string1240 = self.consume_terminal("STRING") + string_31241 = self.consume_terminal("STRING") self.consume_literal(")") - return (string1232, string_31233,) + return (string1240, string_31241,) def parse_iceberg_auth_properties(self) -> Sequence[tuple[str, str]]: self.consume_literal("(") self.consume_literal("auth_properties") - xs1234 = [] - cond1235 = self.match_lookahead_literal("(", 0) - while cond1235: - _t1998 = self.parse_iceberg_masked_property_entry() - item1236 = _t1998 - xs1234.append(item1236) - cond1235 = self.match_lookahead_literal("(", 0) - iceberg_masked_property_entrys1237 = xs1234 + xs1242 = [] + cond1243 = self.match_lookahead_literal("(", 0) + while cond1243: + _t2014 = self.parse_iceberg_masked_property_entry() + item1244 = _t2014 + xs1242.append(item1244) + cond1243 = self.match_lookahead_literal("(", 0) + iceberg_masked_property_entrys1245 = xs1242 self.consume_literal(")") - return iceberg_masked_property_entrys1237 + return iceberg_masked_property_entrys1245 def parse_iceberg_masked_property_entry(self) -> tuple[str, str]: self.consume_literal("(") self.consume_literal("prop") - string1238 = self.consume_terminal("STRING") - string_31239 = self.consume_terminal("STRING") + string1246 = self.consume_terminal("STRING") + string_31247 = self.consume_terminal("STRING") self.consume_literal(")") - return (string1238, string_31239,) + return (string1246, string_31247,) def parse_iceberg_from_snapshot(self) -> str: self.consume_literal("(") self.consume_literal("from_snapshot") - string1240 = self.consume_terminal("STRING") + string1248 = self.consume_terminal("STRING") self.consume_literal(")") - return string1240 + return string1248 def parse_iceberg_to_snapshot(self) -> str: self.consume_literal("(") self.consume_literal("to_snapshot") - string1241 = self.consume_terminal("STRING") + string1249 = self.consume_terminal("STRING") self.consume_literal(")") - return string1241 + return string1249 def parse_undefine(self) -> transactions_pb2.Undefine: - span_start1243 = self.span_start() + span_start1251 = self.span_start() self.consume_literal("(") self.consume_literal("undefine") - _t1999 = self.parse_fragment_id() - fragment_id1242 = _t1999 + _t2015 = self.parse_fragment_id() + fragment_id1250 = _t2015 self.consume_literal(")") - _t2000 = transactions_pb2.Undefine(fragment_id=fragment_id1242) - result1244 = _t2000 - self.record_span(span_start1243, "Undefine") - return result1244 + _t2016 = transactions_pb2.Undefine(fragment_id=fragment_id1250) + result1252 = _t2016 + self.record_span(span_start1251, "Undefine") + return result1252 def parse_context(self) -> transactions_pb2.Context: - span_start1249 = self.span_start() + span_start1257 = self.span_start() self.consume_literal("(") self.consume_literal("context") - xs1245 = [] - cond1246 = (self.match_lookahead_literal(":", 0) or self.match_lookahead_terminal("UINT128", 0)) - while cond1246: - _t2001 = self.parse_relation_id() - item1247 = _t2001 - xs1245.append(item1247) - cond1246 = (self.match_lookahead_literal(":", 0) or self.match_lookahead_terminal("UINT128", 0)) - relation_ids1248 = xs1245 - self.consume_literal(")") - _t2002 = transactions_pb2.Context(relations=relation_ids1248) - result1250 = _t2002 - self.record_span(span_start1249, "Context") - return result1250 + xs1253 = [] + cond1254 = (self.match_lookahead_literal(":", 0) or self.match_lookahead_terminal("UINT128", 0)) + while cond1254: + _t2017 = self.parse_relation_id() + item1255 = _t2017 + xs1253.append(item1255) + cond1254 = (self.match_lookahead_literal(":", 0) or self.match_lookahead_terminal("UINT128", 0)) + relation_ids1256 = xs1253 + self.consume_literal(")") + _t2018 = transactions_pb2.Context(relations=relation_ids1256) + result1258 = _t2018 + self.record_span(span_start1257, "Context") + return result1258 def parse_snapshot(self) -> transactions_pb2.Snapshot: - span_start1256 = self.span_start() + span_start1264 = self.span_start() self.consume_literal("(") self.consume_literal("snapshot") - _t2003 = self.parse_edb_path() - edb_path1251 = _t2003 - xs1252 = [] - cond1253 = self.match_lookahead_literal("[", 0) - while cond1253: - _t2004 = self.parse_snapshot_mapping() - item1254 = _t2004 - xs1252.append(item1254) - cond1253 = self.match_lookahead_literal("[", 0) - snapshot_mappings1255 = xs1252 - self.consume_literal(")") - _t2005 = transactions_pb2.Snapshot(prefix=edb_path1251, mappings=snapshot_mappings1255) - result1257 = _t2005 - self.record_span(span_start1256, "Snapshot") - return result1257 + _t2019 = self.parse_edb_path() + edb_path1259 = _t2019 + xs1260 = [] + cond1261 = self.match_lookahead_literal("[", 0) + while cond1261: + _t2020 = self.parse_snapshot_mapping() + item1262 = _t2020 + xs1260.append(item1262) + cond1261 = self.match_lookahead_literal("[", 0) + snapshot_mappings1263 = xs1260 + self.consume_literal(")") + _t2021 = transactions_pb2.Snapshot(prefix=edb_path1259, mappings=snapshot_mappings1263) + result1265 = _t2021 + self.record_span(span_start1264, "Snapshot") + return result1265 def parse_snapshot_mapping(self) -> transactions_pb2.SnapshotMapping: - span_start1260 = self.span_start() - _t2006 = self.parse_edb_path() - edb_path1258 = _t2006 - _t2007 = self.parse_relation_id() - relation_id1259 = _t2007 - _t2008 = transactions_pb2.SnapshotMapping(destination_path=edb_path1258, source_relation=relation_id1259) - result1261 = _t2008 - self.record_span(span_start1260, "SnapshotMapping") - return result1261 + span_start1268 = self.span_start() + _t2022 = self.parse_edb_path() + edb_path1266 = _t2022 + _t2023 = self.parse_relation_id() + relation_id1267 = _t2023 + _t2024 = transactions_pb2.SnapshotMapping(destination_path=edb_path1266, source_relation=relation_id1267) + result1269 = _t2024 + self.record_span(span_start1268, "SnapshotMapping") + return result1269 def parse_epoch_reads(self) -> Sequence[transactions_pb2.Read]: self.consume_literal("(") self.consume_literal("reads") - xs1262 = [] - cond1263 = self.match_lookahead_literal("(", 0) - while cond1263: - _t2009 = self.parse_read() - item1264 = _t2009 - xs1262.append(item1264) - cond1263 = self.match_lookahead_literal("(", 0) - reads1265 = xs1262 + xs1270 = [] + cond1271 = self.match_lookahead_literal("(", 0) + while cond1271: + _t2025 = self.parse_read() + item1272 = _t2025 + xs1270.append(item1272) + cond1271 = self.match_lookahead_literal("(", 0) + reads1273 = xs1270 self.consume_literal(")") - return reads1265 + return reads1273 def parse_read(self) -> transactions_pb2.Read: - span_start1272 = self.span_start() + span_start1281 = self.span_start() if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("what_if", 1): - _t2011 = 2 + _t2027 = 2 else: - if self.match_lookahead_literal("output", 1): - _t2012 = 1 + if self.match_lookahead_literal("output_export", 1): + _t2028 = 5 else: - if self.match_lookahead_literal("export_iceberg", 1): - _t2013 = 4 + if self.match_lookahead_literal("output", 1): + _t2029 = 1 else: - if self.match_lookahead_literal("export", 1): - _t2014 = 4 + if self.match_lookahead_literal("export_iceberg", 1): + _t2030 = 4 else: - if self.match_lookahead_literal("demand", 1): - _t2015 = 0 + if self.match_lookahead_literal("export", 1): + _t2031 = 4 else: - if self.match_lookahead_literal("abort", 1): - _t2016 = 3 + if self.match_lookahead_literal("demand", 1): + _t2032 = 0 else: - _t2016 = -1 - _t2015 = _t2016 - _t2014 = _t2015 - _t2013 = _t2014 - _t2012 = _t2013 - _t2011 = _t2012 - _t2010 = _t2011 - else: - _t2010 = -1 - prediction1266 = _t2010 - if prediction1266 == 4: - _t2018 = self.parse_export() - export1271 = _t2018 - _t2019 = transactions_pb2.Read(export=export1271) - _t2017 = _t2019 - else: - if prediction1266 == 3: - _t2021 = self.parse_abort() - abort1270 = _t2021 - _t2022 = transactions_pb2.Read(abort=abort1270) - _t2020 = _t2022 + if self.match_lookahead_literal("abort", 1): + _t2033 = 3 + else: + _t2033 = -1 + _t2032 = _t2033 + _t2031 = _t2032 + _t2030 = _t2031 + _t2029 = _t2030 + _t2028 = _t2029 + _t2027 = _t2028 + _t2026 = _t2027 + else: + _t2026 = -1 + prediction1274 = _t2026 + if prediction1274 == 5: + _t2035 = self.parse_export_output() + export_output1280 = _t2035 + _t2036 = transactions_pb2.Read(export_output=export_output1280) + _t2034 = _t2036 + else: + if prediction1274 == 4: + _t2038 = self.parse_export() + export1279 = _t2038 + _t2039 = transactions_pb2.Read(export=export1279) + _t2037 = _t2039 else: - if prediction1266 == 2: - _t2024 = self.parse_what_if() - what_if1269 = _t2024 - _t2025 = transactions_pb2.Read(what_if=what_if1269) - _t2023 = _t2025 + if prediction1274 == 3: + _t2041 = self.parse_abort() + abort1278 = _t2041 + _t2042 = transactions_pb2.Read(abort=abort1278) + _t2040 = _t2042 else: - if prediction1266 == 1: - _t2027 = self.parse_output() - output1268 = _t2027 - _t2028 = transactions_pb2.Read(output=output1268) - _t2026 = _t2028 + if prediction1274 == 2: + _t2044 = self.parse_what_if() + what_if1277 = _t2044 + _t2045 = transactions_pb2.Read(what_if=what_if1277) + _t2043 = _t2045 else: - if prediction1266 == 0: - _t2030 = self.parse_demand() - demand1267 = _t2030 - _t2031 = transactions_pb2.Read(demand=demand1267) - _t2029 = _t2031 + if prediction1274 == 1: + _t2047 = self.parse_output() + output1276 = _t2047 + _t2048 = transactions_pb2.Read(output=output1276) + _t2046 = _t2048 else: - raise ParseError("Unexpected token in read" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t2026 = _t2029 - _t2023 = _t2026 - _t2020 = _t2023 - _t2017 = _t2020 - result1273 = _t2017 - self.record_span(span_start1272, "Read") - return result1273 + if prediction1274 == 0: + _t2050 = self.parse_demand() + demand1275 = _t2050 + _t2051 = transactions_pb2.Read(demand=demand1275) + _t2049 = _t2051 + else: + raise ParseError("Unexpected token in read" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") + _t2046 = _t2049 + _t2043 = _t2046 + _t2040 = _t2043 + _t2037 = _t2040 + _t2034 = _t2037 + result1282 = _t2034 + self.record_span(span_start1281, "Read") + return result1282 def parse_demand(self) -> transactions_pb2.Demand: - span_start1275 = self.span_start() + span_start1284 = self.span_start() self.consume_literal("(") self.consume_literal("demand") - _t2032 = self.parse_relation_id() - relation_id1274 = _t2032 + _t2052 = self.parse_relation_id() + relation_id1283 = _t2052 self.consume_literal(")") - _t2033 = transactions_pb2.Demand(relation_id=relation_id1274) - result1276 = _t2033 - self.record_span(span_start1275, "Demand") - return result1276 + _t2053 = transactions_pb2.Demand(relation_id=relation_id1283) + result1285 = _t2053 + self.record_span(span_start1284, "Demand") + return result1285 def parse_output(self) -> transactions_pb2.Output: - span_start1279 = self.span_start() + span_start1288 = self.span_start() self.consume_literal("(") self.consume_literal("output") - _t2034 = self.parse_name() - name1277 = _t2034 - _t2035 = self.parse_relation_id() - relation_id1278 = _t2035 + _t2054 = self.parse_name() + name1286 = _t2054 + _t2055 = self.parse_relation_id() + relation_id1287 = _t2055 self.consume_literal(")") - _t2036 = transactions_pb2.Output(name=name1277, relation_id=relation_id1278) - result1280 = _t2036 - self.record_span(span_start1279, "Output") - return result1280 + _t2056 = transactions_pb2.Output(name=name1286, relation_id=relation_id1287) + result1289 = _t2056 + self.record_span(span_start1288, "Output") + return result1289 def parse_what_if(self) -> transactions_pb2.WhatIf: - span_start1283 = self.span_start() + span_start1292 = self.span_start() self.consume_literal("(") self.consume_literal("what_if") - _t2037 = self.parse_name() - name1281 = _t2037 - _t2038 = self.parse_epoch() - epoch1282 = _t2038 - self.consume_literal(")") - _t2039 = transactions_pb2.WhatIf(branch=name1281, epoch=epoch1282) - result1284 = _t2039 - self.record_span(span_start1283, "WhatIf") - return result1284 + _t2057 = self.parse_name() + name1290 = _t2057 + _t2058 = self.parse_epoch() + epoch1291 = _t2058 + self.consume_literal(")") + _t2059 = transactions_pb2.WhatIf(branch=name1290, epoch=epoch1291) + result1293 = _t2059 + self.record_span(span_start1292, "WhatIf") + return result1293 def parse_abort(self) -> transactions_pb2.Abort: - span_start1287 = self.span_start() + span_start1296 = self.span_start() self.consume_literal("(") self.consume_literal("abort") if (self.match_lookahead_literal(":", 0) and self.match_lookahead_terminal("SYMBOL", 1)): - _t2041 = self.parse_name() - _t2040 = _t2041 + _t2061 = self.parse_name() + _t2060 = _t2061 else: - _t2040 = None - name1285 = _t2040 - _t2042 = self.parse_relation_id() - relation_id1286 = _t2042 + _t2060 = None + name1294 = _t2060 + _t2062 = self.parse_relation_id() + relation_id1295 = _t2062 self.consume_literal(")") - _t2043 = transactions_pb2.Abort(name=(name1285 if name1285 is not None else "abort"), relation_id=relation_id1286) - result1288 = _t2043 - self.record_span(span_start1287, "Abort") - return result1288 + _t2063 = transactions_pb2.Abort(name=(name1294 if name1294 is not None else "abort"), relation_id=relation_id1295) + result1297 = _t2063 + self.record_span(span_start1296, "Abort") + return result1297 def parse_export(self) -> transactions_pb2.Export: - span_start1292 = self.span_start() + span_start1301 = self.span_start() if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("export_iceberg", 1): - _t2045 = 1 + _t2065 = 1 else: if self.match_lookahead_literal("export", 1): - _t2046 = 0 + _t2066 = 0 else: - _t2046 = -1 - _t2045 = _t2046 - _t2044 = _t2045 + _t2066 = -1 + _t2065 = _t2066 + _t2064 = _t2065 else: - _t2044 = -1 - prediction1289 = _t2044 - if prediction1289 == 1: + _t2064 = -1 + prediction1298 = _t2064 + if prediction1298 == 1: self.consume_literal("(") self.consume_literal("export_iceberg") - _t2048 = self.parse_export_iceberg_config() - export_iceberg_config1291 = _t2048 + _t2068 = self.parse_export_iceberg_config() + export_iceberg_config1300 = _t2068 self.consume_literal(")") - _t2049 = transactions_pb2.Export(iceberg_config=export_iceberg_config1291) - _t2047 = _t2049 + _t2069 = transactions_pb2.Export(iceberg_config=export_iceberg_config1300) + _t2067 = _t2069 else: - if prediction1289 == 0: + if prediction1298 == 0: self.consume_literal("(") self.consume_literal("export") - _t2051 = self.parse_export_csv_config() - export_csv_config1290 = _t2051 + _t2071 = self.parse_export_csv_config() + export_csv_config1299 = _t2071 self.consume_literal(")") - _t2052 = transactions_pb2.Export(csv_config=export_csv_config1290) - _t2050 = _t2052 + _t2072 = transactions_pb2.Export(csv_config=export_csv_config1299) + _t2070 = _t2072 else: raise ParseError("Unexpected token in export" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t2047 = _t2050 - result1293 = _t2047 - self.record_span(span_start1292, "Export") - return result1293 + _t2067 = _t2070 + result1302 = _t2067 + self.record_span(span_start1301, "Export") + return result1302 def parse_export_csv_config(self) -> transactions_pb2.ExportCSVConfig: - span_start1301 = self.span_start() + span_start1310 = self.span_start() if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("export_csv_config_v2", 1): - _t2054 = 0 + _t2074 = 0 else: if self.match_lookahead_literal("export_csv_config", 1): - _t2055 = 1 + _t2075 = 1 else: - _t2055 = -1 - _t2054 = _t2055 - _t2053 = _t2054 + _t2075 = -1 + _t2074 = _t2075 + _t2073 = _t2074 else: - _t2053 = -1 - prediction1294 = _t2053 - if prediction1294 == 1: + _t2073 = -1 + prediction1303 = _t2073 + if prediction1303 == 1: self.consume_literal("(") self.consume_literal("export_csv_config") - _t2057 = self.parse_export_csv_path() - export_csv_path1298 = _t2057 - _t2058 = self.parse_export_csv_columns_list() - export_csv_columns_list1299 = _t2058 - _t2059 = self.parse_config_dict() - config_dict1300 = _t2059 + _t2077 = self.parse_export_csv_path() + export_csv_path1307 = _t2077 + _t2078 = self.parse_export_csv_columns_list() + export_csv_columns_list1308 = _t2078 + _t2079 = self.parse_config_dict() + config_dict1309 = _t2079 self.consume_literal(")") - _t2060 = self.construct_export_csv_config(export_csv_path1298, export_csv_columns_list1299, config_dict1300) - _t2056 = _t2060 + _t2080 = self.construct_export_csv_config(export_csv_path1307, export_csv_columns_list1308, config_dict1309) + _t2076 = _t2080 else: - if prediction1294 == 0: + if prediction1303 == 0: self.consume_literal("(") self.consume_literal("export_csv_config_v2") - _t2062 = self.parse_export_csv_path() - export_csv_path1295 = _t2062 - _t2063 = self.parse_export_csv_source() - export_csv_source1296 = _t2063 - _t2064 = self.parse_csv_config() - csv_config1297 = _t2064 + _t2082 = self.parse_export_csv_path() + export_csv_path1304 = _t2082 + _t2083 = self.parse_export_csv_source() + export_csv_source1305 = _t2083 + _t2084 = self.parse_csv_config() + csv_config1306 = _t2084 self.consume_literal(")") - _t2065 = self.construct_export_csv_config_with_source(export_csv_path1295, export_csv_source1296, csv_config1297) - _t2061 = _t2065 + _t2085 = self.construct_export_csv_config_with_source(export_csv_path1304, export_csv_source1305, csv_config1306) + _t2081 = _t2085 else: raise ParseError("Unexpected token in export_csv_config" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t2056 = _t2061 - result1302 = _t2056 - self.record_span(span_start1301, "ExportCSVConfig") - return result1302 + _t2076 = _t2081 + result1311 = _t2076 + self.record_span(span_start1310, "ExportCSVConfig") + return result1311 def parse_export_csv_path(self) -> str: self.consume_literal("(") self.consume_literal("path") - string1303 = self.consume_terminal("STRING") + string1312 = self.consume_terminal("STRING") self.consume_literal(")") - return string1303 + return string1312 def parse_export_csv_source(self) -> transactions_pb2.ExportCSVSource: - span_start1310 = self.span_start() + span_start1319 = self.span_start() if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("table_def", 1): - _t2067 = 1 + _t2087 = 1 else: if self.match_lookahead_literal("gnf_columns", 1): - _t2068 = 0 + _t2088 = 0 else: - _t2068 = -1 - _t2067 = _t2068 - _t2066 = _t2067 + _t2088 = -1 + _t2087 = _t2088 + _t2086 = _t2087 else: - _t2066 = -1 - prediction1304 = _t2066 - if prediction1304 == 1: + _t2086 = -1 + prediction1313 = _t2086 + if prediction1313 == 1: self.consume_literal("(") self.consume_literal("table_def") - _t2070 = self.parse_relation_id() - relation_id1309 = _t2070 + _t2090 = self.parse_relation_id() + relation_id1318 = _t2090 self.consume_literal(")") - _t2071 = transactions_pb2.ExportCSVSource(table_def=relation_id1309) - _t2069 = _t2071 + _t2091 = transactions_pb2.ExportCSVSource(table_def=relation_id1318) + _t2089 = _t2091 else: - if prediction1304 == 0: + if prediction1313 == 0: self.consume_literal("(") self.consume_literal("gnf_columns") - xs1305 = [] - cond1306 = self.match_lookahead_literal("(", 0) - while cond1306: - _t2073 = self.parse_export_csv_column() - item1307 = _t2073 - xs1305.append(item1307) - cond1306 = self.match_lookahead_literal("(", 0) - export_csv_columns1308 = xs1305 + xs1314 = [] + cond1315 = self.match_lookahead_literal("(", 0) + while cond1315: + _t2093 = self.parse_export_csv_column() + item1316 = _t2093 + xs1314.append(item1316) + cond1315 = self.match_lookahead_literal("(", 0) + export_csv_columns1317 = xs1314 self.consume_literal(")") - _t2074 = transactions_pb2.ExportCSVColumns(columns=export_csv_columns1308) - _t2075 = transactions_pb2.ExportCSVSource(gnf_columns=_t2074) - _t2072 = _t2075 + _t2094 = transactions_pb2.ExportCSVColumns(columns=export_csv_columns1317) + _t2095 = transactions_pb2.ExportCSVSource(gnf_columns=_t2094) + _t2092 = _t2095 else: raise ParseError("Unexpected token in export_csv_source" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t2069 = _t2072 - result1311 = _t2069 - self.record_span(span_start1310, "ExportCSVSource") - return result1311 + _t2089 = _t2092 + result1320 = _t2089 + self.record_span(span_start1319, "ExportCSVSource") + return result1320 def parse_export_csv_column(self) -> transactions_pb2.ExportCSVColumn: - span_start1314 = self.span_start() + span_start1323 = self.span_start() self.consume_literal("(") self.consume_literal("column") - string1312 = self.consume_terminal("STRING") - _t2076 = self.parse_relation_id() - relation_id1313 = _t2076 + string1321 = self.consume_terminal("STRING") + _t2096 = self.parse_relation_id() + relation_id1322 = _t2096 self.consume_literal(")") - _t2077 = transactions_pb2.ExportCSVColumn(column_name=string1312, column_data=relation_id1313) - result1315 = _t2077 - self.record_span(span_start1314, "ExportCSVColumn") - return result1315 + _t2097 = transactions_pb2.ExportCSVColumn(column_name=string1321, column_data=relation_id1322) + result1324 = _t2097 + self.record_span(span_start1323, "ExportCSVColumn") + return result1324 def parse_export_csv_columns_list(self) -> Sequence[transactions_pb2.ExportCSVColumn]: self.consume_literal("(") self.consume_literal("columns") - xs1316 = [] - cond1317 = self.match_lookahead_literal("(", 0) - while cond1317: - _t2078 = self.parse_export_csv_column() - item1318 = _t2078 - xs1316.append(item1318) - cond1317 = self.match_lookahead_literal("(", 0) - export_csv_columns1319 = xs1316 + xs1325 = [] + cond1326 = self.match_lookahead_literal("(", 0) + while cond1326: + _t2098 = self.parse_export_csv_column() + item1327 = _t2098 + xs1325.append(item1327) + cond1326 = self.match_lookahead_literal("(", 0) + export_csv_columns1328 = xs1325 self.consume_literal(")") - return export_csv_columns1319 + return export_csv_columns1328 def parse_export_iceberg_config(self) -> transactions_pb2.ExportIcebergConfig: - span_start1325 = self.span_start() + span_start1334 = self.span_start() self.consume_literal("(") self.consume_literal("export_iceberg_config") - _t2079 = self.parse_iceberg_locator() - iceberg_locator1320 = _t2079 - _t2080 = self.parse_iceberg_catalog_config() - iceberg_catalog_config1321 = _t2080 - _t2081 = self.parse_export_iceberg_table_def() - export_iceberg_table_def1322 = _t2081 - _t2082 = self.parse_iceberg_table_properties() - iceberg_table_properties1323 = _t2082 + _t2099 = self.parse_iceberg_locator() + iceberg_locator1329 = _t2099 + _t2100 = self.parse_iceberg_catalog_config() + iceberg_catalog_config1330 = _t2100 + _t2101 = self.parse_export_iceberg_table_def() + export_iceberg_table_def1331 = _t2101 + _t2102 = self.parse_iceberg_table_properties() + iceberg_table_properties1332 = _t2102 if self.match_lookahead_literal("{", 0): - _t2084 = self.parse_config_dict() - _t2083 = _t2084 + _t2104 = self.parse_config_dict() + _t2103 = _t2104 else: - _t2083 = None - config_dict1324 = _t2083 + _t2103 = None + config_dict1333 = _t2103 self.consume_literal(")") - _t2085 = self.construct_export_iceberg_config_full(iceberg_locator1320, iceberg_catalog_config1321, export_iceberg_table_def1322, iceberg_table_properties1323, config_dict1324) - result1326 = _t2085 - self.record_span(span_start1325, "ExportIcebergConfig") - return result1326 + _t2105 = self.construct_export_iceberg_config_full(iceberg_locator1329, iceberg_catalog_config1330, export_iceberg_table_def1331, iceberg_table_properties1332, config_dict1333) + result1335 = _t2105 + self.record_span(span_start1334, "ExportIcebergConfig") + return result1335 def parse_export_iceberg_table_def(self) -> logic_pb2.RelationId: - span_start1328 = self.span_start() + span_start1337 = self.span_start() self.consume_literal("(") self.consume_literal("table_def") - _t2086 = self.parse_relation_id() - relation_id1327 = _t2086 + _t2106 = self.parse_relation_id() + relation_id1336 = _t2106 self.consume_literal(")") - result1329 = relation_id1327 - self.record_span(span_start1328, "RelationId") - return result1329 + result1338 = relation_id1336 + self.record_span(span_start1337, "RelationId") + return result1338 def parse_iceberg_table_properties(self) -> Sequence[tuple[str, str]]: self.consume_literal("(") self.consume_literal("table_properties") - xs1330 = [] - cond1331 = self.match_lookahead_literal("(", 0) - while cond1331: - _t2087 = self.parse_iceberg_property_entry() - item1332 = _t2087 - xs1330.append(item1332) - cond1331 = self.match_lookahead_literal("(", 0) - iceberg_property_entrys1333 = xs1330 - self.consume_literal(")") - return iceberg_property_entrys1333 + xs1339 = [] + cond1340 = self.match_lookahead_literal("(", 0) + while cond1340: + _t2107 = self.parse_iceberg_property_entry() + item1341 = _t2107 + xs1339.append(item1341) + cond1340 = self.match_lookahead_literal("(", 0) + iceberg_property_entrys1342 = xs1339 + self.consume_literal(")") + return iceberg_property_entrys1342 + + def parse_export_output(self) -> transactions_pb2.ExportOutput: + span_start1344 = self.span_start() + self.consume_literal("(") + self.consume_literal("output_export") + _t2108 = self.parse_export_csv_output() + export_csv_output1343 = _t2108 + self.consume_literal(")") + _t2109 = transactions_pb2.ExportOutput(csv=export_csv_output1343) + result1345 = _t2109 + self.record_span(span_start1344, "ExportOutput") + return result1345 + + def parse_export_csv_output(self) -> transactions_pb2.ExportCSVOutput: + span_start1348 = self.span_start() + self.consume_literal("(") + self.consume_literal("csv") + _t2110 = self.parse_export_csv_source() + export_csv_source1346 = _t2110 + _t2111 = self.parse_csv_config() + csv_config1347 = _t2111 + self.consume_literal(")") + _t2112 = transactions_pb2.ExportCSVOutput(csv_source=export_csv_source1346, csv_config=csv_config1347) + result1349 = _t2112 + self.record_span(span_start1348, "ExportCSVOutput") + return result1349 def parse_transaction(input_str: str) -> tuple[Any, dict[int, Span]]: diff --git a/sdks/python/src/lqp/gen/pretty.py b/sdks/python/src/lqp/gen/pretty.py index f0b28fa6..7b4a5fa9 100644 --- a/sdks/python/src/lqp/gen/pretty.py +++ b/sdks/python/src/lqp/gen/pretty.py @@ -217,159 +217,159 @@ def write_debug_info(self) -> None: # --- Helper functions --- def _make_value_int32(self, v: int) -> logic_pb2.Value: - _t1742 = logic_pb2.Value(int32_value=v) - return _t1742 + _t1764 = logic_pb2.Value(int32_value=v) + return _t1764 def _make_value_int64(self, v: int) -> logic_pb2.Value: - _t1743 = logic_pb2.Value(int_value=v) - return _t1743 + _t1765 = logic_pb2.Value(int_value=v) + return _t1765 def _make_value_float64(self, v: float) -> logic_pb2.Value: - _t1744 = logic_pb2.Value(float_value=v) - return _t1744 + _t1766 = logic_pb2.Value(float_value=v) + return _t1766 def _make_value_string(self, v: str) -> logic_pb2.Value: - _t1745 = logic_pb2.Value(string_value=v) - return _t1745 + _t1767 = logic_pb2.Value(string_value=v) + return _t1767 def _make_value_boolean(self, v: bool) -> logic_pb2.Value: - _t1746 = logic_pb2.Value(boolean_value=v) - return _t1746 + _t1768 = logic_pb2.Value(boolean_value=v) + return _t1768 def _make_value_uint128(self, v: logic_pb2.UInt128Value) -> logic_pb2.Value: - _t1747 = logic_pb2.Value(uint128_value=v) - return _t1747 + _t1769 = logic_pb2.Value(uint128_value=v) + return _t1769 def deconstruct_configure(self, msg: transactions_pb2.Configure) -> list[tuple[str, logic_pb2.Value]]: result = [] if msg.ivm_config.level == transactions_pb2.MaintenanceLevel.MAINTENANCE_LEVEL_AUTO: - _t1748 = self._make_value_string("auto") - result.append(("ivm.maintenance_level", _t1748,)) + _t1770 = self._make_value_string("auto") + result.append(("ivm.maintenance_level", _t1770,)) else: if msg.ivm_config.level == transactions_pb2.MaintenanceLevel.MAINTENANCE_LEVEL_ALL: - _t1749 = self._make_value_string("all") - result.append(("ivm.maintenance_level", _t1749,)) + _t1771 = self._make_value_string("all") + result.append(("ivm.maintenance_level", _t1771,)) else: if msg.ivm_config.level == transactions_pb2.MaintenanceLevel.MAINTENANCE_LEVEL_OFF: - _t1750 = self._make_value_string("off") - result.append(("ivm.maintenance_level", _t1750,)) - _t1751 = self._make_value_int64(msg.semantics_version) - result.append(("semantics_version", _t1751,)) + _t1772 = self._make_value_string("off") + result.append(("ivm.maintenance_level", _t1772,)) + _t1773 = self._make_value_int64(msg.semantics_version) + result.append(("semantics_version", _t1773,)) return sorted(result) def deconstruct_csv_config(self, msg: logic_pb2.CSVConfig) -> list[tuple[str, logic_pb2.Value]]: result = [] - _t1752 = self._make_value_int32(msg.header_row) - result.append(("csv_header_row", _t1752,)) - _t1753 = self._make_value_int64(msg.skip) - result.append(("csv_skip", _t1753,)) + _t1774 = self._make_value_int32(msg.header_row) + result.append(("csv_header_row", _t1774,)) + _t1775 = self._make_value_int64(msg.skip) + result.append(("csv_skip", _t1775,)) if msg.new_line != "": - _t1754 = self._make_value_string(msg.new_line) - result.append(("csv_new_line", _t1754,)) - _t1755 = self._make_value_string(msg.delimiter) - result.append(("csv_delimiter", _t1755,)) - _t1756 = self._make_value_string(msg.quotechar) - result.append(("csv_quotechar", _t1756,)) - _t1757 = self._make_value_string(msg.escapechar) - result.append(("csv_escapechar", _t1757,)) + _t1776 = self._make_value_string(msg.new_line) + result.append(("csv_new_line", _t1776,)) + _t1777 = self._make_value_string(msg.delimiter) + result.append(("csv_delimiter", _t1777,)) + _t1778 = self._make_value_string(msg.quotechar) + result.append(("csv_quotechar", _t1778,)) + _t1779 = self._make_value_string(msg.escapechar) + result.append(("csv_escapechar", _t1779,)) if msg.comment != "": - _t1758 = self._make_value_string(msg.comment) - result.append(("csv_comment", _t1758,)) + _t1780 = self._make_value_string(msg.comment) + result.append(("csv_comment", _t1780,)) for missing_string in msg.missing_strings: - _t1759 = self._make_value_string(missing_string) - result.append(("csv_missing_strings", _t1759,)) - _t1760 = self._make_value_string(msg.decimal_separator) - result.append(("csv_decimal_separator", _t1760,)) - _t1761 = self._make_value_string(msg.encoding) - result.append(("csv_encoding", _t1761,)) - _t1762 = self._make_value_string(msg.compression) - result.append(("csv_compression", _t1762,)) + _t1781 = self._make_value_string(missing_string) + result.append(("csv_missing_strings", _t1781,)) + _t1782 = self._make_value_string(msg.decimal_separator) + result.append(("csv_decimal_separator", _t1782,)) + _t1783 = self._make_value_string(msg.encoding) + result.append(("csv_encoding", _t1783,)) + _t1784 = self._make_value_string(msg.compression) + result.append(("csv_compression", _t1784,)) if msg.partition_size_mb != 0: - _t1763 = self._make_value_int64(msg.partition_size_mb) - result.append(("csv_partition_size_mb", _t1763,)) + _t1785 = self._make_value_int64(msg.partition_size_mb) + result.append(("csv_partition_size_mb", _t1785,)) return sorted(result) def deconstruct_csv_storage_integration_optional(self, msg: logic_pb2.CSVConfig) -> Sequence[tuple[str, logic_pb2.Value]] | None: if not msg.HasField("storage_integration"): return None else: - _t1764 = None + _t1786 = None assert msg.storage_integration is not None si = msg.storage_integration result = [] if si.provider != "": - _t1765 = self._make_value_string(si.provider) - result.append(("provider", _t1765,)) + _t1787 = self._make_value_string(si.provider) + result.append(("provider", _t1787,)) if si.azure_sas_token != "": - _t1766 = self._make_value_string("***") - result.append(("azure_sas_token", _t1766,)) + _t1788 = self._make_value_string("***") + result.append(("azure_sas_token", _t1788,)) if si.s3_region != "": - _t1767 = self._make_value_string(si.s3_region) - result.append(("s3_region", _t1767,)) + _t1789 = self._make_value_string(si.s3_region) + result.append(("s3_region", _t1789,)) if si.s3_access_key_id != "": - _t1768 = self._make_value_string("***") - result.append(("s3_access_key_id", _t1768,)) + _t1790 = self._make_value_string("***") + result.append(("s3_access_key_id", _t1790,)) if si.s3_secret_access_key != "": - _t1769 = self._make_value_string("***") - result.append(("s3_secret_access_key", _t1769,)) + _t1791 = self._make_value_string("***") + result.append(("s3_secret_access_key", _t1791,)) return sorted(result) def deconstruct_betree_info_config(self, msg: logic_pb2.BeTreeInfo) -> list[tuple[str, logic_pb2.Value]]: result = [] - _t1770 = self._make_value_float64(msg.storage_config.epsilon) - result.append(("betree_config_epsilon", _t1770,)) - _t1771 = self._make_value_int64(msg.storage_config.max_pivots) - result.append(("betree_config_max_pivots", _t1771,)) - _t1772 = self._make_value_int64(msg.storage_config.max_deltas) - result.append(("betree_config_max_deltas", _t1772,)) - _t1773 = self._make_value_int64(msg.storage_config.max_leaf) - result.append(("betree_config_max_leaf", _t1773,)) + _t1792 = self._make_value_float64(msg.storage_config.epsilon) + result.append(("betree_config_epsilon", _t1792,)) + _t1793 = self._make_value_int64(msg.storage_config.max_pivots) + result.append(("betree_config_max_pivots", _t1793,)) + _t1794 = self._make_value_int64(msg.storage_config.max_deltas) + result.append(("betree_config_max_deltas", _t1794,)) + _t1795 = self._make_value_int64(msg.storage_config.max_leaf) + result.append(("betree_config_max_leaf", _t1795,)) if msg.relation_locator.HasField("root_pageid"): if msg.relation_locator.root_pageid is not None: assert msg.relation_locator.root_pageid is not None - _t1774 = self._make_value_uint128(msg.relation_locator.root_pageid) - result.append(("betree_locator_root_pageid", _t1774,)) + _t1796 = self._make_value_uint128(msg.relation_locator.root_pageid) + result.append(("betree_locator_root_pageid", _t1796,)) if msg.relation_locator.HasField("inline_data"): if msg.relation_locator.inline_data is not None: assert msg.relation_locator.inline_data is not None - _t1775 = self._make_value_string(msg.relation_locator.inline_data.decode('utf-8')) - result.append(("betree_locator_inline_data", _t1775,)) - _t1776 = self._make_value_int64(msg.relation_locator.element_count) - result.append(("betree_locator_element_count", _t1776,)) - _t1777 = self._make_value_int64(msg.relation_locator.tree_height) - result.append(("betree_locator_tree_height", _t1777,)) + _t1797 = self._make_value_string(msg.relation_locator.inline_data.decode('utf-8')) + result.append(("betree_locator_inline_data", _t1797,)) + _t1798 = self._make_value_int64(msg.relation_locator.element_count) + result.append(("betree_locator_element_count", _t1798,)) + _t1799 = self._make_value_int64(msg.relation_locator.tree_height) + result.append(("betree_locator_tree_height", _t1799,)) return sorted(result) def deconstruct_export_csv_config(self, msg: transactions_pb2.ExportCSVConfig) -> list[tuple[str, logic_pb2.Value]]: result = [] if msg.partition_size is not None: assert msg.partition_size is not None - _t1778 = self._make_value_int64(msg.partition_size) - result.append(("partition_size", _t1778,)) + _t1800 = self._make_value_int64(msg.partition_size) + result.append(("partition_size", _t1800,)) if msg.compression is not None: assert msg.compression is not None - _t1779 = self._make_value_string(msg.compression) - result.append(("compression", _t1779,)) + _t1801 = self._make_value_string(msg.compression) + result.append(("compression", _t1801,)) if msg.syntax_header_row is not None: assert msg.syntax_header_row is not None - _t1780 = self._make_value_boolean(msg.syntax_header_row) - result.append(("syntax_header_row", _t1780,)) + _t1802 = self._make_value_boolean(msg.syntax_header_row) + result.append(("syntax_header_row", _t1802,)) if msg.syntax_missing_string is not None: assert msg.syntax_missing_string is not None - _t1781 = self._make_value_string(msg.syntax_missing_string) - result.append(("syntax_missing_string", _t1781,)) + _t1803 = self._make_value_string(msg.syntax_missing_string) + result.append(("syntax_missing_string", _t1803,)) if msg.syntax_delim is not None: assert msg.syntax_delim is not None - _t1782 = self._make_value_string(msg.syntax_delim) - result.append(("syntax_delim", _t1782,)) + _t1804 = self._make_value_string(msg.syntax_delim) + result.append(("syntax_delim", _t1804,)) if msg.syntax_quotechar is not None: assert msg.syntax_quotechar is not None - _t1783 = self._make_value_string(msg.syntax_quotechar) - result.append(("syntax_quotechar", _t1783,)) + _t1805 = self._make_value_string(msg.syntax_quotechar) + result.append(("syntax_quotechar", _t1805,)) if msg.syntax_escapechar is not None: assert msg.syntax_escapechar is not None - _t1784 = self._make_value_string(msg.syntax_escapechar) - result.append(("syntax_escapechar", _t1784,)) + _t1806 = self._make_value_string(msg.syntax_escapechar) + result.append(("syntax_escapechar", _t1806,)) return sorted(result) def mask_secret_value(self, pair: tuple[str, str]) -> str: @@ -381,7 +381,7 @@ def deconstruct_iceberg_catalog_config_scope_optional(self, msg: logic_pb2.Icebe assert msg.scope is not None return msg.scope else: - _t1785 = None + _t1807 = None return None def deconstruct_iceberg_data_from_snapshot_optional(self, msg: logic_pb2.IcebergData) -> str | None: @@ -390,7 +390,7 @@ def deconstruct_iceberg_data_from_snapshot_optional(self, msg: logic_pb2.Iceberg assert msg.from_snapshot is not None return msg.from_snapshot else: - _t1786 = None + _t1808 = None return None def deconstruct_iceberg_data_to_snapshot_optional(self, msg: logic_pb2.IcebergData) -> str | None: @@ -399,7 +399,7 @@ def deconstruct_iceberg_data_to_snapshot_optional(self, msg: logic_pb2.IcebergDa assert msg.to_snapshot is not None return msg.to_snapshot else: - _t1787 = None + _t1809 = None return None def deconstruct_export_iceberg_config_optional(self, msg: transactions_pb2.ExportIcebergConfig) -> Sequence[tuple[str, logic_pb2.Value]] | None: @@ -407,20 +407,20 @@ def deconstruct_export_iceberg_config_optional(self, msg: transactions_pb2.Expor assert msg.prefix is not None if msg.prefix != "": assert msg.prefix is not None - _t1788 = self._make_value_string(msg.prefix) - result.append(("prefix", _t1788,)) + _t1810 = self._make_value_string(msg.prefix) + result.append(("prefix", _t1810,)) assert msg.target_file_size_bytes is not None if msg.target_file_size_bytes != 0: assert msg.target_file_size_bytes is not None - _t1789 = self._make_value_int64(msg.target_file_size_bytes) - result.append(("target_file_size_bytes", _t1789,)) + _t1811 = self._make_value_int64(msg.target_file_size_bytes) + result.append(("target_file_size_bytes", _t1811,)) if msg.compression != "": - _t1790 = self._make_value_string(msg.compression) - result.append(("compression", _t1790,)) + _t1812 = self._make_value_string(msg.compression) + result.append(("compression", _t1812,)) if len(result) == 0: return None else: - _t1791 = None + _t1813 = None return sorted(result) def deconstruct_relation_id_string(self, msg: logic_pb2.RelationId) -> str: @@ -433,7 +433,7 @@ def deconstruct_relation_id_uint128(self, msg: logic_pb2.RelationId) -> logic_pb if name is None: return self.relation_id_to_uint128(msg) else: - _t1792 = None + _t1814 = None return None def deconstruct_bindings(self, abs: logic_pb2.Abstraction) -> tuple[Sequence[logic_pb2.Binding], Sequence[logic_pb2.Binding]]: @@ -448,3936 +448,3991 @@ def deconstruct_bindings_with_arity(self, abs: logic_pb2.Abstraction, value_arit # --- Pretty-print methods --- def pretty_transaction(self, msg: transactions_pb2.Transaction): - flat808 = self._try_flat(msg, self.pretty_transaction) - if flat808 is not None: - assert flat808 is not None - self.write(flat808) + flat818 = self._try_flat(msg, self.pretty_transaction) + if flat818 is not None: + assert flat818 is not None + self.write(flat818) return None else: _dollar_dollar = msg if _dollar_dollar.HasField("configure"): - _t1598 = _dollar_dollar.configure + _t1618 = _dollar_dollar.configure else: - _t1598 = None + _t1618 = None if _dollar_dollar.HasField("sync"): - _t1599 = _dollar_dollar.sync + _t1619 = _dollar_dollar.sync else: - _t1599 = None - fields799 = (_t1598, _t1599, _dollar_dollar.epochs,) - assert fields799 is not None - unwrapped_fields800 = fields799 + _t1619 = None + fields809 = (_t1618, _t1619, _dollar_dollar.epochs,) + assert fields809 is not None + unwrapped_fields810 = fields809 self.write("(transaction") self.indent_sexp() - field801 = unwrapped_fields800[0] - if field801 is not None: + field811 = unwrapped_fields810[0] + if field811 is not None: self.newline() - assert field801 is not None - opt_val802 = field801 - self.pretty_configure(opt_val802) - field803 = unwrapped_fields800[1] - if field803 is not None: + assert field811 is not None + opt_val812 = field811 + self.pretty_configure(opt_val812) + field813 = unwrapped_fields810[1] + if field813 is not None: self.newline() - assert field803 is not None - opt_val804 = field803 - self.pretty_sync(opt_val804) - field805 = unwrapped_fields800[2] - if not len(field805) == 0: + assert field813 is not None + opt_val814 = field813 + self.pretty_sync(opt_val814) + field815 = unwrapped_fields810[2] + if not len(field815) == 0: self.newline() - for i807, elem806 in enumerate(field805): - if (i807 > 0): + for i817, elem816 in enumerate(field815): + if (i817 > 0): self.newline() - self.pretty_epoch(elem806) + self.pretty_epoch(elem816) self.dedent() self.write(")") def pretty_configure(self, msg: transactions_pb2.Configure): - flat811 = self._try_flat(msg, self.pretty_configure) - if flat811 is not None: - assert flat811 is not None - self.write(flat811) + flat821 = self._try_flat(msg, self.pretty_configure) + if flat821 is not None: + assert flat821 is not None + self.write(flat821) return None else: _dollar_dollar = msg - _t1600 = self.deconstruct_configure(_dollar_dollar) - fields809 = _t1600 - assert fields809 is not None - unwrapped_fields810 = fields809 + _t1620 = self.deconstruct_configure(_dollar_dollar) + fields819 = _t1620 + assert fields819 is not None + unwrapped_fields820 = fields819 self.write("(configure") self.indent_sexp() self.newline() - self.pretty_config_dict(unwrapped_fields810) + self.pretty_config_dict(unwrapped_fields820) self.dedent() self.write(")") def pretty_config_dict(self, msg: Sequence[tuple[str, logic_pb2.Value]]): - flat815 = self._try_flat(msg, self.pretty_config_dict) - if flat815 is not None: - assert flat815 is not None - self.write(flat815) + flat825 = self._try_flat(msg, self.pretty_config_dict) + if flat825 is not None: + assert flat825 is not None + self.write(flat825) return None else: - fields812 = msg + fields822 = msg self.write("{") self.indent() - if not len(fields812) == 0: + if not len(fields822) == 0: self.newline() - for i814, elem813 in enumerate(fields812): - if (i814 > 0): + for i824, elem823 in enumerate(fields822): + if (i824 > 0): self.newline() - self.pretty_config_key_value(elem813) + self.pretty_config_key_value(elem823) self.dedent() self.write("}") def pretty_config_key_value(self, msg: tuple[str, logic_pb2.Value]): - flat820 = self._try_flat(msg, self.pretty_config_key_value) - if flat820 is not None: - assert flat820 is not None - self.write(flat820) + flat830 = self._try_flat(msg, self.pretty_config_key_value) + if flat830 is not None: + assert flat830 is not None + self.write(flat830) return None else: _dollar_dollar = msg - fields816 = (_dollar_dollar[0], _dollar_dollar[1],) - assert fields816 is not None - unwrapped_fields817 = fields816 + fields826 = (_dollar_dollar[0], _dollar_dollar[1],) + assert fields826 is not None + unwrapped_fields827 = fields826 self.write(":") - field818 = unwrapped_fields817[0] - self.write(field818) + field828 = unwrapped_fields827[0] + self.write(field828) self.write(" ") - field819 = unwrapped_fields817[1] - self.pretty_raw_value(field819) + field829 = unwrapped_fields827[1] + self.pretty_raw_value(field829) def pretty_raw_value(self, msg: logic_pb2.Value): - flat846 = self._try_flat(msg, self.pretty_raw_value) - if flat846 is not None: - assert flat846 is not None - self.write(flat846) + flat856 = self._try_flat(msg, self.pretty_raw_value) + if flat856 is not None: + assert flat856 is not None + self.write(flat856) return None else: _dollar_dollar = msg if _dollar_dollar.HasField("date_value"): - _t1601 = _dollar_dollar.date_value + _t1621 = _dollar_dollar.date_value else: - _t1601 = None - deconstruct_result844 = _t1601 - if deconstruct_result844 is not None: - assert deconstruct_result844 is not None - unwrapped845 = deconstruct_result844 - self.pretty_raw_date(unwrapped845) + _t1621 = None + deconstruct_result854 = _t1621 + if deconstruct_result854 is not None: + assert deconstruct_result854 is not None + unwrapped855 = deconstruct_result854 + self.pretty_raw_date(unwrapped855) else: _dollar_dollar = msg if _dollar_dollar.HasField("datetime_value"): - _t1602 = _dollar_dollar.datetime_value + _t1622 = _dollar_dollar.datetime_value else: - _t1602 = None - deconstruct_result842 = _t1602 - if deconstruct_result842 is not None: - assert deconstruct_result842 is not None - unwrapped843 = deconstruct_result842 - self.pretty_raw_datetime(unwrapped843) + _t1622 = None + deconstruct_result852 = _t1622 + if deconstruct_result852 is not None: + assert deconstruct_result852 is not None + unwrapped853 = deconstruct_result852 + self.pretty_raw_datetime(unwrapped853) else: _dollar_dollar = msg if _dollar_dollar.HasField("string_value"): - _t1603 = _dollar_dollar.string_value + _t1623 = _dollar_dollar.string_value else: - _t1603 = None - deconstruct_result840 = _t1603 - if deconstruct_result840 is not None: - assert deconstruct_result840 is not None - unwrapped841 = deconstruct_result840 - self.write(self.format_string_value(unwrapped841)) + _t1623 = None + deconstruct_result850 = _t1623 + if deconstruct_result850 is not None: + assert deconstruct_result850 is not None + unwrapped851 = deconstruct_result850 + self.write(self.format_string_value(unwrapped851)) else: _dollar_dollar = msg if _dollar_dollar.HasField("int32_value"): - _t1604 = _dollar_dollar.int32_value + _t1624 = _dollar_dollar.int32_value else: - _t1604 = None - deconstruct_result838 = _t1604 - if deconstruct_result838 is not None: - assert deconstruct_result838 is not None - unwrapped839 = deconstruct_result838 - self.write((str(unwrapped839) + 'i32')) + _t1624 = None + deconstruct_result848 = _t1624 + if deconstruct_result848 is not None: + assert deconstruct_result848 is not None + unwrapped849 = deconstruct_result848 + self.write((str(unwrapped849) + 'i32')) else: _dollar_dollar = msg if _dollar_dollar.HasField("int_value"): - _t1605 = _dollar_dollar.int_value + _t1625 = _dollar_dollar.int_value else: - _t1605 = None - deconstruct_result836 = _t1605 - if deconstruct_result836 is not None: - assert deconstruct_result836 is not None - unwrapped837 = deconstruct_result836 - self.write(str(unwrapped837)) + _t1625 = None + deconstruct_result846 = _t1625 + if deconstruct_result846 is not None: + assert deconstruct_result846 is not None + unwrapped847 = deconstruct_result846 + self.write(str(unwrapped847)) else: _dollar_dollar = msg if _dollar_dollar.HasField("float32_value"): - _t1606 = _dollar_dollar.float32_value + _t1626 = _dollar_dollar.float32_value else: - _t1606 = None - deconstruct_result834 = _t1606 - if deconstruct_result834 is not None: - assert deconstruct_result834 is not None - unwrapped835 = deconstruct_result834 - self.write(self.format_float32_literal(unwrapped835)) + _t1626 = None + deconstruct_result844 = _t1626 + if deconstruct_result844 is not None: + assert deconstruct_result844 is not None + unwrapped845 = deconstruct_result844 + self.write(self.format_float32_literal(unwrapped845)) else: _dollar_dollar = msg if _dollar_dollar.HasField("float_value"): - _t1607 = _dollar_dollar.float_value + _t1627 = _dollar_dollar.float_value else: - _t1607 = None - deconstruct_result832 = _t1607 - if deconstruct_result832 is not None: - assert deconstruct_result832 is not None - unwrapped833 = deconstruct_result832 - self.write(str(unwrapped833)) + _t1627 = None + deconstruct_result842 = _t1627 + if deconstruct_result842 is not None: + assert deconstruct_result842 is not None + unwrapped843 = deconstruct_result842 + self.write(str(unwrapped843)) else: _dollar_dollar = msg if _dollar_dollar.HasField("uint32_value"): - _t1608 = _dollar_dollar.uint32_value + _t1628 = _dollar_dollar.uint32_value else: - _t1608 = None - deconstruct_result830 = _t1608 - if deconstruct_result830 is not None: - assert deconstruct_result830 is not None - unwrapped831 = deconstruct_result830 - self.write((str(unwrapped831) + 'u32')) + _t1628 = None + deconstruct_result840 = _t1628 + if deconstruct_result840 is not None: + assert deconstruct_result840 is not None + unwrapped841 = deconstruct_result840 + self.write((str(unwrapped841) + 'u32')) else: _dollar_dollar = msg if _dollar_dollar.HasField("uint128_value"): - _t1609 = _dollar_dollar.uint128_value + _t1629 = _dollar_dollar.uint128_value else: - _t1609 = None - deconstruct_result828 = _t1609 - if deconstruct_result828 is not None: - assert deconstruct_result828 is not None - unwrapped829 = deconstruct_result828 - self.write(self.format_uint128(unwrapped829)) + _t1629 = None + deconstruct_result838 = _t1629 + if deconstruct_result838 is not None: + assert deconstruct_result838 is not None + unwrapped839 = deconstruct_result838 + self.write(self.format_uint128(unwrapped839)) else: _dollar_dollar = msg if _dollar_dollar.HasField("int128_value"): - _t1610 = _dollar_dollar.int128_value + _t1630 = _dollar_dollar.int128_value else: - _t1610 = None - deconstruct_result826 = _t1610 - if deconstruct_result826 is not None: - assert deconstruct_result826 is not None - unwrapped827 = deconstruct_result826 - self.write(self.format_int128(unwrapped827)) + _t1630 = None + deconstruct_result836 = _t1630 + if deconstruct_result836 is not None: + assert deconstruct_result836 is not None + unwrapped837 = deconstruct_result836 + self.write(self.format_int128(unwrapped837)) else: _dollar_dollar = msg if _dollar_dollar.HasField("decimal_value"): - _t1611 = _dollar_dollar.decimal_value + _t1631 = _dollar_dollar.decimal_value else: - _t1611 = None - deconstruct_result824 = _t1611 - if deconstruct_result824 is not None: - assert deconstruct_result824 is not None - unwrapped825 = deconstruct_result824 - self.write(self.format_decimal(unwrapped825)) + _t1631 = None + deconstruct_result834 = _t1631 + if deconstruct_result834 is not None: + assert deconstruct_result834 is not None + unwrapped835 = deconstruct_result834 + self.write(self.format_decimal(unwrapped835)) else: _dollar_dollar = msg if _dollar_dollar.HasField("boolean_value"): - _t1612 = _dollar_dollar.boolean_value + _t1632 = _dollar_dollar.boolean_value else: - _t1612 = None - deconstruct_result822 = _t1612 - if deconstruct_result822 is not None: - assert deconstruct_result822 is not None - unwrapped823 = deconstruct_result822 - self.pretty_boolean_value(unwrapped823) + _t1632 = None + deconstruct_result832 = _t1632 + if deconstruct_result832 is not None: + assert deconstruct_result832 is not None + unwrapped833 = deconstruct_result832 + self.pretty_boolean_value(unwrapped833) else: - fields821 = msg + fields831 = msg self.write("missing") def pretty_raw_date(self, msg: logic_pb2.DateValue): - flat852 = self._try_flat(msg, self.pretty_raw_date) - if flat852 is not None: - assert flat852 is not None - self.write(flat852) + flat862 = self._try_flat(msg, self.pretty_raw_date) + if flat862 is not None: + assert flat862 is not None + self.write(flat862) return None else: _dollar_dollar = msg - fields847 = (int(_dollar_dollar.year), int(_dollar_dollar.month), int(_dollar_dollar.day),) - assert fields847 is not None - unwrapped_fields848 = fields847 + fields857 = (int(_dollar_dollar.year), int(_dollar_dollar.month), int(_dollar_dollar.day),) + assert fields857 is not None + unwrapped_fields858 = fields857 self.write("(date") self.indent_sexp() self.newline() - field849 = unwrapped_fields848[0] - self.write(str(field849)) + field859 = unwrapped_fields858[0] + self.write(str(field859)) self.newline() - field850 = unwrapped_fields848[1] - self.write(str(field850)) + field860 = unwrapped_fields858[1] + self.write(str(field860)) self.newline() - field851 = unwrapped_fields848[2] - self.write(str(field851)) + field861 = unwrapped_fields858[2] + self.write(str(field861)) self.dedent() self.write(")") def pretty_raw_datetime(self, msg: logic_pb2.DateTimeValue): - flat863 = self._try_flat(msg, self.pretty_raw_datetime) - if flat863 is not None: - assert flat863 is not None - self.write(flat863) + flat873 = self._try_flat(msg, self.pretty_raw_datetime) + if flat873 is not None: + assert flat873 is not None + self.write(flat873) return None else: _dollar_dollar = msg - fields853 = (int(_dollar_dollar.year), int(_dollar_dollar.month), int(_dollar_dollar.day), int(_dollar_dollar.hour), int(_dollar_dollar.minute), int(_dollar_dollar.second), int(_dollar_dollar.microsecond),) - assert fields853 is not None - unwrapped_fields854 = fields853 + fields863 = (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 fields863 is not None + unwrapped_fields864 = fields863 self.write("(datetime") self.indent_sexp() self.newline() - field855 = unwrapped_fields854[0] - self.write(str(field855)) + field865 = unwrapped_fields864[0] + self.write(str(field865)) self.newline() - field856 = unwrapped_fields854[1] - self.write(str(field856)) + field866 = unwrapped_fields864[1] + self.write(str(field866)) self.newline() - field857 = unwrapped_fields854[2] - self.write(str(field857)) + field867 = unwrapped_fields864[2] + self.write(str(field867)) self.newline() - field858 = unwrapped_fields854[3] - self.write(str(field858)) + field868 = unwrapped_fields864[3] + self.write(str(field868)) self.newline() - field859 = unwrapped_fields854[4] - self.write(str(field859)) + field869 = unwrapped_fields864[4] + self.write(str(field869)) self.newline() - field860 = unwrapped_fields854[5] - self.write(str(field860)) - field861 = unwrapped_fields854[6] - if field861 is not None: + field870 = unwrapped_fields864[5] + self.write(str(field870)) + field871 = unwrapped_fields864[6] + if field871 is not None: self.newline() - assert field861 is not None - opt_val862 = field861 - self.write(str(opt_val862)) + assert field871 is not None + opt_val872 = field871 + self.write(str(opt_val872)) self.dedent() self.write(")") def pretty_boolean_value(self, msg: bool): _dollar_dollar = msg if _dollar_dollar: - _t1613 = () + _t1633 = () else: - _t1613 = None - deconstruct_result866 = _t1613 - if deconstruct_result866 is not None: - assert deconstruct_result866 is not None - unwrapped867 = deconstruct_result866 + _t1633 = None + deconstruct_result876 = _t1633 + if deconstruct_result876 is not None: + assert deconstruct_result876 is not None + unwrapped877 = deconstruct_result876 self.write("true") else: _dollar_dollar = msg if not _dollar_dollar: - _t1614 = () + _t1634 = () else: - _t1614 = None - deconstruct_result864 = _t1614 - if deconstruct_result864 is not None: - assert deconstruct_result864 is not None - unwrapped865 = deconstruct_result864 + _t1634 = None + deconstruct_result874 = _t1634 + if deconstruct_result874 is not None: + assert deconstruct_result874 is not None + unwrapped875 = deconstruct_result874 self.write("false") else: raise ParseError("No matching rule for boolean_value") def pretty_sync(self, msg: transactions_pb2.Sync): - flat872 = self._try_flat(msg, self.pretty_sync) - if flat872 is not None: - assert flat872 is not None - self.write(flat872) + flat882 = self._try_flat(msg, self.pretty_sync) + if flat882 is not None: + assert flat882 is not None + self.write(flat882) return None else: _dollar_dollar = msg - fields868 = _dollar_dollar.fragments - assert fields868 is not None - unwrapped_fields869 = fields868 + fields878 = _dollar_dollar.fragments + assert fields878 is not None + unwrapped_fields879 = fields878 self.write("(sync") self.indent_sexp() - if not len(unwrapped_fields869) == 0: + if not len(unwrapped_fields879) == 0: self.newline() - for i871, elem870 in enumerate(unwrapped_fields869): - if (i871 > 0): + for i881, elem880 in enumerate(unwrapped_fields879): + if (i881 > 0): self.newline() - self.pretty_fragment_id(elem870) + self.pretty_fragment_id(elem880) self.dedent() self.write(")") def pretty_fragment_id(self, msg: fragments_pb2.FragmentId): - flat875 = self._try_flat(msg, self.pretty_fragment_id) - if flat875 is not None: - assert flat875 is not None - self.write(flat875) + flat885 = self._try_flat(msg, self.pretty_fragment_id) + if flat885 is not None: + assert flat885 is not None + self.write(flat885) return None else: _dollar_dollar = msg - fields873 = self.fragment_id_to_string(_dollar_dollar) - assert fields873 is not None - unwrapped_fields874 = fields873 + fields883 = self.fragment_id_to_string(_dollar_dollar) + assert fields883 is not None + unwrapped_fields884 = fields883 self.write(":") - self.write(unwrapped_fields874) + self.write(unwrapped_fields884) def pretty_epoch(self, msg: transactions_pb2.Epoch): - flat882 = self._try_flat(msg, self.pretty_epoch) - if flat882 is not None: - assert flat882 is not None - self.write(flat882) + flat892 = self._try_flat(msg, self.pretty_epoch) + if flat892 is not None: + assert flat892 is not None + self.write(flat892) return None else: _dollar_dollar = msg if not len(_dollar_dollar.writes) == 0: - _t1615 = _dollar_dollar.writes + _t1635 = _dollar_dollar.writes else: - _t1615 = None + _t1635 = None if not len(_dollar_dollar.reads) == 0: - _t1616 = _dollar_dollar.reads + _t1636 = _dollar_dollar.reads else: - _t1616 = None - fields876 = (_t1615, _t1616,) - assert fields876 is not None - unwrapped_fields877 = fields876 + _t1636 = None + fields886 = (_t1635, _t1636,) + assert fields886 is not None + unwrapped_fields887 = fields886 self.write("(epoch") self.indent_sexp() - field878 = unwrapped_fields877[0] - if field878 is not None: + field888 = unwrapped_fields887[0] + if field888 is not None: self.newline() - assert field878 is not None - opt_val879 = field878 - self.pretty_epoch_writes(opt_val879) - field880 = unwrapped_fields877[1] - if field880 is not None: + assert field888 is not None + opt_val889 = field888 + self.pretty_epoch_writes(opt_val889) + field890 = unwrapped_fields887[1] + if field890 is not None: self.newline() - assert field880 is not None - opt_val881 = field880 - self.pretty_epoch_reads(opt_val881) + assert field890 is not None + opt_val891 = field890 + self.pretty_epoch_reads(opt_val891) self.dedent() self.write(")") def pretty_epoch_writes(self, msg: Sequence[transactions_pb2.Write]): - flat886 = self._try_flat(msg, self.pretty_epoch_writes) - if flat886 is not None: - assert flat886 is not None - self.write(flat886) + flat896 = self._try_flat(msg, self.pretty_epoch_writes) + if flat896 is not None: + assert flat896 is not None + self.write(flat896) return None else: - fields883 = msg + fields893 = msg self.write("(writes") self.indent_sexp() - if not len(fields883) == 0: + if not len(fields893) == 0: self.newline() - for i885, elem884 in enumerate(fields883): - if (i885 > 0): + for i895, elem894 in enumerate(fields893): + if (i895 > 0): self.newline() - self.pretty_write(elem884) + self.pretty_write(elem894) self.dedent() self.write(")") def pretty_write(self, msg: transactions_pb2.Write): - flat895 = self._try_flat(msg, self.pretty_write) - if flat895 is not None: - assert flat895 is not None - self.write(flat895) + flat905 = self._try_flat(msg, self.pretty_write) + if flat905 is not None: + assert flat905 is not None + self.write(flat905) return None else: _dollar_dollar = msg if _dollar_dollar.HasField("define"): - _t1617 = _dollar_dollar.define + _t1637 = _dollar_dollar.define else: - _t1617 = None - deconstruct_result893 = _t1617 - if deconstruct_result893 is not None: - assert deconstruct_result893 is not None - unwrapped894 = deconstruct_result893 - self.pretty_define(unwrapped894) + _t1637 = None + deconstruct_result903 = _t1637 + if deconstruct_result903 is not None: + assert deconstruct_result903 is not None + unwrapped904 = deconstruct_result903 + self.pretty_define(unwrapped904) else: _dollar_dollar = msg if _dollar_dollar.HasField("undefine"): - _t1618 = _dollar_dollar.undefine + _t1638 = _dollar_dollar.undefine else: - _t1618 = None - deconstruct_result891 = _t1618 - if deconstruct_result891 is not None: - assert deconstruct_result891 is not None - unwrapped892 = deconstruct_result891 - self.pretty_undefine(unwrapped892) + _t1638 = None + deconstruct_result901 = _t1638 + if deconstruct_result901 is not None: + assert deconstruct_result901 is not None + unwrapped902 = deconstruct_result901 + self.pretty_undefine(unwrapped902) else: _dollar_dollar = msg if _dollar_dollar.HasField("context"): - _t1619 = _dollar_dollar.context + _t1639 = _dollar_dollar.context else: - _t1619 = None - deconstruct_result889 = _t1619 - if deconstruct_result889 is not None: - assert deconstruct_result889 is not None - unwrapped890 = deconstruct_result889 - self.pretty_context(unwrapped890) + _t1639 = None + deconstruct_result899 = _t1639 + if deconstruct_result899 is not None: + assert deconstruct_result899 is not None + unwrapped900 = deconstruct_result899 + self.pretty_context(unwrapped900) else: _dollar_dollar = msg if _dollar_dollar.HasField("snapshot"): - _t1620 = _dollar_dollar.snapshot + _t1640 = _dollar_dollar.snapshot else: - _t1620 = None - deconstruct_result887 = _t1620 - if deconstruct_result887 is not None: - assert deconstruct_result887 is not None - unwrapped888 = deconstruct_result887 - self.pretty_snapshot(unwrapped888) + _t1640 = None + deconstruct_result897 = _t1640 + if deconstruct_result897 is not None: + assert deconstruct_result897 is not None + unwrapped898 = deconstruct_result897 + self.pretty_snapshot(unwrapped898) else: raise ParseError("No matching rule for write") def pretty_define(self, msg: transactions_pb2.Define): - flat898 = self._try_flat(msg, self.pretty_define) - if flat898 is not None: - assert flat898 is not None - self.write(flat898) + flat908 = self._try_flat(msg, self.pretty_define) + if flat908 is not None: + assert flat908 is not None + self.write(flat908) return None else: _dollar_dollar = msg - fields896 = _dollar_dollar.fragment - assert fields896 is not None - unwrapped_fields897 = fields896 + fields906 = _dollar_dollar.fragment + assert fields906 is not None + unwrapped_fields907 = fields906 self.write("(define") self.indent_sexp() self.newline() - self.pretty_fragment(unwrapped_fields897) + self.pretty_fragment(unwrapped_fields907) self.dedent() self.write(")") def pretty_fragment(self, msg: fragments_pb2.Fragment): - flat905 = self._try_flat(msg, self.pretty_fragment) - if flat905 is not None: - assert flat905 is not None - self.write(flat905) + flat915 = self._try_flat(msg, self.pretty_fragment) + if flat915 is not None: + assert flat915 is not None + self.write(flat915) return None else: _dollar_dollar = msg self.start_pretty_fragment(_dollar_dollar) - fields899 = (_dollar_dollar.id, _dollar_dollar.declarations,) - assert fields899 is not None - unwrapped_fields900 = fields899 + fields909 = (_dollar_dollar.id, _dollar_dollar.declarations,) + assert fields909 is not None + unwrapped_fields910 = fields909 self.write("(fragment") self.indent_sexp() self.newline() - field901 = unwrapped_fields900[0] - self.pretty_new_fragment_id(field901) - field902 = unwrapped_fields900[1] - if not len(field902) == 0: + field911 = unwrapped_fields910[0] + self.pretty_new_fragment_id(field911) + field912 = unwrapped_fields910[1] + if not len(field912) == 0: self.newline() - for i904, elem903 in enumerate(field902): - if (i904 > 0): + for i914, elem913 in enumerate(field912): + if (i914 > 0): self.newline() - self.pretty_declaration(elem903) + self.pretty_declaration(elem913) self.dedent() self.write(")") def pretty_new_fragment_id(self, msg: fragments_pb2.FragmentId): - flat907 = self._try_flat(msg, self.pretty_new_fragment_id) - if flat907 is not None: - assert flat907 is not None - self.write(flat907) + flat917 = self._try_flat(msg, self.pretty_new_fragment_id) + if flat917 is not None: + assert flat917 is not None + self.write(flat917) return None else: - fields906 = msg - self.pretty_fragment_id(fields906) + fields916 = msg + self.pretty_fragment_id(fields916) def pretty_declaration(self, msg: logic_pb2.Declaration): - flat916 = self._try_flat(msg, self.pretty_declaration) - if flat916 is not None: - assert flat916 is not None - self.write(flat916) + flat926 = self._try_flat(msg, self.pretty_declaration) + if flat926 is not None: + assert flat926 is not None + self.write(flat926) return None else: _dollar_dollar = msg if _dollar_dollar.HasField("def"): - _t1621 = getattr(_dollar_dollar, 'def') + _t1641 = getattr(_dollar_dollar, 'def') else: - _t1621 = None - deconstruct_result914 = _t1621 - if deconstruct_result914 is not None: - assert deconstruct_result914 is not None - unwrapped915 = deconstruct_result914 - self.pretty_def(unwrapped915) + _t1641 = None + deconstruct_result924 = _t1641 + if deconstruct_result924 is not None: + assert deconstruct_result924 is not None + unwrapped925 = deconstruct_result924 + self.pretty_def(unwrapped925) else: _dollar_dollar = msg if _dollar_dollar.HasField("algorithm"): - _t1622 = _dollar_dollar.algorithm + _t1642 = _dollar_dollar.algorithm else: - _t1622 = None - deconstruct_result912 = _t1622 - if deconstruct_result912 is not None: - assert deconstruct_result912 is not None - unwrapped913 = deconstruct_result912 - self.pretty_algorithm(unwrapped913) + _t1642 = None + deconstruct_result922 = _t1642 + if deconstruct_result922 is not None: + assert deconstruct_result922 is not None + unwrapped923 = deconstruct_result922 + self.pretty_algorithm(unwrapped923) else: _dollar_dollar = msg if _dollar_dollar.HasField("constraint"): - _t1623 = _dollar_dollar.constraint + _t1643 = _dollar_dollar.constraint else: - _t1623 = None - deconstruct_result910 = _t1623 - if deconstruct_result910 is not None: - assert deconstruct_result910 is not None - unwrapped911 = deconstruct_result910 - self.pretty_constraint(unwrapped911) + _t1643 = None + deconstruct_result920 = _t1643 + if deconstruct_result920 is not None: + assert deconstruct_result920 is not None + unwrapped921 = deconstruct_result920 + self.pretty_constraint(unwrapped921) else: _dollar_dollar = msg if _dollar_dollar.HasField("data"): - _t1624 = _dollar_dollar.data + _t1644 = _dollar_dollar.data else: - _t1624 = None - deconstruct_result908 = _t1624 - if deconstruct_result908 is not None: - assert deconstruct_result908 is not None - unwrapped909 = deconstruct_result908 - self.pretty_data(unwrapped909) + _t1644 = None + deconstruct_result918 = _t1644 + if deconstruct_result918 is not None: + assert deconstruct_result918 is not None + unwrapped919 = deconstruct_result918 + self.pretty_data(unwrapped919) else: raise ParseError("No matching rule for declaration") def pretty_def(self, msg: logic_pb2.Def): - flat923 = self._try_flat(msg, self.pretty_def) - if flat923 is not None: - assert flat923 is not None - self.write(flat923) + flat933 = self._try_flat(msg, self.pretty_def) + if flat933 is not None: + assert flat933 is not None + self.write(flat933) return None else: _dollar_dollar = msg if not len(_dollar_dollar.attrs) == 0: - _t1625 = _dollar_dollar.attrs + _t1645 = _dollar_dollar.attrs else: - _t1625 = None - fields917 = (_dollar_dollar.name, _dollar_dollar.body, _t1625,) - assert fields917 is not None - unwrapped_fields918 = fields917 + _t1645 = None + fields927 = (_dollar_dollar.name, _dollar_dollar.body, _t1645,) + assert fields927 is not None + unwrapped_fields928 = fields927 self.write("(def") self.indent_sexp() self.newline() - field919 = unwrapped_fields918[0] - self.pretty_relation_id(field919) + field929 = unwrapped_fields928[0] + self.pretty_relation_id(field929) self.newline() - field920 = unwrapped_fields918[1] - self.pretty_abstraction(field920) - field921 = unwrapped_fields918[2] - if field921 is not None: + field930 = unwrapped_fields928[1] + self.pretty_abstraction(field930) + field931 = unwrapped_fields928[2] + if field931 is not None: self.newline() - assert field921 is not None - opt_val922 = field921 - self.pretty_attrs(opt_val922) + assert field931 is not None + opt_val932 = field931 + self.pretty_attrs(opt_val932) self.dedent() self.write(")") def pretty_relation_id(self, msg: logic_pb2.RelationId): - flat928 = self._try_flat(msg, self.pretty_relation_id) - if flat928 is not None: - assert flat928 is not None - self.write(flat928) + flat938 = self._try_flat(msg, self.pretty_relation_id) + if flat938 is not None: + assert flat938 is not None + self.write(flat938) return None else: _dollar_dollar = msg if self.relation_id_to_string(_dollar_dollar) is not None: - _t1627 = self.deconstruct_relation_id_string(_dollar_dollar) - _t1626 = _t1627 + _t1647 = self.deconstruct_relation_id_string(_dollar_dollar) + _t1646 = _t1647 else: - _t1626 = None - deconstruct_result926 = _t1626 - if deconstruct_result926 is not None: - assert deconstruct_result926 is not None - unwrapped927 = deconstruct_result926 + _t1646 = None + deconstruct_result936 = _t1646 + if deconstruct_result936 is not None: + assert deconstruct_result936 is not None + unwrapped937 = deconstruct_result936 self.write(":") - self.write(unwrapped927) + self.write(unwrapped937) else: _dollar_dollar = msg - _t1628 = self.deconstruct_relation_id_uint128(_dollar_dollar) - deconstruct_result924 = _t1628 - if deconstruct_result924 is not None: - assert deconstruct_result924 is not None - unwrapped925 = deconstruct_result924 - self.write(self.format_uint128(unwrapped925)) + _t1648 = self.deconstruct_relation_id_uint128(_dollar_dollar) + deconstruct_result934 = _t1648 + if deconstruct_result934 is not None: + assert deconstruct_result934 is not None + unwrapped935 = deconstruct_result934 + self.write(self.format_uint128(unwrapped935)) else: raise ParseError("No matching rule for relation_id") def pretty_abstraction(self, msg: logic_pb2.Abstraction): - flat933 = self._try_flat(msg, self.pretty_abstraction) - if flat933 is not None: - assert flat933 is not None - self.write(flat933) + flat943 = self._try_flat(msg, self.pretty_abstraction) + if flat943 is not None: + assert flat943 is not None + self.write(flat943) return None else: _dollar_dollar = msg - _t1629 = self.deconstruct_bindings(_dollar_dollar) - fields929 = (_t1629, _dollar_dollar.value,) - assert fields929 is not None - unwrapped_fields930 = fields929 + _t1649 = self.deconstruct_bindings(_dollar_dollar) + fields939 = (_t1649, _dollar_dollar.value,) + assert fields939 is not None + unwrapped_fields940 = fields939 self.write("(") self.indent() - field931 = unwrapped_fields930[0] - self.pretty_bindings(field931) + field941 = unwrapped_fields940[0] + self.pretty_bindings(field941) self.newline() - field932 = unwrapped_fields930[1] - self.pretty_formula(field932) + field942 = unwrapped_fields940[1] + self.pretty_formula(field942) self.dedent() self.write(")") def pretty_bindings(self, msg: tuple[Sequence[logic_pb2.Binding], Sequence[logic_pb2.Binding]]): - flat941 = self._try_flat(msg, self.pretty_bindings) - if flat941 is not None: - assert flat941 is not None - self.write(flat941) + flat951 = self._try_flat(msg, self.pretty_bindings) + if flat951 is not None: + assert flat951 is not None + self.write(flat951) return None else: _dollar_dollar = msg if not len(_dollar_dollar[1]) == 0: - _t1630 = _dollar_dollar[1] + _t1650 = _dollar_dollar[1] else: - _t1630 = None - fields934 = (_dollar_dollar[0], _t1630,) - assert fields934 is not None - unwrapped_fields935 = fields934 + _t1650 = None + fields944 = (_dollar_dollar[0], _t1650,) + assert fields944 is not None + unwrapped_fields945 = fields944 self.write("[") self.indent() - field936 = unwrapped_fields935[0] - for i938, elem937 in enumerate(field936): - if (i938 > 0): + field946 = unwrapped_fields945[0] + for i948, elem947 in enumerate(field946): + if (i948 > 0): self.newline() - self.pretty_binding(elem937) - field939 = unwrapped_fields935[1] - if field939 is not None: + self.pretty_binding(elem947) + field949 = unwrapped_fields945[1] + if field949 is not None: self.newline() - assert field939 is not None - opt_val940 = field939 - self.pretty_value_bindings(opt_val940) + assert field949 is not None + opt_val950 = field949 + self.pretty_value_bindings(opt_val950) self.dedent() self.write("]") def pretty_binding(self, msg: logic_pb2.Binding): - flat946 = self._try_flat(msg, self.pretty_binding) - if flat946 is not None: - assert flat946 is not None - self.write(flat946) + flat956 = self._try_flat(msg, self.pretty_binding) + if flat956 is not None: + assert flat956 is not None + self.write(flat956) return None else: _dollar_dollar = msg - fields942 = (_dollar_dollar.var.name, _dollar_dollar.type,) - assert fields942 is not None - unwrapped_fields943 = fields942 - field944 = unwrapped_fields943[0] - self.write(field944) + fields952 = (_dollar_dollar.var.name, _dollar_dollar.type,) + assert fields952 is not None + unwrapped_fields953 = fields952 + field954 = unwrapped_fields953[0] + self.write(field954) self.write("::") - field945 = unwrapped_fields943[1] - self.pretty_type(field945) + field955 = unwrapped_fields953[1] + self.pretty_type(field955) def pretty_type(self, msg: logic_pb2.Type): - flat975 = self._try_flat(msg, self.pretty_type) - if flat975 is not None: - assert flat975 is not None - self.write(flat975) + flat985 = self._try_flat(msg, self.pretty_type) + if flat985 is not None: + assert flat985 is not None + self.write(flat985) return None else: _dollar_dollar = msg if _dollar_dollar.HasField("unspecified_type"): - _t1631 = _dollar_dollar.unspecified_type + _t1651 = _dollar_dollar.unspecified_type else: - _t1631 = None - deconstruct_result973 = _t1631 - if deconstruct_result973 is not None: - assert deconstruct_result973 is not None - unwrapped974 = deconstruct_result973 - self.pretty_unspecified_type(unwrapped974) + _t1651 = None + deconstruct_result983 = _t1651 + if deconstruct_result983 is not None: + assert deconstruct_result983 is not None + unwrapped984 = deconstruct_result983 + self.pretty_unspecified_type(unwrapped984) else: _dollar_dollar = msg if _dollar_dollar.HasField("string_type"): - _t1632 = _dollar_dollar.string_type + _t1652 = _dollar_dollar.string_type else: - _t1632 = None - deconstruct_result971 = _t1632 - if deconstruct_result971 is not None: - assert deconstruct_result971 is not None - unwrapped972 = deconstruct_result971 - self.pretty_string_type(unwrapped972) + _t1652 = None + deconstruct_result981 = _t1652 + if deconstruct_result981 is not None: + assert deconstruct_result981 is not None + unwrapped982 = deconstruct_result981 + self.pretty_string_type(unwrapped982) else: _dollar_dollar = msg if _dollar_dollar.HasField("int_type"): - _t1633 = _dollar_dollar.int_type + _t1653 = _dollar_dollar.int_type else: - _t1633 = None - deconstruct_result969 = _t1633 - if deconstruct_result969 is not None: - assert deconstruct_result969 is not None - unwrapped970 = deconstruct_result969 - self.pretty_int_type(unwrapped970) + _t1653 = None + deconstruct_result979 = _t1653 + if deconstruct_result979 is not None: + assert deconstruct_result979 is not None + unwrapped980 = deconstruct_result979 + self.pretty_int_type(unwrapped980) else: _dollar_dollar = msg if _dollar_dollar.HasField("float_type"): - _t1634 = _dollar_dollar.float_type + _t1654 = _dollar_dollar.float_type else: - _t1634 = None - deconstruct_result967 = _t1634 - if deconstruct_result967 is not None: - assert deconstruct_result967 is not None - unwrapped968 = deconstruct_result967 - self.pretty_float_type(unwrapped968) + _t1654 = None + deconstruct_result977 = _t1654 + if deconstruct_result977 is not None: + assert deconstruct_result977 is not None + unwrapped978 = deconstruct_result977 + self.pretty_float_type(unwrapped978) else: _dollar_dollar = msg if _dollar_dollar.HasField("uint128_type"): - _t1635 = _dollar_dollar.uint128_type + _t1655 = _dollar_dollar.uint128_type else: - _t1635 = None - deconstruct_result965 = _t1635 - if deconstruct_result965 is not None: - assert deconstruct_result965 is not None - unwrapped966 = deconstruct_result965 - self.pretty_uint128_type(unwrapped966) + _t1655 = None + deconstruct_result975 = _t1655 + if deconstruct_result975 is not None: + assert deconstruct_result975 is not None + unwrapped976 = deconstruct_result975 + self.pretty_uint128_type(unwrapped976) else: _dollar_dollar = msg if _dollar_dollar.HasField("int128_type"): - _t1636 = _dollar_dollar.int128_type + _t1656 = _dollar_dollar.int128_type else: - _t1636 = None - deconstruct_result963 = _t1636 - if deconstruct_result963 is not None: - assert deconstruct_result963 is not None - unwrapped964 = deconstruct_result963 - self.pretty_int128_type(unwrapped964) + _t1656 = None + deconstruct_result973 = _t1656 + if deconstruct_result973 is not None: + assert deconstruct_result973 is not None + unwrapped974 = deconstruct_result973 + self.pretty_int128_type(unwrapped974) else: _dollar_dollar = msg if _dollar_dollar.HasField("date_type"): - _t1637 = _dollar_dollar.date_type + _t1657 = _dollar_dollar.date_type else: - _t1637 = None - deconstruct_result961 = _t1637 - if deconstruct_result961 is not None: - assert deconstruct_result961 is not None - unwrapped962 = deconstruct_result961 - self.pretty_date_type(unwrapped962) + _t1657 = None + deconstruct_result971 = _t1657 + if deconstruct_result971 is not None: + assert deconstruct_result971 is not None + unwrapped972 = deconstruct_result971 + self.pretty_date_type(unwrapped972) else: _dollar_dollar = msg if _dollar_dollar.HasField("datetime_type"): - _t1638 = _dollar_dollar.datetime_type + _t1658 = _dollar_dollar.datetime_type else: - _t1638 = None - deconstruct_result959 = _t1638 - if deconstruct_result959 is not None: - assert deconstruct_result959 is not None - unwrapped960 = deconstruct_result959 - self.pretty_datetime_type(unwrapped960) + _t1658 = None + deconstruct_result969 = _t1658 + if deconstruct_result969 is not None: + assert deconstruct_result969 is not None + unwrapped970 = deconstruct_result969 + self.pretty_datetime_type(unwrapped970) else: _dollar_dollar = msg if _dollar_dollar.HasField("missing_type"): - _t1639 = _dollar_dollar.missing_type + _t1659 = _dollar_dollar.missing_type else: - _t1639 = None - deconstruct_result957 = _t1639 - if deconstruct_result957 is not None: - assert deconstruct_result957 is not None - unwrapped958 = deconstruct_result957 - self.pretty_missing_type(unwrapped958) + _t1659 = None + deconstruct_result967 = _t1659 + if deconstruct_result967 is not None: + assert deconstruct_result967 is not None + unwrapped968 = deconstruct_result967 + self.pretty_missing_type(unwrapped968) else: _dollar_dollar = msg if _dollar_dollar.HasField("decimal_type"): - _t1640 = _dollar_dollar.decimal_type + _t1660 = _dollar_dollar.decimal_type else: - _t1640 = None - deconstruct_result955 = _t1640 - if deconstruct_result955 is not None: - assert deconstruct_result955 is not None - unwrapped956 = deconstruct_result955 - self.pretty_decimal_type(unwrapped956) + _t1660 = None + deconstruct_result965 = _t1660 + if deconstruct_result965 is not None: + assert deconstruct_result965 is not None + unwrapped966 = deconstruct_result965 + self.pretty_decimal_type(unwrapped966) else: _dollar_dollar = msg if _dollar_dollar.HasField("boolean_type"): - _t1641 = _dollar_dollar.boolean_type + _t1661 = _dollar_dollar.boolean_type else: - _t1641 = None - deconstruct_result953 = _t1641 - if deconstruct_result953 is not None: - assert deconstruct_result953 is not None - unwrapped954 = deconstruct_result953 - self.pretty_boolean_type(unwrapped954) + _t1661 = None + deconstruct_result963 = _t1661 + if deconstruct_result963 is not None: + assert deconstruct_result963 is not None + unwrapped964 = deconstruct_result963 + self.pretty_boolean_type(unwrapped964) else: _dollar_dollar = msg if _dollar_dollar.HasField("int32_type"): - _t1642 = _dollar_dollar.int32_type + _t1662 = _dollar_dollar.int32_type else: - _t1642 = None - deconstruct_result951 = _t1642 - if deconstruct_result951 is not None: - assert deconstruct_result951 is not None - unwrapped952 = deconstruct_result951 - self.pretty_int32_type(unwrapped952) + _t1662 = None + deconstruct_result961 = _t1662 + if deconstruct_result961 is not None: + assert deconstruct_result961 is not None + unwrapped962 = deconstruct_result961 + self.pretty_int32_type(unwrapped962) else: _dollar_dollar = msg if _dollar_dollar.HasField("float32_type"): - _t1643 = _dollar_dollar.float32_type + _t1663 = _dollar_dollar.float32_type else: - _t1643 = None - deconstruct_result949 = _t1643 - if deconstruct_result949 is not None: - assert deconstruct_result949 is not None - unwrapped950 = deconstruct_result949 - self.pretty_float32_type(unwrapped950) + _t1663 = None + deconstruct_result959 = _t1663 + if deconstruct_result959 is not None: + assert deconstruct_result959 is not None + unwrapped960 = deconstruct_result959 + self.pretty_float32_type(unwrapped960) else: _dollar_dollar = msg if _dollar_dollar.HasField("uint32_type"): - _t1644 = _dollar_dollar.uint32_type + _t1664 = _dollar_dollar.uint32_type else: - _t1644 = None - deconstruct_result947 = _t1644 - if deconstruct_result947 is not None: - assert deconstruct_result947 is not None - unwrapped948 = deconstruct_result947 - self.pretty_uint32_type(unwrapped948) + _t1664 = None + deconstruct_result957 = _t1664 + if deconstruct_result957 is not None: + assert deconstruct_result957 is not None + unwrapped958 = deconstruct_result957 + self.pretty_uint32_type(unwrapped958) else: raise ParseError("No matching rule for type") def pretty_unspecified_type(self, msg: logic_pb2.UnspecifiedType): - fields976 = msg + fields986 = msg self.write("UNKNOWN") def pretty_string_type(self, msg: logic_pb2.StringType): - fields977 = msg + fields987 = msg self.write("STRING") def pretty_int_type(self, msg: logic_pb2.IntType): - fields978 = msg + fields988 = msg self.write("INT") def pretty_float_type(self, msg: logic_pb2.FloatType): - fields979 = msg + fields989 = msg self.write("FLOAT") def pretty_uint128_type(self, msg: logic_pb2.UInt128Type): - fields980 = msg + fields990 = msg self.write("UINT128") def pretty_int128_type(self, msg: logic_pb2.Int128Type): - fields981 = msg + fields991 = msg self.write("INT128") def pretty_date_type(self, msg: logic_pb2.DateType): - fields982 = msg + fields992 = msg self.write("DATE") def pretty_datetime_type(self, msg: logic_pb2.DateTimeType): - fields983 = msg + fields993 = msg self.write("DATETIME") def pretty_missing_type(self, msg: logic_pb2.MissingType): - fields984 = msg + fields994 = msg self.write("MISSING") def pretty_decimal_type(self, msg: logic_pb2.DecimalType): - flat989 = self._try_flat(msg, self.pretty_decimal_type) - if flat989 is not None: - assert flat989 is not None - self.write(flat989) + flat999 = self._try_flat(msg, self.pretty_decimal_type) + if flat999 is not None: + assert flat999 is not None + self.write(flat999) return None else: _dollar_dollar = msg - fields985 = (int(_dollar_dollar.precision), int(_dollar_dollar.scale),) - assert fields985 is not None - unwrapped_fields986 = fields985 + fields995 = (int(_dollar_dollar.precision), int(_dollar_dollar.scale),) + assert fields995 is not None + unwrapped_fields996 = fields995 self.write("(DECIMAL") self.indent_sexp() self.newline() - field987 = unwrapped_fields986[0] - self.write(str(field987)) + field997 = unwrapped_fields996[0] + self.write(str(field997)) self.newline() - field988 = unwrapped_fields986[1] - self.write(str(field988)) + field998 = unwrapped_fields996[1] + self.write(str(field998)) self.dedent() self.write(")") def pretty_boolean_type(self, msg: logic_pb2.BooleanType): - fields990 = msg + fields1000 = msg self.write("BOOLEAN") def pretty_int32_type(self, msg: logic_pb2.Int32Type): - fields991 = msg + fields1001 = msg self.write("INT32") def pretty_float32_type(self, msg: logic_pb2.Float32Type): - fields992 = msg + fields1002 = msg self.write("FLOAT32") def pretty_uint32_type(self, msg: logic_pb2.UInt32Type): - fields993 = msg + fields1003 = msg self.write("UINT32") def pretty_value_bindings(self, msg: Sequence[logic_pb2.Binding]): - flat997 = self._try_flat(msg, self.pretty_value_bindings) - if flat997 is not None: - assert flat997 is not None - self.write(flat997) + flat1007 = self._try_flat(msg, self.pretty_value_bindings) + if flat1007 is not None: + assert flat1007 is not None + self.write(flat1007) return None else: - fields994 = msg + fields1004 = msg self.write("|") - if not len(fields994) == 0: + if not len(fields1004) == 0: self.write(" ") - for i996, elem995 in enumerate(fields994): - if (i996 > 0): + for i1006, elem1005 in enumerate(fields1004): + if (i1006 > 0): self.newline() - self.pretty_binding(elem995) + self.pretty_binding(elem1005) def pretty_formula(self, msg: logic_pb2.Formula): - flat1024 = self._try_flat(msg, self.pretty_formula) - if flat1024 is not None: - assert flat1024 is not None - self.write(flat1024) + flat1034 = self._try_flat(msg, self.pretty_formula) + if flat1034 is not None: + assert flat1034 is not None + self.write(flat1034) return None else: _dollar_dollar = msg if (_dollar_dollar.HasField("conjunction") and len(_dollar_dollar.conjunction.args) == 0): - _t1645 = _dollar_dollar.conjunction + _t1665 = _dollar_dollar.conjunction else: - _t1645 = None - deconstruct_result1022 = _t1645 - if deconstruct_result1022 is not None: - assert deconstruct_result1022 is not None - unwrapped1023 = deconstruct_result1022 - self.pretty_true(unwrapped1023) + _t1665 = None + deconstruct_result1032 = _t1665 + if deconstruct_result1032 is not None: + assert deconstruct_result1032 is not None + unwrapped1033 = deconstruct_result1032 + self.pretty_true(unwrapped1033) else: _dollar_dollar = msg if (_dollar_dollar.HasField("disjunction") and len(_dollar_dollar.disjunction.args) == 0): - _t1646 = _dollar_dollar.disjunction + _t1666 = _dollar_dollar.disjunction else: - _t1646 = None - deconstruct_result1020 = _t1646 - if deconstruct_result1020 is not None: - assert deconstruct_result1020 is not None - unwrapped1021 = deconstruct_result1020 - self.pretty_false(unwrapped1021) + _t1666 = None + deconstruct_result1030 = _t1666 + if deconstruct_result1030 is not None: + assert deconstruct_result1030 is not None + unwrapped1031 = deconstruct_result1030 + self.pretty_false(unwrapped1031) else: _dollar_dollar = msg if _dollar_dollar.HasField("exists"): - _t1647 = _dollar_dollar.exists + _t1667 = _dollar_dollar.exists else: - _t1647 = None - deconstruct_result1018 = _t1647 - if deconstruct_result1018 is not None: - assert deconstruct_result1018 is not None - unwrapped1019 = deconstruct_result1018 - self.pretty_exists(unwrapped1019) + _t1667 = None + deconstruct_result1028 = _t1667 + if deconstruct_result1028 is not None: + assert deconstruct_result1028 is not None + unwrapped1029 = deconstruct_result1028 + self.pretty_exists(unwrapped1029) else: _dollar_dollar = msg if _dollar_dollar.HasField("reduce"): - _t1648 = _dollar_dollar.reduce + _t1668 = _dollar_dollar.reduce else: - _t1648 = None - deconstruct_result1016 = _t1648 - if deconstruct_result1016 is not None: - assert deconstruct_result1016 is not None - unwrapped1017 = deconstruct_result1016 - self.pretty_reduce(unwrapped1017) + _t1668 = None + deconstruct_result1026 = _t1668 + if deconstruct_result1026 is not None: + assert deconstruct_result1026 is not None + unwrapped1027 = deconstruct_result1026 + self.pretty_reduce(unwrapped1027) else: _dollar_dollar = msg if (_dollar_dollar.HasField("conjunction") and not len(_dollar_dollar.conjunction.args) == 0): - _t1649 = _dollar_dollar.conjunction + _t1669 = _dollar_dollar.conjunction else: - _t1649 = None - deconstruct_result1014 = _t1649 - if deconstruct_result1014 is not None: - assert deconstruct_result1014 is not None - unwrapped1015 = deconstruct_result1014 - self.pretty_conjunction(unwrapped1015) + _t1669 = None + deconstruct_result1024 = _t1669 + if deconstruct_result1024 is not None: + assert deconstruct_result1024 is not None + unwrapped1025 = deconstruct_result1024 + self.pretty_conjunction(unwrapped1025) else: _dollar_dollar = msg if (_dollar_dollar.HasField("disjunction") and not len(_dollar_dollar.disjunction.args) == 0): - _t1650 = _dollar_dollar.disjunction + _t1670 = _dollar_dollar.disjunction else: - _t1650 = None - deconstruct_result1012 = _t1650 - if deconstruct_result1012 is not None: - assert deconstruct_result1012 is not None - unwrapped1013 = deconstruct_result1012 - self.pretty_disjunction(unwrapped1013) + _t1670 = None + deconstruct_result1022 = _t1670 + if deconstruct_result1022 is not None: + assert deconstruct_result1022 is not None + unwrapped1023 = deconstruct_result1022 + self.pretty_disjunction(unwrapped1023) else: _dollar_dollar = msg if _dollar_dollar.HasField("not"): - _t1651 = getattr(_dollar_dollar, 'not') + _t1671 = getattr(_dollar_dollar, 'not') else: - _t1651 = None - deconstruct_result1010 = _t1651 - if deconstruct_result1010 is not None: - assert deconstruct_result1010 is not None - unwrapped1011 = deconstruct_result1010 - self.pretty_not(unwrapped1011) + _t1671 = None + deconstruct_result1020 = _t1671 + if deconstruct_result1020 is not None: + assert deconstruct_result1020 is not None + unwrapped1021 = deconstruct_result1020 + self.pretty_not(unwrapped1021) else: _dollar_dollar = msg if _dollar_dollar.HasField("ffi"): - _t1652 = _dollar_dollar.ffi + _t1672 = _dollar_dollar.ffi else: - _t1652 = None - deconstruct_result1008 = _t1652 - if deconstruct_result1008 is not None: - assert deconstruct_result1008 is not None - unwrapped1009 = deconstruct_result1008 - self.pretty_ffi(unwrapped1009) + _t1672 = None + deconstruct_result1018 = _t1672 + if deconstruct_result1018 is not None: + assert deconstruct_result1018 is not None + unwrapped1019 = deconstruct_result1018 + self.pretty_ffi(unwrapped1019) else: _dollar_dollar = msg if _dollar_dollar.HasField("atom"): - _t1653 = _dollar_dollar.atom + _t1673 = _dollar_dollar.atom else: - _t1653 = None - deconstruct_result1006 = _t1653 - if deconstruct_result1006 is not None: - assert deconstruct_result1006 is not None - unwrapped1007 = deconstruct_result1006 - self.pretty_atom(unwrapped1007) + _t1673 = None + deconstruct_result1016 = _t1673 + if deconstruct_result1016 is not None: + assert deconstruct_result1016 is not None + unwrapped1017 = deconstruct_result1016 + self.pretty_atom(unwrapped1017) else: _dollar_dollar = msg if _dollar_dollar.HasField("pragma"): - _t1654 = _dollar_dollar.pragma + _t1674 = _dollar_dollar.pragma else: - _t1654 = None - deconstruct_result1004 = _t1654 - if deconstruct_result1004 is not None: - assert deconstruct_result1004 is not None - unwrapped1005 = deconstruct_result1004 - self.pretty_pragma(unwrapped1005) + _t1674 = None + deconstruct_result1014 = _t1674 + if deconstruct_result1014 is not None: + assert deconstruct_result1014 is not None + unwrapped1015 = deconstruct_result1014 + self.pretty_pragma(unwrapped1015) else: _dollar_dollar = msg if _dollar_dollar.HasField("primitive"): - _t1655 = _dollar_dollar.primitive + _t1675 = _dollar_dollar.primitive else: - _t1655 = None - deconstruct_result1002 = _t1655 - if deconstruct_result1002 is not None: - assert deconstruct_result1002 is not None - unwrapped1003 = deconstruct_result1002 - self.pretty_primitive(unwrapped1003) + _t1675 = None + deconstruct_result1012 = _t1675 + if deconstruct_result1012 is not None: + assert deconstruct_result1012 is not None + unwrapped1013 = deconstruct_result1012 + self.pretty_primitive(unwrapped1013) else: _dollar_dollar = msg if _dollar_dollar.HasField("rel_atom"): - _t1656 = _dollar_dollar.rel_atom + _t1676 = _dollar_dollar.rel_atom else: - _t1656 = None - deconstruct_result1000 = _t1656 - if deconstruct_result1000 is not None: - assert deconstruct_result1000 is not None - unwrapped1001 = deconstruct_result1000 - self.pretty_rel_atom(unwrapped1001) + _t1676 = None + deconstruct_result1010 = _t1676 + if deconstruct_result1010 is not None: + assert deconstruct_result1010 is not None + unwrapped1011 = deconstruct_result1010 + self.pretty_rel_atom(unwrapped1011) else: _dollar_dollar = msg if _dollar_dollar.HasField("cast"): - _t1657 = _dollar_dollar.cast + _t1677 = _dollar_dollar.cast else: - _t1657 = None - deconstruct_result998 = _t1657 - if deconstruct_result998 is not None: - assert deconstruct_result998 is not None - unwrapped999 = deconstruct_result998 - self.pretty_cast(unwrapped999) + _t1677 = None + deconstruct_result1008 = _t1677 + if deconstruct_result1008 is not None: + assert deconstruct_result1008 is not None + unwrapped1009 = deconstruct_result1008 + self.pretty_cast(unwrapped1009) else: raise ParseError("No matching rule for formula") def pretty_true(self, msg: logic_pb2.Conjunction): - fields1025 = msg + fields1035 = msg self.write("(true)") def pretty_false(self, msg: logic_pb2.Disjunction): - fields1026 = msg + fields1036 = msg self.write("(false)") def pretty_exists(self, msg: logic_pb2.Exists): - flat1031 = self._try_flat(msg, self.pretty_exists) - if flat1031 is not None: - assert flat1031 is not None - self.write(flat1031) + flat1041 = self._try_flat(msg, self.pretty_exists) + if flat1041 is not None: + assert flat1041 is not None + self.write(flat1041) return None else: _dollar_dollar = msg - _t1658 = self.deconstruct_bindings(_dollar_dollar.body) - fields1027 = (_t1658, _dollar_dollar.body.value,) - assert fields1027 is not None - unwrapped_fields1028 = fields1027 + _t1678 = self.deconstruct_bindings(_dollar_dollar.body) + fields1037 = (_t1678, _dollar_dollar.body.value,) + assert fields1037 is not None + unwrapped_fields1038 = fields1037 self.write("(exists") self.indent_sexp() self.newline() - field1029 = unwrapped_fields1028[0] - self.pretty_bindings(field1029) + field1039 = unwrapped_fields1038[0] + self.pretty_bindings(field1039) self.newline() - field1030 = unwrapped_fields1028[1] - self.pretty_formula(field1030) + field1040 = unwrapped_fields1038[1] + self.pretty_formula(field1040) self.dedent() self.write(")") def pretty_reduce(self, msg: logic_pb2.Reduce): - flat1037 = self._try_flat(msg, self.pretty_reduce) - if flat1037 is not None: - assert flat1037 is not None - self.write(flat1037) + flat1047 = self._try_flat(msg, self.pretty_reduce) + if flat1047 is not None: + assert flat1047 is not None + self.write(flat1047) return None else: _dollar_dollar = msg - fields1032 = (_dollar_dollar.op, _dollar_dollar.body, _dollar_dollar.terms,) - assert fields1032 is not None - unwrapped_fields1033 = fields1032 + fields1042 = (_dollar_dollar.op, _dollar_dollar.body, _dollar_dollar.terms,) + assert fields1042 is not None + unwrapped_fields1043 = fields1042 self.write("(reduce") self.indent_sexp() self.newline() - field1034 = unwrapped_fields1033[0] - self.pretty_abstraction(field1034) + field1044 = unwrapped_fields1043[0] + self.pretty_abstraction(field1044) self.newline() - field1035 = unwrapped_fields1033[1] - self.pretty_abstraction(field1035) + field1045 = unwrapped_fields1043[1] + self.pretty_abstraction(field1045) self.newline() - field1036 = unwrapped_fields1033[2] - self.pretty_terms(field1036) + field1046 = unwrapped_fields1043[2] + self.pretty_terms(field1046) self.dedent() self.write(")") def pretty_terms(self, msg: Sequence[logic_pb2.Term]): - flat1041 = self._try_flat(msg, self.pretty_terms) - if flat1041 is not None: - assert flat1041 is not None - self.write(flat1041) + flat1051 = self._try_flat(msg, self.pretty_terms) + if flat1051 is not None: + assert flat1051 is not None + self.write(flat1051) return None else: - fields1038 = msg + fields1048 = msg self.write("(terms") self.indent_sexp() - if not len(fields1038) == 0: + if not len(fields1048) == 0: self.newline() - for i1040, elem1039 in enumerate(fields1038): - if (i1040 > 0): + for i1050, elem1049 in enumerate(fields1048): + if (i1050 > 0): self.newline() - self.pretty_term(elem1039) + self.pretty_term(elem1049) self.dedent() self.write(")") def pretty_term(self, msg: logic_pb2.Term): - flat1046 = self._try_flat(msg, self.pretty_term) - if flat1046 is not None: - assert flat1046 is not None - self.write(flat1046) + flat1056 = self._try_flat(msg, self.pretty_term) + if flat1056 is not None: + assert flat1056 is not None + self.write(flat1056) return None else: _dollar_dollar = msg if _dollar_dollar.HasField("var"): - _t1659 = _dollar_dollar.var + _t1679 = _dollar_dollar.var else: - _t1659 = None - deconstruct_result1044 = _t1659 - if deconstruct_result1044 is not None: - assert deconstruct_result1044 is not None - unwrapped1045 = deconstruct_result1044 - self.pretty_var(unwrapped1045) + _t1679 = None + deconstruct_result1054 = _t1679 + if deconstruct_result1054 is not None: + assert deconstruct_result1054 is not None + unwrapped1055 = deconstruct_result1054 + self.pretty_var(unwrapped1055) else: _dollar_dollar = msg if _dollar_dollar.HasField("constant"): - _t1660 = _dollar_dollar.constant + _t1680 = _dollar_dollar.constant else: - _t1660 = None - deconstruct_result1042 = _t1660 - if deconstruct_result1042 is not None: - assert deconstruct_result1042 is not None - unwrapped1043 = deconstruct_result1042 - self.pretty_value(unwrapped1043) + _t1680 = None + deconstruct_result1052 = _t1680 + if deconstruct_result1052 is not None: + assert deconstruct_result1052 is not None + unwrapped1053 = deconstruct_result1052 + self.pretty_value(unwrapped1053) else: raise ParseError("No matching rule for term") def pretty_var(self, msg: logic_pb2.Var): - flat1049 = self._try_flat(msg, self.pretty_var) - if flat1049 is not None: - assert flat1049 is not None - self.write(flat1049) + flat1059 = self._try_flat(msg, self.pretty_var) + if flat1059 is not None: + assert flat1059 is not None + self.write(flat1059) return None else: _dollar_dollar = msg - fields1047 = _dollar_dollar.name - assert fields1047 is not None - unwrapped_fields1048 = fields1047 - self.write(unwrapped_fields1048) + fields1057 = _dollar_dollar.name + assert fields1057 is not None + unwrapped_fields1058 = fields1057 + self.write(unwrapped_fields1058) def pretty_value(self, msg: logic_pb2.Value): - flat1075 = self._try_flat(msg, self.pretty_value) - if flat1075 is not None: - assert flat1075 is not None - self.write(flat1075) + flat1085 = self._try_flat(msg, self.pretty_value) + if flat1085 is not None: + assert flat1085 is not None + self.write(flat1085) return None else: _dollar_dollar = msg if _dollar_dollar.HasField("date_value"): - _t1661 = _dollar_dollar.date_value + _t1681 = _dollar_dollar.date_value else: - _t1661 = None - deconstruct_result1073 = _t1661 - if deconstruct_result1073 is not None: - assert deconstruct_result1073 is not None - unwrapped1074 = deconstruct_result1073 - self.pretty_date(unwrapped1074) + _t1681 = None + deconstruct_result1083 = _t1681 + if deconstruct_result1083 is not None: + assert deconstruct_result1083 is not None + unwrapped1084 = deconstruct_result1083 + self.pretty_date(unwrapped1084) else: _dollar_dollar = msg if _dollar_dollar.HasField("datetime_value"): - _t1662 = _dollar_dollar.datetime_value + _t1682 = _dollar_dollar.datetime_value else: - _t1662 = None - deconstruct_result1071 = _t1662 - if deconstruct_result1071 is not None: - assert deconstruct_result1071 is not None - unwrapped1072 = deconstruct_result1071 - self.pretty_datetime(unwrapped1072) + _t1682 = None + deconstruct_result1081 = _t1682 + if deconstruct_result1081 is not None: + assert deconstruct_result1081 is not None + unwrapped1082 = deconstruct_result1081 + self.pretty_datetime(unwrapped1082) else: _dollar_dollar = msg if _dollar_dollar.HasField("string_value"): - _t1663 = _dollar_dollar.string_value + _t1683 = _dollar_dollar.string_value else: - _t1663 = None - deconstruct_result1069 = _t1663 - if deconstruct_result1069 is not None: - assert deconstruct_result1069 is not None - unwrapped1070 = deconstruct_result1069 - self.write(self.format_string_value(unwrapped1070)) + _t1683 = None + deconstruct_result1079 = _t1683 + if deconstruct_result1079 is not None: + assert deconstruct_result1079 is not None + unwrapped1080 = deconstruct_result1079 + self.write(self.format_string_value(unwrapped1080)) else: _dollar_dollar = msg if _dollar_dollar.HasField("int32_value"): - _t1664 = _dollar_dollar.int32_value + _t1684 = _dollar_dollar.int32_value else: - _t1664 = None - deconstruct_result1067 = _t1664 - if deconstruct_result1067 is not None: - assert deconstruct_result1067 is not None - unwrapped1068 = deconstruct_result1067 - self.write((str(unwrapped1068) + 'i32')) + _t1684 = None + deconstruct_result1077 = _t1684 + if deconstruct_result1077 is not None: + assert deconstruct_result1077 is not None + unwrapped1078 = deconstruct_result1077 + self.write((str(unwrapped1078) + 'i32')) else: _dollar_dollar = msg if _dollar_dollar.HasField("int_value"): - _t1665 = _dollar_dollar.int_value + _t1685 = _dollar_dollar.int_value else: - _t1665 = None - deconstruct_result1065 = _t1665 - if deconstruct_result1065 is not None: - assert deconstruct_result1065 is not None - unwrapped1066 = deconstruct_result1065 - self.write(str(unwrapped1066)) + _t1685 = None + deconstruct_result1075 = _t1685 + if deconstruct_result1075 is not None: + assert deconstruct_result1075 is not None + unwrapped1076 = deconstruct_result1075 + self.write(str(unwrapped1076)) else: _dollar_dollar = msg if _dollar_dollar.HasField("float32_value"): - _t1666 = _dollar_dollar.float32_value + _t1686 = _dollar_dollar.float32_value else: - _t1666 = None - deconstruct_result1063 = _t1666 - if deconstruct_result1063 is not None: - assert deconstruct_result1063 is not None - unwrapped1064 = deconstruct_result1063 - self.write(self.format_float32_literal(unwrapped1064)) + _t1686 = None + deconstruct_result1073 = _t1686 + if deconstruct_result1073 is not None: + assert deconstruct_result1073 is not None + unwrapped1074 = deconstruct_result1073 + self.write(self.format_float32_literal(unwrapped1074)) else: _dollar_dollar = msg if _dollar_dollar.HasField("float_value"): - _t1667 = _dollar_dollar.float_value + _t1687 = _dollar_dollar.float_value else: - _t1667 = None - deconstruct_result1061 = _t1667 - if deconstruct_result1061 is not None: - assert deconstruct_result1061 is not None - unwrapped1062 = deconstruct_result1061 - self.write(str(unwrapped1062)) + _t1687 = None + deconstruct_result1071 = _t1687 + if deconstruct_result1071 is not None: + assert deconstruct_result1071 is not None + unwrapped1072 = deconstruct_result1071 + self.write(str(unwrapped1072)) else: _dollar_dollar = msg if _dollar_dollar.HasField("uint32_value"): - _t1668 = _dollar_dollar.uint32_value + _t1688 = _dollar_dollar.uint32_value else: - _t1668 = None - deconstruct_result1059 = _t1668 - if deconstruct_result1059 is not None: - assert deconstruct_result1059 is not None - unwrapped1060 = deconstruct_result1059 - self.write((str(unwrapped1060) + 'u32')) + _t1688 = None + deconstruct_result1069 = _t1688 + if deconstruct_result1069 is not None: + assert deconstruct_result1069 is not None + unwrapped1070 = deconstruct_result1069 + self.write((str(unwrapped1070) + 'u32')) else: _dollar_dollar = msg if _dollar_dollar.HasField("uint128_value"): - _t1669 = _dollar_dollar.uint128_value + _t1689 = _dollar_dollar.uint128_value else: - _t1669 = None - deconstruct_result1057 = _t1669 - if deconstruct_result1057 is not None: - assert deconstruct_result1057 is not None - unwrapped1058 = deconstruct_result1057 - self.write(self.format_uint128(unwrapped1058)) + _t1689 = None + deconstruct_result1067 = _t1689 + if deconstruct_result1067 is not None: + assert deconstruct_result1067 is not None + unwrapped1068 = deconstruct_result1067 + self.write(self.format_uint128(unwrapped1068)) else: _dollar_dollar = msg if _dollar_dollar.HasField("int128_value"): - _t1670 = _dollar_dollar.int128_value + _t1690 = _dollar_dollar.int128_value else: - _t1670 = None - deconstruct_result1055 = _t1670 - if deconstruct_result1055 is not None: - assert deconstruct_result1055 is not None - unwrapped1056 = deconstruct_result1055 - self.write(self.format_int128(unwrapped1056)) + _t1690 = None + deconstruct_result1065 = _t1690 + if deconstruct_result1065 is not None: + assert deconstruct_result1065 is not None + unwrapped1066 = deconstruct_result1065 + self.write(self.format_int128(unwrapped1066)) else: _dollar_dollar = msg if _dollar_dollar.HasField("decimal_value"): - _t1671 = _dollar_dollar.decimal_value + _t1691 = _dollar_dollar.decimal_value else: - _t1671 = None - deconstruct_result1053 = _t1671 - if deconstruct_result1053 is not None: - assert deconstruct_result1053 is not None - unwrapped1054 = deconstruct_result1053 - self.write(self.format_decimal(unwrapped1054)) + _t1691 = None + deconstruct_result1063 = _t1691 + if deconstruct_result1063 is not None: + assert deconstruct_result1063 is not None + unwrapped1064 = deconstruct_result1063 + self.write(self.format_decimal(unwrapped1064)) else: _dollar_dollar = msg if _dollar_dollar.HasField("boolean_value"): - _t1672 = _dollar_dollar.boolean_value + _t1692 = _dollar_dollar.boolean_value else: - _t1672 = None - deconstruct_result1051 = _t1672 - if deconstruct_result1051 is not None: - assert deconstruct_result1051 is not None - unwrapped1052 = deconstruct_result1051 - self.pretty_boolean_value(unwrapped1052) + _t1692 = None + deconstruct_result1061 = _t1692 + if deconstruct_result1061 is not None: + assert deconstruct_result1061 is not None + unwrapped1062 = deconstruct_result1061 + self.pretty_boolean_value(unwrapped1062) else: - fields1050 = msg + fields1060 = msg self.write("missing") def pretty_date(self, msg: logic_pb2.DateValue): - flat1081 = self._try_flat(msg, self.pretty_date) - if flat1081 is not None: - assert flat1081 is not None - self.write(flat1081) + flat1091 = self._try_flat(msg, self.pretty_date) + if flat1091 is not None: + assert flat1091 is not None + self.write(flat1091) return None else: _dollar_dollar = msg - fields1076 = (int(_dollar_dollar.year), int(_dollar_dollar.month), int(_dollar_dollar.day),) - assert fields1076 is not None - unwrapped_fields1077 = fields1076 + fields1086 = (int(_dollar_dollar.year), int(_dollar_dollar.month), int(_dollar_dollar.day),) + assert fields1086 is not None + unwrapped_fields1087 = fields1086 self.write("(date") self.indent_sexp() self.newline() - field1078 = unwrapped_fields1077[0] - self.write(str(field1078)) + field1088 = unwrapped_fields1087[0] + self.write(str(field1088)) self.newline() - field1079 = unwrapped_fields1077[1] - self.write(str(field1079)) + field1089 = unwrapped_fields1087[1] + self.write(str(field1089)) self.newline() - field1080 = unwrapped_fields1077[2] - self.write(str(field1080)) + field1090 = unwrapped_fields1087[2] + self.write(str(field1090)) self.dedent() self.write(")") def pretty_datetime(self, msg: logic_pb2.DateTimeValue): - flat1092 = self._try_flat(msg, self.pretty_datetime) - if flat1092 is not None: - assert flat1092 is not None - self.write(flat1092) + flat1102 = self._try_flat(msg, self.pretty_datetime) + if flat1102 is not None: + assert flat1102 is not None + self.write(flat1102) return None else: _dollar_dollar = msg - fields1082 = (int(_dollar_dollar.year), int(_dollar_dollar.month), int(_dollar_dollar.day), int(_dollar_dollar.hour), int(_dollar_dollar.minute), int(_dollar_dollar.second), int(_dollar_dollar.microsecond),) - assert fields1082 is not None - unwrapped_fields1083 = fields1082 + fields1092 = (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 fields1092 is not None + unwrapped_fields1093 = fields1092 self.write("(datetime") self.indent_sexp() self.newline() - field1084 = unwrapped_fields1083[0] - self.write(str(field1084)) + field1094 = unwrapped_fields1093[0] + self.write(str(field1094)) self.newline() - field1085 = unwrapped_fields1083[1] - self.write(str(field1085)) + field1095 = unwrapped_fields1093[1] + self.write(str(field1095)) self.newline() - field1086 = unwrapped_fields1083[2] - self.write(str(field1086)) + field1096 = unwrapped_fields1093[2] + self.write(str(field1096)) self.newline() - field1087 = unwrapped_fields1083[3] - self.write(str(field1087)) + field1097 = unwrapped_fields1093[3] + self.write(str(field1097)) self.newline() - field1088 = unwrapped_fields1083[4] - self.write(str(field1088)) + field1098 = unwrapped_fields1093[4] + self.write(str(field1098)) self.newline() - field1089 = unwrapped_fields1083[5] - self.write(str(field1089)) - field1090 = unwrapped_fields1083[6] - if field1090 is not None: + field1099 = unwrapped_fields1093[5] + self.write(str(field1099)) + field1100 = unwrapped_fields1093[6] + if field1100 is not None: self.newline() - assert field1090 is not None - opt_val1091 = field1090 - self.write(str(opt_val1091)) + assert field1100 is not None + opt_val1101 = field1100 + self.write(str(opt_val1101)) self.dedent() self.write(")") def pretty_conjunction(self, msg: logic_pb2.Conjunction): - flat1097 = self._try_flat(msg, self.pretty_conjunction) - if flat1097 is not None: - assert flat1097 is not None - self.write(flat1097) + flat1107 = self._try_flat(msg, self.pretty_conjunction) + if flat1107 is not None: + assert flat1107 is not None + self.write(flat1107) return None else: _dollar_dollar = msg - fields1093 = _dollar_dollar.args - assert fields1093 is not None - unwrapped_fields1094 = fields1093 + fields1103 = _dollar_dollar.args + assert fields1103 is not None + unwrapped_fields1104 = fields1103 self.write("(and") self.indent_sexp() - if not len(unwrapped_fields1094) == 0: + if not len(unwrapped_fields1104) == 0: self.newline() - for i1096, elem1095 in enumerate(unwrapped_fields1094): - if (i1096 > 0): + for i1106, elem1105 in enumerate(unwrapped_fields1104): + if (i1106 > 0): self.newline() - self.pretty_formula(elem1095) + self.pretty_formula(elem1105) self.dedent() self.write(")") def pretty_disjunction(self, msg: logic_pb2.Disjunction): - flat1102 = self._try_flat(msg, self.pretty_disjunction) - if flat1102 is not None: - assert flat1102 is not None - self.write(flat1102) + flat1112 = self._try_flat(msg, self.pretty_disjunction) + if flat1112 is not None: + assert flat1112 is not None + self.write(flat1112) return None else: _dollar_dollar = msg - fields1098 = _dollar_dollar.args - assert fields1098 is not None - unwrapped_fields1099 = fields1098 + fields1108 = _dollar_dollar.args + assert fields1108 is not None + unwrapped_fields1109 = fields1108 self.write("(or") self.indent_sexp() - if not len(unwrapped_fields1099) == 0: + if not len(unwrapped_fields1109) == 0: self.newline() - for i1101, elem1100 in enumerate(unwrapped_fields1099): - if (i1101 > 0): + for i1111, elem1110 in enumerate(unwrapped_fields1109): + if (i1111 > 0): self.newline() - self.pretty_formula(elem1100) + self.pretty_formula(elem1110) self.dedent() self.write(")") def pretty_not(self, msg: logic_pb2.Not): - flat1105 = self._try_flat(msg, self.pretty_not) - if flat1105 is not None: - assert flat1105 is not None - self.write(flat1105) + flat1115 = self._try_flat(msg, self.pretty_not) + if flat1115 is not None: + assert flat1115 is not None + self.write(flat1115) return None else: _dollar_dollar = msg - fields1103 = _dollar_dollar.arg - assert fields1103 is not None - unwrapped_fields1104 = fields1103 + fields1113 = _dollar_dollar.arg + assert fields1113 is not None + unwrapped_fields1114 = fields1113 self.write("(not") self.indent_sexp() self.newline() - self.pretty_formula(unwrapped_fields1104) + self.pretty_formula(unwrapped_fields1114) self.dedent() self.write(")") def pretty_ffi(self, msg: logic_pb2.FFI): - flat1111 = self._try_flat(msg, self.pretty_ffi) - if flat1111 is not None: - assert flat1111 is not None - self.write(flat1111) + flat1121 = self._try_flat(msg, self.pretty_ffi) + if flat1121 is not None: + assert flat1121 is not None + self.write(flat1121) return None else: _dollar_dollar = msg - fields1106 = (_dollar_dollar.name, _dollar_dollar.args, _dollar_dollar.terms,) - assert fields1106 is not None - unwrapped_fields1107 = fields1106 + fields1116 = (_dollar_dollar.name, _dollar_dollar.args, _dollar_dollar.terms,) + assert fields1116 is not None + unwrapped_fields1117 = fields1116 self.write("(ffi") self.indent_sexp() self.newline() - field1108 = unwrapped_fields1107[0] - self.pretty_name(field1108) + field1118 = unwrapped_fields1117[0] + self.pretty_name(field1118) self.newline() - field1109 = unwrapped_fields1107[1] - self.pretty_ffi_args(field1109) + field1119 = unwrapped_fields1117[1] + self.pretty_ffi_args(field1119) self.newline() - field1110 = unwrapped_fields1107[2] - self.pretty_terms(field1110) + field1120 = unwrapped_fields1117[2] + self.pretty_terms(field1120) self.dedent() self.write(")") def pretty_name(self, msg: str): - flat1113 = self._try_flat(msg, self.pretty_name) - if flat1113 is not None: - assert flat1113 is not None - self.write(flat1113) + flat1123 = self._try_flat(msg, self.pretty_name) + if flat1123 is not None: + assert flat1123 is not None + self.write(flat1123) return None else: - fields1112 = msg + fields1122 = msg self.write(":") - self.write(fields1112) + self.write(fields1122) def pretty_ffi_args(self, msg: Sequence[logic_pb2.Abstraction]): - flat1117 = self._try_flat(msg, self.pretty_ffi_args) - if flat1117 is not None: - assert flat1117 is not None - self.write(flat1117) + flat1127 = self._try_flat(msg, self.pretty_ffi_args) + if flat1127 is not None: + assert flat1127 is not None + self.write(flat1127) return None else: - fields1114 = msg + fields1124 = msg self.write("(args") self.indent_sexp() - if not len(fields1114) == 0: + if not len(fields1124) == 0: self.newline() - for i1116, elem1115 in enumerate(fields1114): - if (i1116 > 0): + for i1126, elem1125 in enumerate(fields1124): + if (i1126 > 0): self.newline() - self.pretty_abstraction(elem1115) + self.pretty_abstraction(elem1125) self.dedent() self.write(")") def pretty_atom(self, msg: logic_pb2.Atom): - flat1124 = self._try_flat(msg, self.pretty_atom) - if flat1124 is not None: - assert flat1124 is not None - self.write(flat1124) + flat1134 = self._try_flat(msg, self.pretty_atom) + if flat1134 is not None: + assert flat1134 is not None + self.write(flat1134) return None else: _dollar_dollar = msg - fields1118 = (_dollar_dollar.name, _dollar_dollar.terms,) - assert fields1118 is not None - unwrapped_fields1119 = fields1118 + fields1128 = (_dollar_dollar.name, _dollar_dollar.terms,) + assert fields1128 is not None + unwrapped_fields1129 = fields1128 self.write("(atom") self.indent_sexp() self.newline() - field1120 = unwrapped_fields1119[0] - self.pretty_relation_id(field1120) - field1121 = unwrapped_fields1119[1] - if not len(field1121) == 0: + field1130 = unwrapped_fields1129[0] + self.pretty_relation_id(field1130) + field1131 = unwrapped_fields1129[1] + if not len(field1131) == 0: self.newline() - for i1123, elem1122 in enumerate(field1121): - if (i1123 > 0): + for i1133, elem1132 in enumerate(field1131): + if (i1133 > 0): self.newline() - self.pretty_term(elem1122) + self.pretty_term(elem1132) self.dedent() self.write(")") def pretty_pragma(self, msg: logic_pb2.Pragma): - flat1131 = self._try_flat(msg, self.pretty_pragma) - if flat1131 is not None: - assert flat1131 is not None - self.write(flat1131) + flat1141 = self._try_flat(msg, self.pretty_pragma) + if flat1141 is not None: + assert flat1141 is not None + self.write(flat1141) return None else: _dollar_dollar = msg - fields1125 = (_dollar_dollar.name, _dollar_dollar.terms,) - assert fields1125 is not None - unwrapped_fields1126 = fields1125 + fields1135 = (_dollar_dollar.name, _dollar_dollar.terms,) + assert fields1135 is not None + unwrapped_fields1136 = fields1135 self.write("(pragma") self.indent_sexp() self.newline() - field1127 = unwrapped_fields1126[0] - self.pretty_name(field1127) - field1128 = unwrapped_fields1126[1] - if not len(field1128) == 0: + field1137 = unwrapped_fields1136[0] + self.pretty_name(field1137) + field1138 = unwrapped_fields1136[1] + if not len(field1138) == 0: self.newline() - for i1130, elem1129 in enumerate(field1128): - if (i1130 > 0): + for i1140, elem1139 in enumerate(field1138): + if (i1140 > 0): self.newline() - self.pretty_term(elem1129) + self.pretty_term(elem1139) self.dedent() self.write(")") def pretty_primitive(self, msg: logic_pb2.Primitive): - flat1147 = self._try_flat(msg, self.pretty_primitive) - if flat1147 is not None: - assert flat1147 is not None - self.write(flat1147) + flat1157 = self._try_flat(msg, self.pretty_primitive) + if flat1157 is not None: + assert flat1157 is not None + self.write(flat1157) return None else: _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_eq": - _t1673 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) + _t1693 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) else: - _t1673 = None - guard_result1146 = _t1673 - if guard_result1146 is not None: + _t1693 = None + guard_result1156 = _t1693 + if guard_result1156 is not None: self.pretty_eq(msg) else: _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_lt_monotype": - _t1674 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) + _t1694 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) else: - _t1674 = None - guard_result1145 = _t1674 - if guard_result1145 is not None: + _t1694 = None + guard_result1155 = _t1694 + if guard_result1155 is not None: self.pretty_lt(msg) else: _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_lt_eq_monotype": - _t1675 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) + _t1695 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) else: - _t1675 = None - guard_result1144 = _t1675 - if guard_result1144 is not None: + _t1695 = None + guard_result1154 = _t1695 + if guard_result1154 is not None: self.pretty_lt_eq(msg) else: _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_gt_monotype": - _t1676 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) + _t1696 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) else: - _t1676 = None - guard_result1143 = _t1676 - if guard_result1143 is not None: + _t1696 = None + guard_result1153 = _t1696 + if guard_result1153 is not None: self.pretty_gt(msg) else: _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_gt_eq_monotype": - _t1677 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) + _t1697 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) else: - _t1677 = None - guard_result1142 = _t1677 - if guard_result1142 is not None: + _t1697 = None + guard_result1152 = _t1697 + if guard_result1152 is not None: self.pretty_gt_eq(msg) else: _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_add_monotype": - _t1678 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) + _t1698 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) else: - _t1678 = None - guard_result1141 = _t1678 - if guard_result1141 is not None: + _t1698 = None + guard_result1151 = _t1698 + if guard_result1151 is not None: self.pretty_add(msg) else: _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_subtract_monotype": - _t1679 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) + _t1699 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) else: - _t1679 = None - guard_result1140 = _t1679 - if guard_result1140 is not None: + _t1699 = None + guard_result1150 = _t1699 + if guard_result1150 is not None: self.pretty_minus(msg) else: _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_multiply_monotype": - _t1680 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) + _t1700 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) else: - _t1680 = None - guard_result1139 = _t1680 - if guard_result1139 is not None: + _t1700 = None + guard_result1149 = _t1700 + if guard_result1149 is not None: self.pretty_multiply(msg) else: _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_divide_monotype": - _t1681 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) + _t1701 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) else: - _t1681 = None - guard_result1138 = _t1681 - if guard_result1138 is not None: + _t1701 = None + guard_result1148 = _t1701 + if guard_result1148 is not None: self.pretty_divide(msg) else: _dollar_dollar = msg - fields1132 = (_dollar_dollar.name, _dollar_dollar.terms,) - assert fields1132 is not None - unwrapped_fields1133 = fields1132 + fields1142 = (_dollar_dollar.name, _dollar_dollar.terms,) + assert fields1142 is not None + unwrapped_fields1143 = fields1142 self.write("(primitive") self.indent_sexp() self.newline() - field1134 = unwrapped_fields1133[0] - self.pretty_name(field1134) - field1135 = unwrapped_fields1133[1] - if not len(field1135) == 0: + field1144 = unwrapped_fields1143[0] + self.pretty_name(field1144) + field1145 = unwrapped_fields1143[1] + if not len(field1145) == 0: self.newline() - for i1137, elem1136 in enumerate(field1135): - if (i1137 > 0): + for i1147, elem1146 in enumerate(field1145): + if (i1147 > 0): self.newline() - self.pretty_rel_term(elem1136) + self.pretty_rel_term(elem1146) self.dedent() self.write(")") def pretty_eq(self, msg: logic_pb2.Primitive): - flat1152 = self._try_flat(msg, self.pretty_eq) - if flat1152 is not None: - assert flat1152 is not None - self.write(flat1152) + flat1162 = self._try_flat(msg, self.pretty_eq) + if flat1162 is not None: + assert flat1162 is not None + self.write(flat1162) return None else: _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_eq": - _t1682 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) + _t1702 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) else: - _t1682 = None - fields1148 = _t1682 - assert fields1148 is not None - unwrapped_fields1149 = fields1148 + _t1702 = None + fields1158 = _t1702 + assert fields1158 is not None + unwrapped_fields1159 = fields1158 self.write("(=") self.indent_sexp() self.newline() - field1150 = unwrapped_fields1149[0] - self.pretty_term(field1150) + field1160 = unwrapped_fields1159[0] + self.pretty_term(field1160) self.newline() - field1151 = unwrapped_fields1149[1] - self.pretty_term(field1151) + field1161 = unwrapped_fields1159[1] + self.pretty_term(field1161) self.dedent() self.write(")") def pretty_lt(self, msg: logic_pb2.Primitive): - flat1157 = self._try_flat(msg, self.pretty_lt) - if flat1157 is not None: - assert flat1157 is not None - self.write(flat1157) + flat1167 = self._try_flat(msg, self.pretty_lt) + if flat1167 is not None: + assert flat1167 is not None + self.write(flat1167) return None else: _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_lt_monotype": - _t1683 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) + _t1703 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) else: - _t1683 = None - fields1153 = _t1683 - assert fields1153 is not None - unwrapped_fields1154 = fields1153 + _t1703 = None + fields1163 = _t1703 + assert fields1163 is not None + unwrapped_fields1164 = fields1163 self.write("(<") self.indent_sexp() self.newline() - field1155 = unwrapped_fields1154[0] - self.pretty_term(field1155) + field1165 = unwrapped_fields1164[0] + self.pretty_term(field1165) self.newline() - field1156 = unwrapped_fields1154[1] - self.pretty_term(field1156) + field1166 = unwrapped_fields1164[1] + self.pretty_term(field1166) self.dedent() self.write(")") def pretty_lt_eq(self, msg: logic_pb2.Primitive): - flat1162 = self._try_flat(msg, self.pretty_lt_eq) - if flat1162 is not None: - assert flat1162 is not None - self.write(flat1162) + flat1172 = self._try_flat(msg, self.pretty_lt_eq) + if flat1172 is not None: + assert flat1172 is not None + self.write(flat1172) return None else: _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_lt_eq_monotype": - _t1684 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) + _t1704 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) else: - _t1684 = None - fields1158 = _t1684 - assert fields1158 is not None - unwrapped_fields1159 = fields1158 + _t1704 = None + fields1168 = _t1704 + assert fields1168 is not None + unwrapped_fields1169 = fields1168 self.write("(<=") self.indent_sexp() self.newline() - field1160 = unwrapped_fields1159[0] - self.pretty_term(field1160) + field1170 = unwrapped_fields1169[0] + self.pretty_term(field1170) self.newline() - field1161 = unwrapped_fields1159[1] - self.pretty_term(field1161) + field1171 = unwrapped_fields1169[1] + self.pretty_term(field1171) self.dedent() self.write(")") def pretty_gt(self, msg: logic_pb2.Primitive): - flat1167 = self._try_flat(msg, self.pretty_gt) - if flat1167 is not None: - assert flat1167 is not None - self.write(flat1167) + flat1177 = self._try_flat(msg, self.pretty_gt) + if flat1177 is not None: + assert flat1177 is not None + self.write(flat1177) return None else: _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_gt_monotype": - _t1685 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) + _t1705 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) else: - _t1685 = None - fields1163 = _t1685 - assert fields1163 is not None - unwrapped_fields1164 = fields1163 + _t1705 = None + fields1173 = _t1705 + assert fields1173 is not None + unwrapped_fields1174 = fields1173 self.write("(>") self.indent_sexp() self.newline() - field1165 = unwrapped_fields1164[0] - self.pretty_term(field1165) + field1175 = unwrapped_fields1174[0] + self.pretty_term(field1175) self.newline() - field1166 = unwrapped_fields1164[1] - self.pretty_term(field1166) + field1176 = unwrapped_fields1174[1] + self.pretty_term(field1176) self.dedent() self.write(")") def pretty_gt_eq(self, msg: logic_pb2.Primitive): - flat1172 = self._try_flat(msg, self.pretty_gt_eq) - if flat1172 is not None: - assert flat1172 is not None - self.write(flat1172) + flat1182 = self._try_flat(msg, self.pretty_gt_eq) + if flat1182 is not None: + assert flat1182 is not None + self.write(flat1182) return None else: _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_gt_eq_monotype": - _t1686 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) + _t1706 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) else: - _t1686 = None - fields1168 = _t1686 - assert fields1168 is not None - unwrapped_fields1169 = fields1168 + _t1706 = None + fields1178 = _t1706 + assert fields1178 is not None + unwrapped_fields1179 = fields1178 self.write("(>=") self.indent_sexp() self.newline() - field1170 = unwrapped_fields1169[0] - self.pretty_term(field1170) + field1180 = unwrapped_fields1179[0] + self.pretty_term(field1180) self.newline() - field1171 = unwrapped_fields1169[1] - self.pretty_term(field1171) + field1181 = unwrapped_fields1179[1] + self.pretty_term(field1181) self.dedent() self.write(")") def pretty_add(self, msg: logic_pb2.Primitive): - flat1178 = self._try_flat(msg, self.pretty_add) - if flat1178 is not None: - assert flat1178 is not None - self.write(flat1178) + flat1188 = self._try_flat(msg, self.pretty_add) + if flat1188 is not None: + assert flat1188 is not None + self.write(flat1188) return None else: _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_add_monotype": - _t1687 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) + _t1707 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) else: - _t1687 = None - fields1173 = _t1687 - assert fields1173 is not None - unwrapped_fields1174 = fields1173 + _t1707 = None + fields1183 = _t1707 + assert fields1183 is not None + unwrapped_fields1184 = fields1183 self.write("(+") self.indent_sexp() self.newline() - field1175 = unwrapped_fields1174[0] - self.pretty_term(field1175) + field1185 = unwrapped_fields1184[0] + self.pretty_term(field1185) self.newline() - field1176 = unwrapped_fields1174[1] - self.pretty_term(field1176) + field1186 = unwrapped_fields1184[1] + self.pretty_term(field1186) self.newline() - field1177 = unwrapped_fields1174[2] - self.pretty_term(field1177) + field1187 = unwrapped_fields1184[2] + self.pretty_term(field1187) self.dedent() self.write(")") def pretty_minus(self, msg: logic_pb2.Primitive): - flat1184 = self._try_flat(msg, self.pretty_minus) - if flat1184 is not None: - assert flat1184 is not None - self.write(flat1184) + flat1194 = self._try_flat(msg, self.pretty_minus) + if flat1194 is not None: + assert flat1194 is not None + self.write(flat1194) return None else: _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_subtract_monotype": - _t1688 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) + _t1708 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) else: - _t1688 = None - fields1179 = _t1688 - assert fields1179 is not None - unwrapped_fields1180 = fields1179 + _t1708 = None + fields1189 = _t1708 + assert fields1189 is not None + unwrapped_fields1190 = fields1189 self.write("(-") self.indent_sexp() self.newline() - field1181 = unwrapped_fields1180[0] - self.pretty_term(field1181) + field1191 = unwrapped_fields1190[0] + self.pretty_term(field1191) self.newline() - field1182 = unwrapped_fields1180[1] - self.pretty_term(field1182) + field1192 = unwrapped_fields1190[1] + self.pretty_term(field1192) self.newline() - field1183 = unwrapped_fields1180[2] - self.pretty_term(field1183) + field1193 = unwrapped_fields1190[2] + self.pretty_term(field1193) self.dedent() self.write(")") def pretty_multiply(self, msg: logic_pb2.Primitive): - flat1190 = self._try_flat(msg, self.pretty_multiply) - if flat1190 is not None: - assert flat1190 is not None - self.write(flat1190) + flat1200 = self._try_flat(msg, self.pretty_multiply) + 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_multiply_monotype": - _t1689 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) + _t1709 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) else: - _t1689 = None - fields1185 = _t1689 - assert fields1185 is not None - unwrapped_fields1186 = fields1185 + _t1709 = None + fields1195 = _t1709 + assert fields1195 is not None + unwrapped_fields1196 = fields1195 self.write("(*") self.indent_sexp() self.newline() - field1187 = unwrapped_fields1186[0] - self.pretty_term(field1187) + field1197 = unwrapped_fields1196[0] + self.pretty_term(field1197) self.newline() - field1188 = unwrapped_fields1186[1] - self.pretty_term(field1188) + field1198 = unwrapped_fields1196[1] + self.pretty_term(field1198) self.newline() - field1189 = unwrapped_fields1186[2] - self.pretty_term(field1189) + field1199 = unwrapped_fields1196[2] + self.pretty_term(field1199) self.dedent() self.write(")") def pretty_divide(self, msg: logic_pb2.Primitive): - flat1196 = self._try_flat(msg, self.pretty_divide) - if flat1196 is not None: - assert flat1196 is not None - self.write(flat1196) + flat1206 = self._try_flat(msg, self.pretty_divide) + if flat1206 is not None: + assert flat1206 is not None + self.write(flat1206) return None else: _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_divide_monotype": - _t1690 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) + _t1710 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) else: - _t1690 = None - fields1191 = _t1690 - assert fields1191 is not None - unwrapped_fields1192 = fields1191 + _t1710 = None + fields1201 = _t1710 + assert fields1201 is not None + unwrapped_fields1202 = fields1201 self.write("(/") self.indent_sexp() self.newline() - field1193 = unwrapped_fields1192[0] - self.pretty_term(field1193) + field1203 = unwrapped_fields1202[0] + self.pretty_term(field1203) self.newline() - field1194 = unwrapped_fields1192[1] - self.pretty_term(field1194) + field1204 = unwrapped_fields1202[1] + self.pretty_term(field1204) self.newline() - field1195 = unwrapped_fields1192[2] - self.pretty_term(field1195) + field1205 = unwrapped_fields1202[2] + self.pretty_term(field1205) self.dedent() self.write(")") def pretty_rel_term(self, msg: logic_pb2.RelTerm): - flat1201 = self._try_flat(msg, self.pretty_rel_term) - if flat1201 is not None: - assert flat1201 is not None - self.write(flat1201) + flat1211 = self._try_flat(msg, self.pretty_rel_term) + if flat1211 is not None: + assert flat1211 is not None + self.write(flat1211) return None else: _dollar_dollar = msg if _dollar_dollar.HasField("specialized_value"): - _t1691 = _dollar_dollar.specialized_value + _t1711 = _dollar_dollar.specialized_value else: - _t1691 = None - deconstruct_result1199 = _t1691 - if deconstruct_result1199 is not None: - assert deconstruct_result1199 is not None - unwrapped1200 = deconstruct_result1199 - self.pretty_specialized_value(unwrapped1200) + _t1711 = None + deconstruct_result1209 = _t1711 + if deconstruct_result1209 is not None: + assert deconstruct_result1209 is not None + unwrapped1210 = deconstruct_result1209 + self.pretty_specialized_value(unwrapped1210) else: _dollar_dollar = msg if _dollar_dollar.HasField("term"): - _t1692 = _dollar_dollar.term + _t1712 = _dollar_dollar.term else: - _t1692 = None - deconstruct_result1197 = _t1692 - if deconstruct_result1197 is not None: - assert deconstruct_result1197 is not None - unwrapped1198 = deconstruct_result1197 - self.pretty_term(unwrapped1198) + _t1712 = None + deconstruct_result1207 = _t1712 + if deconstruct_result1207 is not None: + assert deconstruct_result1207 is not None + unwrapped1208 = deconstruct_result1207 + self.pretty_term(unwrapped1208) else: raise ParseError("No matching rule for rel_term") def pretty_specialized_value(self, msg: logic_pb2.Value): - flat1203 = self._try_flat(msg, self.pretty_specialized_value) - if flat1203 is not None: - assert flat1203 is not None - self.write(flat1203) + flat1213 = self._try_flat(msg, self.pretty_specialized_value) + if flat1213 is not None: + assert flat1213 is not None + self.write(flat1213) return None else: - fields1202 = msg + fields1212 = msg self.write("#") - self.pretty_raw_value(fields1202) + self.pretty_raw_value(fields1212) def pretty_rel_atom(self, msg: logic_pb2.RelAtom): - flat1210 = self._try_flat(msg, self.pretty_rel_atom) - if flat1210 is not None: - assert flat1210 is not None - self.write(flat1210) + flat1220 = self._try_flat(msg, self.pretty_rel_atom) + if flat1220 is not None: + assert flat1220 is not None + self.write(flat1220) return None else: _dollar_dollar = msg - fields1204 = (_dollar_dollar.name, _dollar_dollar.terms,) - assert fields1204 is not None - unwrapped_fields1205 = fields1204 + fields1214 = (_dollar_dollar.name, _dollar_dollar.terms,) + assert fields1214 is not None + unwrapped_fields1215 = fields1214 self.write("(relatom") self.indent_sexp() self.newline() - field1206 = unwrapped_fields1205[0] - self.pretty_name(field1206) - field1207 = unwrapped_fields1205[1] - if not len(field1207) == 0: + field1216 = unwrapped_fields1215[0] + self.pretty_name(field1216) + field1217 = unwrapped_fields1215[1] + if not len(field1217) == 0: self.newline() - for i1209, elem1208 in enumerate(field1207): - if (i1209 > 0): + for i1219, elem1218 in enumerate(field1217): + if (i1219 > 0): self.newline() - self.pretty_rel_term(elem1208) + self.pretty_rel_term(elem1218) self.dedent() self.write(")") def pretty_cast(self, msg: logic_pb2.Cast): - flat1215 = self._try_flat(msg, self.pretty_cast) - if flat1215 is not None: - assert flat1215 is not None - self.write(flat1215) + flat1225 = self._try_flat(msg, self.pretty_cast) + if flat1225 is not None: + assert flat1225 is not None + self.write(flat1225) return None else: _dollar_dollar = msg - fields1211 = (_dollar_dollar.input, _dollar_dollar.result,) - assert fields1211 is not None - unwrapped_fields1212 = fields1211 + fields1221 = (_dollar_dollar.input, _dollar_dollar.result,) + assert fields1221 is not None + unwrapped_fields1222 = fields1221 self.write("(cast") self.indent_sexp() self.newline() - field1213 = unwrapped_fields1212[0] - self.pretty_term(field1213) + field1223 = unwrapped_fields1222[0] + self.pretty_term(field1223) self.newline() - field1214 = unwrapped_fields1212[1] - self.pretty_term(field1214) + field1224 = unwrapped_fields1222[1] + self.pretty_term(field1224) self.dedent() self.write(")") def pretty_attrs(self, msg: Sequence[logic_pb2.Attribute]): - flat1219 = self._try_flat(msg, self.pretty_attrs) - if flat1219 is not None: - assert flat1219 is not None - self.write(flat1219) + flat1229 = self._try_flat(msg, self.pretty_attrs) + if flat1229 is not None: + assert flat1229 is not None + self.write(flat1229) return None else: - fields1216 = msg + fields1226 = msg self.write("(attrs") self.indent_sexp() - if not len(fields1216) == 0: + if not len(fields1226) == 0: self.newline() - for i1218, elem1217 in enumerate(fields1216): - if (i1218 > 0): + for i1228, elem1227 in enumerate(fields1226): + if (i1228 > 0): self.newline() - self.pretty_attribute(elem1217) + self.pretty_attribute(elem1227) self.dedent() self.write(")") def pretty_attribute(self, msg: logic_pb2.Attribute): - flat1226 = self._try_flat(msg, self.pretty_attribute) - if flat1226 is not None: - assert flat1226 is not None - self.write(flat1226) + flat1236 = self._try_flat(msg, self.pretty_attribute) + if flat1236 is not None: + assert flat1236 is not None + self.write(flat1236) return None else: _dollar_dollar = msg - fields1220 = (_dollar_dollar.name, _dollar_dollar.args,) - assert fields1220 is not None - unwrapped_fields1221 = fields1220 + fields1230 = (_dollar_dollar.name, _dollar_dollar.args,) + assert fields1230 is not None + unwrapped_fields1231 = fields1230 self.write("(attribute") self.indent_sexp() self.newline() - field1222 = unwrapped_fields1221[0] - self.pretty_name(field1222) - field1223 = unwrapped_fields1221[1] - if not len(field1223) == 0: + field1232 = unwrapped_fields1231[0] + self.pretty_name(field1232) + field1233 = unwrapped_fields1231[1] + if not len(field1233) == 0: self.newline() - for i1225, elem1224 in enumerate(field1223): - if (i1225 > 0): + for i1235, elem1234 in enumerate(field1233): + if (i1235 > 0): self.newline() - self.pretty_raw_value(elem1224) + self.pretty_raw_value(elem1234) self.dedent() self.write(")") def pretty_algorithm(self, msg: logic_pb2.Algorithm): - flat1235 = self._try_flat(msg, self.pretty_algorithm) - if flat1235 is not None: - assert flat1235 is not None - self.write(flat1235) + flat1245 = self._try_flat(msg, self.pretty_algorithm) + if flat1245 is not None: + assert flat1245 is not None + self.write(flat1245) return None else: _dollar_dollar = msg if not len(_dollar_dollar.attrs) == 0: - _t1693 = _dollar_dollar.attrs + _t1713 = _dollar_dollar.attrs else: - _t1693 = None - fields1227 = (getattr(_dollar_dollar, 'global'), _dollar_dollar.body, _t1693,) - assert fields1227 is not None - unwrapped_fields1228 = fields1227 + _t1713 = None + fields1237 = (getattr(_dollar_dollar, 'global'), _dollar_dollar.body, _t1713,) + assert fields1237 is not None + unwrapped_fields1238 = fields1237 self.write("(algorithm") self.indent_sexp() - field1229 = unwrapped_fields1228[0] - if not len(field1229) == 0: + field1239 = unwrapped_fields1238[0] + if not len(field1239) == 0: self.newline() - for i1231, elem1230 in enumerate(field1229): - if (i1231 > 0): + for i1241, elem1240 in enumerate(field1239): + if (i1241 > 0): self.newline() - self.pretty_relation_id(elem1230) + self.pretty_relation_id(elem1240) self.newline() - field1232 = unwrapped_fields1228[1] - self.pretty_script(field1232) - field1233 = unwrapped_fields1228[2] - if field1233 is not None: + field1242 = unwrapped_fields1238[1] + self.pretty_script(field1242) + field1243 = unwrapped_fields1238[2] + if field1243 is not None: self.newline() - assert field1233 is not None - opt_val1234 = field1233 - self.pretty_attrs(opt_val1234) + assert field1243 is not None + opt_val1244 = field1243 + self.pretty_attrs(opt_val1244) self.dedent() self.write(")") def pretty_script(self, msg: logic_pb2.Script): - flat1240 = self._try_flat(msg, self.pretty_script) - if flat1240 is not None: - assert flat1240 is not None - self.write(flat1240) + flat1250 = self._try_flat(msg, self.pretty_script) + if flat1250 is not None: + assert flat1250 is not None + self.write(flat1250) return None else: _dollar_dollar = msg - fields1236 = _dollar_dollar.constructs - assert fields1236 is not None - unwrapped_fields1237 = fields1236 + fields1246 = _dollar_dollar.constructs + assert fields1246 is not None + unwrapped_fields1247 = fields1246 self.write("(script") self.indent_sexp() - if not len(unwrapped_fields1237) == 0: + if not len(unwrapped_fields1247) == 0: self.newline() - for i1239, elem1238 in enumerate(unwrapped_fields1237): - if (i1239 > 0): + for i1249, elem1248 in enumerate(unwrapped_fields1247): + if (i1249 > 0): self.newline() - self.pretty_construct(elem1238) + self.pretty_construct(elem1248) self.dedent() self.write(")") def pretty_construct(self, msg: logic_pb2.Construct): - flat1245 = self._try_flat(msg, self.pretty_construct) - if flat1245 is not None: - assert flat1245 is not None - self.write(flat1245) + flat1255 = self._try_flat(msg, self.pretty_construct) + if flat1255 is not None: + assert flat1255 is not None + self.write(flat1255) return None else: _dollar_dollar = msg if _dollar_dollar.HasField("loop"): - _t1694 = _dollar_dollar.loop + _t1714 = _dollar_dollar.loop else: - _t1694 = None - deconstruct_result1243 = _t1694 - if deconstruct_result1243 is not None: - assert deconstruct_result1243 is not None - unwrapped1244 = deconstruct_result1243 - self.pretty_loop(unwrapped1244) + _t1714 = None + deconstruct_result1253 = _t1714 + if deconstruct_result1253 is not None: + assert deconstruct_result1253 is not None + unwrapped1254 = deconstruct_result1253 + self.pretty_loop(unwrapped1254) else: _dollar_dollar = msg if _dollar_dollar.HasField("instruction"): - _t1695 = _dollar_dollar.instruction + _t1715 = _dollar_dollar.instruction else: - _t1695 = None - deconstruct_result1241 = _t1695 - if deconstruct_result1241 is not None: - assert deconstruct_result1241 is not None - unwrapped1242 = deconstruct_result1241 - self.pretty_instruction(unwrapped1242) + _t1715 = None + deconstruct_result1251 = _t1715 + if deconstruct_result1251 is not None: + assert deconstruct_result1251 is not None + unwrapped1252 = deconstruct_result1251 + self.pretty_instruction(unwrapped1252) else: raise ParseError("No matching rule for construct") def pretty_loop(self, msg: logic_pb2.Loop): - flat1252 = self._try_flat(msg, self.pretty_loop) - if flat1252 is not None: - assert flat1252 is not None - self.write(flat1252) + flat1262 = self._try_flat(msg, self.pretty_loop) + if flat1262 is not None: + assert flat1262 is not None + self.write(flat1262) return None else: _dollar_dollar = msg if not len(_dollar_dollar.attrs) == 0: - _t1696 = _dollar_dollar.attrs + _t1716 = _dollar_dollar.attrs else: - _t1696 = None - fields1246 = (_dollar_dollar.init, _dollar_dollar.body, _t1696,) - assert fields1246 is not None - unwrapped_fields1247 = fields1246 + _t1716 = None + fields1256 = (_dollar_dollar.init, _dollar_dollar.body, _t1716,) + assert fields1256 is not None + unwrapped_fields1257 = fields1256 self.write("(loop") self.indent_sexp() self.newline() - field1248 = unwrapped_fields1247[0] - self.pretty_init(field1248) + field1258 = unwrapped_fields1257[0] + self.pretty_init(field1258) self.newline() - field1249 = unwrapped_fields1247[1] - self.pretty_script(field1249) - field1250 = unwrapped_fields1247[2] - if field1250 is not None: + field1259 = unwrapped_fields1257[1] + self.pretty_script(field1259) + field1260 = unwrapped_fields1257[2] + if field1260 is not None: self.newline() - assert field1250 is not None - opt_val1251 = field1250 - self.pretty_attrs(opt_val1251) + assert field1260 is not None + opt_val1261 = field1260 + self.pretty_attrs(opt_val1261) self.dedent() self.write(")") def pretty_init(self, msg: Sequence[logic_pb2.Instruction]): - flat1256 = self._try_flat(msg, self.pretty_init) - if flat1256 is not None: - assert flat1256 is not None - self.write(flat1256) + flat1266 = self._try_flat(msg, self.pretty_init) + if flat1266 is not None: + assert flat1266 is not None + self.write(flat1266) return None else: - fields1253 = msg + fields1263 = msg self.write("(init") self.indent_sexp() - if not len(fields1253) == 0: + if not len(fields1263) == 0: self.newline() - for i1255, elem1254 in enumerate(fields1253): - if (i1255 > 0): + for i1265, elem1264 in enumerate(fields1263): + if (i1265 > 0): self.newline() - self.pretty_instruction(elem1254) + self.pretty_instruction(elem1264) self.dedent() self.write(")") def pretty_instruction(self, msg: logic_pb2.Instruction): - flat1267 = self._try_flat(msg, self.pretty_instruction) - if flat1267 is not None: - assert flat1267 is not None - self.write(flat1267) + flat1277 = self._try_flat(msg, self.pretty_instruction) + if flat1277 is not None: + assert flat1277 is not None + self.write(flat1277) return None else: _dollar_dollar = msg if _dollar_dollar.HasField("assign"): - _t1697 = _dollar_dollar.assign + _t1717 = _dollar_dollar.assign else: - _t1697 = None - deconstruct_result1265 = _t1697 - if deconstruct_result1265 is not None: - assert deconstruct_result1265 is not None - unwrapped1266 = deconstruct_result1265 - self.pretty_assign(unwrapped1266) + _t1717 = None + deconstruct_result1275 = _t1717 + if deconstruct_result1275 is not None: + assert deconstruct_result1275 is not None + unwrapped1276 = deconstruct_result1275 + self.pretty_assign(unwrapped1276) else: _dollar_dollar = msg if _dollar_dollar.HasField("upsert"): - _t1698 = _dollar_dollar.upsert + _t1718 = _dollar_dollar.upsert else: - _t1698 = None - deconstruct_result1263 = _t1698 - if deconstruct_result1263 is not None: - assert deconstruct_result1263 is not None - unwrapped1264 = deconstruct_result1263 - self.pretty_upsert(unwrapped1264) + _t1718 = None + deconstruct_result1273 = _t1718 + if deconstruct_result1273 is not None: + assert deconstruct_result1273 is not None + unwrapped1274 = deconstruct_result1273 + self.pretty_upsert(unwrapped1274) else: _dollar_dollar = msg if _dollar_dollar.HasField("break"): - _t1699 = getattr(_dollar_dollar, 'break') + _t1719 = getattr(_dollar_dollar, 'break') else: - _t1699 = None - deconstruct_result1261 = _t1699 - if deconstruct_result1261 is not None: - assert deconstruct_result1261 is not None - unwrapped1262 = deconstruct_result1261 - self.pretty_break(unwrapped1262) + _t1719 = None + deconstruct_result1271 = _t1719 + if deconstruct_result1271 is not None: + assert deconstruct_result1271 is not None + unwrapped1272 = deconstruct_result1271 + self.pretty_break(unwrapped1272) else: _dollar_dollar = msg if _dollar_dollar.HasField("monoid_def"): - _t1700 = _dollar_dollar.monoid_def + _t1720 = _dollar_dollar.monoid_def else: - _t1700 = None - deconstruct_result1259 = _t1700 - if deconstruct_result1259 is not None: - assert deconstruct_result1259 is not None - unwrapped1260 = deconstruct_result1259 - self.pretty_monoid_def(unwrapped1260) + _t1720 = None + deconstruct_result1269 = _t1720 + if deconstruct_result1269 is not None: + assert deconstruct_result1269 is not None + unwrapped1270 = deconstruct_result1269 + self.pretty_monoid_def(unwrapped1270) else: _dollar_dollar = msg if _dollar_dollar.HasField("monus_def"): - _t1701 = _dollar_dollar.monus_def + _t1721 = _dollar_dollar.monus_def else: - _t1701 = None - deconstruct_result1257 = _t1701 - if deconstruct_result1257 is not None: - assert deconstruct_result1257 is not None - unwrapped1258 = deconstruct_result1257 - self.pretty_monus_def(unwrapped1258) + _t1721 = None + deconstruct_result1267 = _t1721 + if deconstruct_result1267 is not None: + assert deconstruct_result1267 is not None + unwrapped1268 = deconstruct_result1267 + self.pretty_monus_def(unwrapped1268) else: raise ParseError("No matching rule for instruction") def pretty_assign(self, msg: logic_pb2.Assign): - flat1274 = self._try_flat(msg, self.pretty_assign) - if flat1274 is not None: - assert flat1274 is not None - self.write(flat1274) + flat1284 = self._try_flat(msg, self.pretty_assign) + if flat1284 is not None: + assert flat1284 is not None + self.write(flat1284) return None else: _dollar_dollar = msg if not len(_dollar_dollar.attrs) == 0: - _t1702 = _dollar_dollar.attrs + _t1722 = _dollar_dollar.attrs else: - _t1702 = None - fields1268 = (_dollar_dollar.name, _dollar_dollar.body, _t1702,) - assert fields1268 is not None - unwrapped_fields1269 = fields1268 + _t1722 = None + fields1278 = (_dollar_dollar.name, _dollar_dollar.body, _t1722,) + assert fields1278 is not None + unwrapped_fields1279 = fields1278 self.write("(assign") self.indent_sexp() self.newline() - field1270 = unwrapped_fields1269[0] - self.pretty_relation_id(field1270) + field1280 = unwrapped_fields1279[0] + self.pretty_relation_id(field1280) self.newline() - field1271 = unwrapped_fields1269[1] - self.pretty_abstraction(field1271) - field1272 = unwrapped_fields1269[2] - if field1272 is not None: + field1281 = unwrapped_fields1279[1] + self.pretty_abstraction(field1281) + field1282 = unwrapped_fields1279[2] + if field1282 is not None: self.newline() - assert field1272 is not None - opt_val1273 = field1272 - self.pretty_attrs(opt_val1273) + assert field1282 is not None + opt_val1283 = field1282 + self.pretty_attrs(opt_val1283) self.dedent() self.write(")") def pretty_upsert(self, msg: logic_pb2.Upsert): - flat1281 = self._try_flat(msg, self.pretty_upsert) - if flat1281 is not None: - assert flat1281 is not None - self.write(flat1281) + flat1291 = self._try_flat(msg, self.pretty_upsert) + if flat1291 is not None: + assert flat1291 is not None + self.write(flat1291) return None else: _dollar_dollar = msg if not len(_dollar_dollar.attrs) == 0: - _t1703 = _dollar_dollar.attrs + _t1723 = _dollar_dollar.attrs else: - _t1703 = None - fields1275 = (_dollar_dollar.name, (_dollar_dollar.body, _dollar_dollar.value_arity,), _t1703,) - assert fields1275 is not None - unwrapped_fields1276 = fields1275 + _t1723 = None + fields1285 = (_dollar_dollar.name, (_dollar_dollar.body, _dollar_dollar.value_arity,), _t1723,) + assert fields1285 is not None + unwrapped_fields1286 = fields1285 self.write("(upsert") self.indent_sexp() self.newline() - field1277 = unwrapped_fields1276[0] - self.pretty_relation_id(field1277) + field1287 = unwrapped_fields1286[0] + self.pretty_relation_id(field1287) self.newline() - field1278 = unwrapped_fields1276[1] - self.pretty_abstraction_with_arity(field1278) - field1279 = unwrapped_fields1276[2] - if field1279 is not None: + field1288 = unwrapped_fields1286[1] + self.pretty_abstraction_with_arity(field1288) + field1289 = unwrapped_fields1286[2] + if field1289 is not None: self.newline() - assert field1279 is not None - opt_val1280 = field1279 - self.pretty_attrs(opt_val1280) + assert field1289 is not None + opt_val1290 = field1289 + self.pretty_attrs(opt_val1290) self.dedent() self.write(")") def pretty_abstraction_with_arity(self, msg: tuple[logic_pb2.Abstraction, int]): - flat1286 = self._try_flat(msg, self.pretty_abstraction_with_arity) - if flat1286 is not None: - assert flat1286 is not None - self.write(flat1286) + flat1296 = self._try_flat(msg, self.pretty_abstraction_with_arity) + if flat1296 is not None: + assert flat1296 is not None + self.write(flat1296) return None else: _dollar_dollar = msg - _t1704 = self.deconstruct_bindings_with_arity(_dollar_dollar[0], _dollar_dollar[1]) - fields1282 = (_t1704, _dollar_dollar[0].value,) - assert fields1282 is not None - unwrapped_fields1283 = fields1282 + _t1724 = self.deconstruct_bindings_with_arity(_dollar_dollar[0], _dollar_dollar[1]) + fields1292 = (_t1724, _dollar_dollar[0].value,) + assert fields1292 is not None + unwrapped_fields1293 = fields1292 self.write("(") self.indent() - field1284 = unwrapped_fields1283[0] - self.pretty_bindings(field1284) + field1294 = unwrapped_fields1293[0] + self.pretty_bindings(field1294) self.newline() - field1285 = unwrapped_fields1283[1] - self.pretty_formula(field1285) + field1295 = unwrapped_fields1293[1] + self.pretty_formula(field1295) self.dedent() self.write(")") def pretty_break(self, msg: logic_pb2.Break): - flat1293 = self._try_flat(msg, self.pretty_break) - if flat1293 is not None: - assert flat1293 is not None - self.write(flat1293) + flat1303 = self._try_flat(msg, self.pretty_break) + if flat1303 is not None: + assert flat1303 is not None + self.write(flat1303) return None else: _dollar_dollar = msg if not len(_dollar_dollar.attrs) == 0: - _t1705 = _dollar_dollar.attrs + _t1725 = _dollar_dollar.attrs else: - _t1705 = None - fields1287 = (_dollar_dollar.name, _dollar_dollar.body, _t1705,) - assert fields1287 is not None - unwrapped_fields1288 = fields1287 + _t1725 = None + fields1297 = (_dollar_dollar.name, _dollar_dollar.body, _t1725,) + assert fields1297 is not None + unwrapped_fields1298 = fields1297 self.write("(break") self.indent_sexp() self.newline() - field1289 = unwrapped_fields1288[0] - self.pretty_relation_id(field1289) + field1299 = unwrapped_fields1298[0] + self.pretty_relation_id(field1299) self.newline() - field1290 = unwrapped_fields1288[1] - self.pretty_abstraction(field1290) - field1291 = unwrapped_fields1288[2] - if field1291 is not None: + field1300 = unwrapped_fields1298[1] + self.pretty_abstraction(field1300) + field1301 = unwrapped_fields1298[2] + if field1301 is not None: self.newline() - assert field1291 is not None - opt_val1292 = field1291 - self.pretty_attrs(opt_val1292) + assert field1301 is not None + opt_val1302 = field1301 + self.pretty_attrs(opt_val1302) self.dedent() self.write(")") def pretty_monoid_def(self, msg: logic_pb2.MonoidDef): - flat1301 = self._try_flat(msg, self.pretty_monoid_def) - if flat1301 is not None: - assert flat1301 is not None - self.write(flat1301) + flat1311 = self._try_flat(msg, self.pretty_monoid_def) + if flat1311 is not None: + assert flat1311 is not None + self.write(flat1311) return None else: _dollar_dollar = msg if not len(_dollar_dollar.attrs) == 0: - _t1706 = _dollar_dollar.attrs + _t1726 = _dollar_dollar.attrs else: - _t1706 = None - fields1294 = (_dollar_dollar.monoid, _dollar_dollar.name, (_dollar_dollar.body, _dollar_dollar.value_arity,), _t1706,) - assert fields1294 is not None - unwrapped_fields1295 = fields1294 + _t1726 = None + fields1304 = (_dollar_dollar.monoid, _dollar_dollar.name, (_dollar_dollar.body, _dollar_dollar.value_arity,), _t1726,) + assert fields1304 is not None + unwrapped_fields1305 = fields1304 self.write("(monoid") self.indent_sexp() self.newline() - field1296 = unwrapped_fields1295[0] - self.pretty_monoid(field1296) + field1306 = unwrapped_fields1305[0] + self.pretty_monoid(field1306) self.newline() - field1297 = unwrapped_fields1295[1] - self.pretty_relation_id(field1297) + field1307 = unwrapped_fields1305[1] + self.pretty_relation_id(field1307) self.newline() - field1298 = unwrapped_fields1295[2] - self.pretty_abstraction_with_arity(field1298) - field1299 = unwrapped_fields1295[3] - if field1299 is not None: + field1308 = unwrapped_fields1305[2] + self.pretty_abstraction_with_arity(field1308) + field1309 = unwrapped_fields1305[3] + if field1309 is not None: self.newline() - assert field1299 is not None - opt_val1300 = field1299 - self.pretty_attrs(opt_val1300) + assert field1309 is not None + opt_val1310 = field1309 + self.pretty_attrs(opt_val1310) self.dedent() self.write(")") def pretty_monoid(self, msg: logic_pb2.Monoid): - flat1310 = self._try_flat(msg, self.pretty_monoid) - if flat1310 is not None: - assert flat1310 is not None - self.write(flat1310) + flat1320 = self._try_flat(msg, self.pretty_monoid) + if flat1320 is not None: + assert flat1320 is not None + self.write(flat1320) return None else: _dollar_dollar = msg if _dollar_dollar.HasField("or_monoid"): - _t1707 = _dollar_dollar.or_monoid + _t1727 = _dollar_dollar.or_monoid else: - _t1707 = None - deconstruct_result1308 = _t1707 - if deconstruct_result1308 is not None: - assert deconstruct_result1308 is not None - unwrapped1309 = deconstruct_result1308 - self.pretty_or_monoid(unwrapped1309) + _t1727 = None + deconstruct_result1318 = _t1727 + if deconstruct_result1318 is not None: + assert deconstruct_result1318 is not None + unwrapped1319 = deconstruct_result1318 + self.pretty_or_monoid(unwrapped1319) else: _dollar_dollar = msg if _dollar_dollar.HasField("min_monoid"): - _t1708 = _dollar_dollar.min_monoid + _t1728 = _dollar_dollar.min_monoid else: - _t1708 = None - deconstruct_result1306 = _t1708 - if deconstruct_result1306 is not None: - assert deconstruct_result1306 is not None - unwrapped1307 = deconstruct_result1306 - self.pretty_min_monoid(unwrapped1307) + _t1728 = None + deconstruct_result1316 = _t1728 + if deconstruct_result1316 is not None: + assert deconstruct_result1316 is not None + unwrapped1317 = deconstruct_result1316 + self.pretty_min_monoid(unwrapped1317) else: _dollar_dollar = msg if _dollar_dollar.HasField("max_monoid"): - _t1709 = _dollar_dollar.max_monoid + _t1729 = _dollar_dollar.max_monoid else: - _t1709 = None - deconstruct_result1304 = _t1709 - if deconstruct_result1304 is not None: - assert deconstruct_result1304 is not None - unwrapped1305 = deconstruct_result1304 - self.pretty_max_monoid(unwrapped1305) + _t1729 = None + deconstruct_result1314 = _t1729 + if deconstruct_result1314 is not None: + assert deconstruct_result1314 is not None + unwrapped1315 = deconstruct_result1314 + self.pretty_max_monoid(unwrapped1315) else: _dollar_dollar = msg if _dollar_dollar.HasField("sum_monoid"): - _t1710 = _dollar_dollar.sum_monoid + _t1730 = _dollar_dollar.sum_monoid else: - _t1710 = None - deconstruct_result1302 = _t1710 - if deconstruct_result1302 is not None: - assert deconstruct_result1302 is not None - unwrapped1303 = deconstruct_result1302 - self.pretty_sum_monoid(unwrapped1303) + _t1730 = None + deconstruct_result1312 = _t1730 + if deconstruct_result1312 is not None: + assert deconstruct_result1312 is not None + unwrapped1313 = deconstruct_result1312 + self.pretty_sum_monoid(unwrapped1313) else: raise ParseError("No matching rule for monoid") def pretty_or_monoid(self, msg: logic_pb2.OrMonoid): - fields1311 = msg + fields1321 = msg self.write("(or)") def pretty_min_monoid(self, msg: logic_pb2.MinMonoid): - flat1314 = self._try_flat(msg, self.pretty_min_monoid) - if flat1314 is not None: - assert flat1314 is not None - self.write(flat1314) + flat1324 = self._try_flat(msg, self.pretty_min_monoid) + if flat1324 is not None: + assert flat1324 is not None + self.write(flat1324) return None else: _dollar_dollar = msg - fields1312 = _dollar_dollar.type - assert fields1312 is not None - unwrapped_fields1313 = fields1312 + fields1322 = _dollar_dollar.type + assert fields1322 is not None + unwrapped_fields1323 = fields1322 self.write("(min") self.indent_sexp() self.newline() - self.pretty_type(unwrapped_fields1313) + self.pretty_type(unwrapped_fields1323) self.dedent() self.write(")") def pretty_max_monoid(self, msg: logic_pb2.MaxMonoid): - flat1317 = self._try_flat(msg, self.pretty_max_monoid) - if flat1317 is not None: - assert flat1317 is not None - self.write(flat1317) + flat1327 = self._try_flat(msg, self.pretty_max_monoid) + if flat1327 is not None: + assert flat1327 is not None + self.write(flat1327) return None else: _dollar_dollar = msg - fields1315 = _dollar_dollar.type - assert fields1315 is not None - unwrapped_fields1316 = fields1315 + fields1325 = _dollar_dollar.type + assert fields1325 is not None + unwrapped_fields1326 = fields1325 self.write("(max") self.indent_sexp() self.newline() - self.pretty_type(unwrapped_fields1316) + self.pretty_type(unwrapped_fields1326) self.dedent() self.write(")") def pretty_sum_monoid(self, msg: logic_pb2.SumMonoid): - flat1320 = self._try_flat(msg, self.pretty_sum_monoid) - if flat1320 is not None: - assert flat1320 is not None - self.write(flat1320) + flat1330 = self._try_flat(msg, self.pretty_sum_monoid) + if flat1330 is not None: + assert flat1330 is not None + self.write(flat1330) return None else: _dollar_dollar = msg - fields1318 = _dollar_dollar.type - assert fields1318 is not None - unwrapped_fields1319 = fields1318 + fields1328 = _dollar_dollar.type + assert fields1328 is not None + unwrapped_fields1329 = fields1328 self.write("(sum") self.indent_sexp() self.newline() - self.pretty_type(unwrapped_fields1319) + self.pretty_type(unwrapped_fields1329) self.dedent() self.write(")") def pretty_monus_def(self, msg: logic_pb2.MonusDef): - flat1328 = self._try_flat(msg, self.pretty_monus_def) - if flat1328 is not None: - assert flat1328 is not None - self.write(flat1328) + flat1338 = self._try_flat(msg, self.pretty_monus_def) + if flat1338 is not None: + assert flat1338 is not None + self.write(flat1338) return None else: _dollar_dollar = msg if not len(_dollar_dollar.attrs) == 0: - _t1711 = _dollar_dollar.attrs + _t1731 = _dollar_dollar.attrs else: - _t1711 = None - fields1321 = (_dollar_dollar.monoid, _dollar_dollar.name, (_dollar_dollar.body, _dollar_dollar.value_arity,), _t1711,) - assert fields1321 is not None - unwrapped_fields1322 = fields1321 + _t1731 = None + fields1331 = (_dollar_dollar.monoid, _dollar_dollar.name, (_dollar_dollar.body, _dollar_dollar.value_arity,), _t1731,) + assert fields1331 is not None + unwrapped_fields1332 = fields1331 self.write("(monus") self.indent_sexp() self.newline() - field1323 = unwrapped_fields1322[0] - self.pretty_monoid(field1323) + field1333 = unwrapped_fields1332[0] + self.pretty_monoid(field1333) self.newline() - field1324 = unwrapped_fields1322[1] - self.pretty_relation_id(field1324) + field1334 = unwrapped_fields1332[1] + self.pretty_relation_id(field1334) self.newline() - field1325 = unwrapped_fields1322[2] - self.pretty_abstraction_with_arity(field1325) - field1326 = unwrapped_fields1322[3] - if field1326 is not None: + field1335 = unwrapped_fields1332[2] + self.pretty_abstraction_with_arity(field1335) + field1336 = unwrapped_fields1332[3] + if field1336 is not None: self.newline() - assert field1326 is not None - opt_val1327 = field1326 - self.pretty_attrs(opt_val1327) + assert field1336 is not None + opt_val1337 = field1336 + self.pretty_attrs(opt_val1337) self.dedent() self.write(")") def pretty_constraint(self, msg: logic_pb2.Constraint): - flat1335 = self._try_flat(msg, self.pretty_constraint) - if flat1335 is not None: - assert flat1335 is not None - self.write(flat1335) + flat1345 = self._try_flat(msg, self.pretty_constraint) + if flat1345 is not None: + assert flat1345 is not None + self.write(flat1345) return None else: _dollar_dollar = msg - fields1329 = (_dollar_dollar.name, _dollar_dollar.functional_dependency.guard, _dollar_dollar.functional_dependency.keys, _dollar_dollar.functional_dependency.values,) - assert fields1329 is not None - unwrapped_fields1330 = fields1329 + fields1339 = (_dollar_dollar.name, _dollar_dollar.functional_dependency.guard, _dollar_dollar.functional_dependency.keys, _dollar_dollar.functional_dependency.values,) + assert fields1339 is not None + unwrapped_fields1340 = fields1339 self.write("(functional_dependency") self.indent_sexp() self.newline() - field1331 = unwrapped_fields1330[0] - self.pretty_relation_id(field1331) + field1341 = unwrapped_fields1340[0] + self.pretty_relation_id(field1341) self.newline() - field1332 = unwrapped_fields1330[1] - self.pretty_abstraction(field1332) + field1342 = unwrapped_fields1340[1] + self.pretty_abstraction(field1342) self.newline() - field1333 = unwrapped_fields1330[2] - self.pretty_functional_dependency_keys(field1333) + field1343 = unwrapped_fields1340[2] + self.pretty_functional_dependency_keys(field1343) self.newline() - field1334 = unwrapped_fields1330[3] - self.pretty_functional_dependency_values(field1334) + field1344 = unwrapped_fields1340[3] + self.pretty_functional_dependency_values(field1344) self.dedent() self.write(")") def pretty_functional_dependency_keys(self, msg: Sequence[logic_pb2.Var]): - flat1339 = self._try_flat(msg, self.pretty_functional_dependency_keys) - if flat1339 is not None: - assert flat1339 is not None - self.write(flat1339) + flat1349 = self._try_flat(msg, self.pretty_functional_dependency_keys) + if flat1349 is not None: + assert flat1349 is not None + self.write(flat1349) return None else: - fields1336 = msg + fields1346 = msg self.write("(keys") self.indent_sexp() - if not len(fields1336) == 0: + if not len(fields1346) == 0: self.newline() - for i1338, elem1337 in enumerate(fields1336): - if (i1338 > 0): + for i1348, elem1347 in enumerate(fields1346): + if (i1348 > 0): self.newline() - self.pretty_var(elem1337) + self.pretty_var(elem1347) self.dedent() self.write(")") def pretty_functional_dependency_values(self, msg: Sequence[logic_pb2.Var]): - flat1343 = self._try_flat(msg, self.pretty_functional_dependency_values) - if flat1343 is not None: - assert flat1343 is not None - self.write(flat1343) + flat1353 = self._try_flat(msg, self.pretty_functional_dependency_values) + if flat1353 is not None: + assert flat1353 is not None + self.write(flat1353) return None else: - fields1340 = msg + fields1350 = msg self.write("(values") self.indent_sexp() - if not len(fields1340) == 0: + if not len(fields1350) == 0: self.newline() - for i1342, elem1341 in enumerate(fields1340): - if (i1342 > 0): + for i1352, elem1351 in enumerate(fields1350): + if (i1352 > 0): self.newline() - self.pretty_var(elem1341) + self.pretty_var(elem1351) self.dedent() self.write(")") def pretty_data(self, msg: logic_pb2.Data): - flat1352 = self._try_flat(msg, self.pretty_data) - if flat1352 is not None: - assert flat1352 is not None - self.write(flat1352) + flat1362 = self._try_flat(msg, self.pretty_data) + if flat1362 is not None: + assert flat1362 is not None + self.write(flat1362) return None else: _dollar_dollar = msg if _dollar_dollar.HasField("edb"): - _t1712 = _dollar_dollar.edb + _t1732 = _dollar_dollar.edb else: - _t1712 = None - deconstruct_result1350 = _t1712 - if deconstruct_result1350 is not None: - assert deconstruct_result1350 is not None - unwrapped1351 = deconstruct_result1350 - self.pretty_edb(unwrapped1351) + _t1732 = None + deconstruct_result1360 = _t1732 + if deconstruct_result1360 is not None: + assert deconstruct_result1360 is not None + unwrapped1361 = deconstruct_result1360 + self.pretty_edb(unwrapped1361) else: _dollar_dollar = msg if _dollar_dollar.HasField("betree_relation"): - _t1713 = _dollar_dollar.betree_relation + _t1733 = _dollar_dollar.betree_relation else: - _t1713 = None - deconstruct_result1348 = _t1713 - if deconstruct_result1348 is not None: - assert deconstruct_result1348 is not None - unwrapped1349 = deconstruct_result1348 - self.pretty_betree_relation(unwrapped1349) + _t1733 = None + deconstruct_result1358 = _t1733 + if deconstruct_result1358 is not None: + assert deconstruct_result1358 is not None + unwrapped1359 = deconstruct_result1358 + self.pretty_betree_relation(unwrapped1359) else: _dollar_dollar = msg if _dollar_dollar.HasField("csv_data"): - _t1714 = _dollar_dollar.csv_data + _t1734 = _dollar_dollar.csv_data else: - _t1714 = None - deconstruct_result1346 = _t1714 - if deconstruct_result1346 is not None: - assert deconstruct_result1346 is not None - unwrapped1347 = deconstruct_result1346 - self.pretty_csv_data(unwrapped1347) + _t1734 = None + deconstruct_result1356 = _t1734 + if deconstruct_result1356 is not None: + assert deconstruct_result1356 is not None + unwrapped1357 = deconstruct_result1356 + self.pretty_csv_data(unwrapped1357) else: _dollar_dollar = msg if _dollar_dollar.HasField("iceberg_data"): - _t1715 = _dollar_dollar.iceberg_data + _t1735 = _dollar_dollar.iceberg_data else: - _t1715 = None - deconstruct_result1344 = _t1715 - if deconstruct_result1344 is not None: - assert deconstruct_result1344 is not None - unwrapped1345 = deconstruct_result1344 - self.pretty_iceberg_data(unwrapped1345) + _t1735 = None + deconstruct_result1354 = _t1735 + if deconstruct_result1354 is not None: + assert deconstruct_result1354 is not None + unwrapped1355 = deconstruct_result1354 + self.pretty_iceberg_data(unwrapped1355) else: raise ParseError("No matching rule for data") def pretty_edb(self, msg: logic_pb2.EDB): - flat1358 = self._try_flat(msg, self.pretty_edb) - if flat1358 is not None: - assert flat1358 is not None - self.write(flat1358) + flat1368 = self._try_flat(msg, self.pretty_edb) + if flat1368 is not None: + assert flat1368 is not None + self.write(flat1368) return None else: _dollar_dollar = msg - fields1353 = (_dollar_dollar.target_id, _dollar_dollar.path, _dollar_dollar.types,) - assert fields1353 is not None - unwrapped_fields1354 = fields1353 + fields1363 = (_dollar_dollar.target_id, _dollar_dollar.path, _dollar_dollar.types,) + assert fields1363 is not None + unwrapped_fields1364 = fields1363 self.write("(edb") self.indent_sexp() self.newline() - field1355 = unwrapped_fields1354[0] - self.pretty_relation_id(field1355) + field1365 = unwrapped_fields1364[0] + self.pretty_relation_id(field1365) self.newline() - field1356 = unwrapped_fields1354[1] - self.pretty_edb_path(field1356) + field1366 = unwrapped_fields1364[1] + self.pretty_edb_path(field1366) self.newline() - field1357 = unwrapped_fields1354[2] - self.pretty_edb_types(field1357) + field1367 = unwrapped_fields1364[2] + self.pretty_edb_types(field1367) self.dedent() self.write(")") def pretty_edb_path(self, msg: Sequence[str]): - flat1362 = self._try_flat(msg, self.pretty_edb_path) - if flat1362 is not None: - assert flat1362 is not None - self.write(flat1362) + flat1372 = self._try_flat(msg, self.pretty_edb_path) + if flat1372 is not None: + assert flat1372 is not None + self.write(flat1372) return None else: - fields1359 = msg + fields1369 = msg self.write("[") self.indent() - for i1361, elem1360 in enumerate(fields1359): - if (i1361 > 0): + for i1371, elem1370 in enumerate(fields1369): + if (i1371 > 0): self.newline() - self.write(self.format_string_value(elem1360)) + self.write(self.format_string_value(elem1370)) self.dedent() self.write("]") def pretty_edb_types(self, msg: Sequence[logic_pb2.Type]): - flat1366 = self._try_flat(msg, self.pretty_edb_types) - if flat1366 is not None: - assert flat1366 is not None - self.write(flat1366) + flat1376 = self._try_flat(msg, self.pretty_edb_types) + if flat1376 is not None: + assert flat1376 is not None + self.write(flat1376) return None else: - fields1363 = msg + fields1373 = msg self.write("[") self.indent() - for i1365, elem1364 in enumerate(fields1363): - if (i1365 > 0): + for i1375, elem1374 in enumerate(fields1373): + if (i1375 > 0): self.newline() - self.pretty_type(elem1364) + self.pretty_type(elem1374) self.dedent() self.write("]") def pretty_betree_relation(self, msg: logic_pb2.BeTreeRelation): - flat1371 = self._try_flat(msg, self.pretty_betree_relation) - if flat1371 is not None: - assert flat1371 is not None - self.write(flat1371) + flat1381 = self._try_flat(msg, self.pretty_betree_relation) + if flat1381 is not None: + assert flat1381 is not None + self.write(flat1381) return None else: _dollar_dollar = msg - fields1367 = (_dollar_dollar.name, _dollar_dollar.relation_info,) - assert fields1367 is not None - unwrapped_fields1368 = fields1367 + fields1377 = (_dollar_dollar.name, _dollar_dollar.relation_info,) + assert fields1377 is not None + unwrapped_fields1378 = fields1377 self.write("(betree_relation") self.indent_sexp() self.newline() - field1369 = unwrapped_fields1368[0] - self.pretty_relation_id(field1369) + field1379 = unwrapped_fields1378[0] + self.pretty_relation_id(field1379) self.newline() - field1370 = unwrapped_fields1368[1] - self.pretty_betree_info(field1370) + field1380 = unwrapped_fields1378[1] + self.pretty_betree_info(field1380) self.dedent() self.write(")") def pretty_betree_info(self, msg: logic_pb2.BeTreeInfo): - flat1377 = self._try_flat(msg, self.pretty_betree_info) - if flat1377 is not None: - assert flat1377 is not None - self.write(flat1377) + flat1387 = self._try_flat(msg, self.pretty_betree_info) + if flat1387 is not None: + assert flat1387 is not None + self.write(flat1387) return None else: _dollar_dollar = msg - _t1716 = self.deconstruct_betree_info_config(_dollar_dollar) - fields1372 = (_dollar_dollar.key_types, _dollar_dollar.value_types, _t1716,) - assert fields1372 is not None - unwrapped_fields1373 = fields1372 + _t1736 = self.deconstruct_betree_info_config(_dollar_dollar) + fields1382 = (_dollar_dollar.key_types, _dollar_dollar.value_types, _t1736,) + assert fields1382 is not None + unwrapped_fields1383 = fields1382 self.write("(betree_info") self.indent_sexp() self.newline() - field1374 = unwrapped_fields1373[0] - self.pretty_betree_info_key_types(field1374) + field1384 = unwrapped_fields1383[0] + self.pretty_betree_info_key_types(field1384) self.newline() - field1375 = unwrapped_fields1373[1] - self.pretty_betree_info_value_types(field1375) + field1385 = unwrapped_fields1383[1] + self.pretty_betree_info_value_types(field1385) self.newline() - field1376 = unwrapped_fields1373[2] - self.pretty_config_dict(field1376) + field1386 = unwrapped_fields1383[2] + self.pretty_config_dict(field1386) self.dedent() self.write(")") def pretty_betree_info_key_types(self, msg: Sequence[logic_pb2.Type]): - flat1381 = self._try_flat(msg, self.pretty_betree_info_key_types) - if flat1381 is not None: - assert flat1381 is not None - self.write(flat1381) + flat1391 = self._try_flat(msg, self.pretty_betree_info_key_types) + if flat1391 is not None: + assert flat1391 is not None + self.write(flat1391) return None else: - fields1378 = msg + fields1388 = msg self.write("(key_types") self.indent_sexp() - if not len(fields1378) == 0: + if not len(fields1388) == 0: self.newline() - for i1380, elem1379 in enumerate(fields1378): - if (i1380 > 0): + for i1390, elem1389 in enumerate(fields1388): + if (i1390 > 0): self.newline() - self.pretty_type(elem1379) + self.pretty_type(elem1389) self.dedent() self.write(")") def pretty_betree_info_value_types(self, msg: Sequence[logic_pb2.Type]): - flat1385 = self._try_flat(msg, self.pretty_betree_info_value_types) - if flat1385 is not None: - assert flat1385 is not None - self.write(flat1385) + flat1395 = self._try_flat(msg, self.pretty_betree_info_value_types) + if flat1395 is not None: + assert flat1395 is not None + self.write(flat1395) return None else: - fields1382 = msg + fields1392 = msg self.write("(value_types") self.indent_sexp() - if not len(fields1382) == 0: + if not len(fields1392) == 0: self.newline() - for i1384, elem1383 in enumerate(fields1382): - if (i1384 > 0): + for i1394, elem1393 in enumerate(fields1392): + if (i1394 > 0): self.newline() - self.pretty_type(elem1383) + self.pretty_type(elem1393) self.dedent() self.write(")") def pretty_csv_data(self, msg: logic_pb2.CSVData): - flat1392 = self._try_flat(msg, self.pretty_csv_data) - if flat1392 is not None: - assert flat1392 is not None - self.write(flat1392) + flat1402 = self._try_flat(msg, self.pretty_csv_data) + if flat1402 is not None: + assert flat1402 is not None + self.write(flat1402) return None else: _dollar_dollar = msg - fields1386 = (_dollar_dollar.locator, _dollar_dollar.config, _dollar_dollar.columns, _dollar_dollar.asof,) - assert fields1386 is not None - unwrapped_fields1387 = fields1386 + fields1396 = (_dollar_dollar.locator, _dollar_dollar.config, _dollar_dollar.columns, _dollar_dollar.asof,) + assert fields1396 is not None + unwrapped_fields1397 = fields1396 self.write("(csv_data") self.indent_sexp() self.newline() - field1388 = unwrapped_fields1387[0] - self.pretty_csvlocator(field1388) + field1398 = unwrapped_fields1397[0] + self.pretty_csvlocator(field1398) self.newline() - field1389 = unwrapped_fields1387[1] - self.pretty_csv_config(field1389) + field1399 = unwrapped_fields1397[1] + self.pretty_csv_config(field1399) self.newline() - field1390 = unwrapped_fields1387[2] - self.pretty_gnf_columns(field1390) + field1400 = unwrapped_fields1397[2] + self.pretty_gnf_columns(field1400) self.newline() - field1391 = unwrapped_fields1387[3] - self.pretty_csv_asof(field1391) + field1401 = unwrapped_fields1397[3] + self.pretty_csv_asof(field1401) self.dedent() self.write(")") def pretty_csvlocator(self, msg: logic_pb2.CSVLocator): - flat1399 = self._try_flat(msg, self.pretty_csvlocator) - if flat1399 is not None: - assert flat1399 is not None - self.write(flat1399) + flat1409 = self._try_flat(msg, self.pretty_csvlocator) + if flat1409 is not None: + assert flat1409 is not None + self.write(flat1409) return None else: _dollar_dollar = msg if not len(_dollar_dollar.paths) == 0: - _t1717 = _dollar_dollar.paths + _t1737 = _dollar_dollar.paths else: - _t1717 = None + _t1737 = None if _dollar_dollar.inline_data.decode('utf-8') != "": - _t1718 = _dollar_dollar.inline_data.decode('utf-8') + _t1738 = _dollar_dollar.inline_data.decode('utf-8') else: - _t1718 = None - fields1393 = (_t1717, _t1718,) - assert fields1393 is not None - unwrapped_fields1394 = fields1393 + _t1738 = None + fields1403 = (_t1737, _t1738,) + assert fields1403 is not None + unwrapped_fields1404 = fields1403 self.write("(csv_locator") self.indent_sexp() - field1395 = unwrapped_fields1394[0] - if field1395 is not None: + field1405 = unwrapped_fields1404[0] + if field1405 is not None: self.newline() - assert field1395 is not None - opt_val1396 = field1395 - self.pretty_csv_locator_paths(opt_val1396) - field1397 = unwrapped_fields1394[1] - if field1397 is not None: + assert field1405 is not None + opt_val1406 = field1405 + self.pretty_csv_locator_paths(opt_val1406) + field1407 = unwrapped_fields1404[1] + if field1407 is not None: self.newline() - assert field1397 is not None - opt_val1398 = field1397 - self.pretty_csv_locator_inline_data(opt_val1398) + assert field1407 is not None + opt_val1408 = field1407 + self.pretty_csv_locator_inline_data(opt_val1408) self.dedent() self.write(")") def pretty_csv_locator_paths(self, msg: Sequence[str]): - flat1403 = self._try_flat(msg, self.pretty_csv_locator_paths) - if flat1403 is not None: - assert flat1403 is not None - self.write(flat1403) + flat1413 = self._try_flat(msg, self.pretty_csv_locator_paths) + if flat1413 is not None: + assert flat1413 is not None + self.write(flat1413) return None else: - fields1400 = msg + fields1410 = msg self.write("(paths") self.indent_sexp() - if not len(fields1400) == 0: + if not len(fields1410) == 0: self.newline() - for i1402, elem1401 in enumerate(fields1400): - if (i1402 > 0): + for i1412, elem1411 in enumerate(fields1410): + if (i1412 > 0): self.newline() - self.write(self.format_string_value(elem1401)) + self.write(self.format_string_value(elem1411)) self.dedent() self.write(")") def pretty_csv_locator_inline_data(self, msg: str): - flat1405 = self._try_flat(msg, self.pretty_csv_locator_inline_data) - if flat1405 is not None: - assert flat1405 is not None - self.write(flat1405) + flat1415 = self._try_flat(msg, self.pretty_csv_locator_inline_data) + if flat1415 is not None: + assert flat1415 is not None + self.write(flat1415) return None else: - fields1404 = msg + fields1414 = msg self.write("(inline_data") self.indent_sexp() self.newline() - self.write(self.format_string_value(fields1404)) + self.write(self.format_string_value(fields1414)) self.dedent() self.write(")") def pretty_csv_config(self, msg: logic_pb2.CSVConfig): - flat1411 = self._try_flat(msg, self.pretty_csv_config) - if flat1411 is not None: - assert flat1411 is not None - self.write(flat1411) + flat1421 = self._try_flat(msg, self.pretty_csv_config) + if flat1421 is not None: + assert flat1421 is not None + self.write(flat1421) return None else: _dollar_dollar = msg - _t1719 = self.deconstruct_csv_config(_dollar_dollar) - _t1720 = self.deconstruct_csv_storage_integration_optional(_dollar_dollar) - fields1406 = (_t1719, _t1720,) - assert fields1406 is not None - unwrapped_fields1407 = fields1406 + _t1739 = self.deconstruct_csv_config(_dollar_dollar) + _t1740 = self.deconstruct_csv_storage_integration_optional(_dollar_dollar) + fields1416 = (_t1739, _t1740,) + assert fields1416 is not None + unwrapped_fields1417 = fields1416 self.write("(csv_config") self.indent_sexp() self.newline() - field1408 = unwrapped_fields1407[0] - self.pretty_config_dict(field1408) - field1409 = unwrapped_fields1407[1] - if field1409 is not None: + field1418 = unwrapped_fields1417[0] + self.pretty_config_dict(field1418) + field1419 = unwrapped_fields1417[1] + if field1419 is not None: self.newline() - assert field1409 is not None - opt_val1410 = field1409 - self.pretty__storage_integration(opt_val1410) + assert field1419 is not None + opt_val1420 = field1419 + self.pretty__storage_integration(opt_val1420) self.dedent() self.write(")") def pretty__storage_integration(self, msg: Sequence[tuple[str, logic_pb2.Value]]): - flat1413 = self._try_flat(msg, self.pretty__storage_integration) - if flat1413 is not None: - assert flat1413 is not None - self.write(flat1413) + flat1423 = self._try_flat(msg, self.pretty__storage_integration) + if flat1423 is not None: + assert flat1423 is not None + self.write(flat1423) return None else: - fields1412 = msg + fields1422 = msg self.write("(storage_integration") self.indent_sexp() self.newline() - self.pretty_config_dict(fields1412) + self.pretty_config_dict(fields1422) self.dedent() self.write(")") def pretty_gnf_columns(self, msg: Sequence[logic_pb2.GNFColumn]): - flat1417 = self._try_flat(msg, self.pretty_gnf_columns) - if flat1417 is not None: - assert flat1417 is not None - self.write(flat1417) + flat1427 = self._try_flat(msg, self.pretty_gnf_columns) + if flat1427 is not None: + assert flat1427 is not None + self.write(flat1427) return None else: - fields1414 = msg + fields1424 = msg self.write("(columns") self.indent_sexp() - if not len(fields1414) == 0: + if not len(fields1424) == 0: self.newline() - for i1416, elem1415 in enumerate(fields1414): - if (i1416 > 0): + for i1426, elem1425 in enumerate(fields1424): + if (i1426 > 0): self.newline() - self.pretty_gnf_column(elem1415) + self.pretty_gnf_column(elem1425) self.dedent() self.write(")") def pretty_gnf_column(self, msg: logic_pb2.GNFColumn): - flat1426 = self._try_flat(msg, self.pretty_gnf_column) - if flat1426 is not None: - assert flat1426 is not None - self.write(flat1426) + flat1436 = self._try_flat(msg, self.pretty_gnf_column) + if flat1436 is not None: + assert flat1436 is not None + self.write(flat1436) return None else: _dollar_dollar = msg if _dollar_dollar.HasField("target_id"): - _t1721 = _dollar_dollar.target_id + _t1741 = _dollar_dollar.target_id else: - _t1721 = None - fields1418 = (_dollar_dollar.column_path, _t1721, _dollar_dollar.types,) - assert fields1418 is not None - unwrapped_fields1419 = fields1418 + _t1741 = None + fields1428 = (_dollar_dollar.column_path, _t1741, _dollar_dollar.types,) + assert fields1428 is not None + unwrapped_fields1429 = fields1428 self.write("(column") self.indent_sexp() self.newline() - field1420 = unwrapped_fields1419[0] - self.pretty_gnf_column_path(field1420) - field1421 = unwrapped_fields1419[1] - if field1421 is not None: + field1430 = unwrapped_fields1429[0] + self.pretty_gnf_column_path(field1430) + field1431 = unwrapped_fields1429[1] + if field1431 is not None: self.newline() - assert field1421 is not None - opt_val1422 = field1421 - self.pretty_relation_id(opt_val1422) + assert field1431 is not None + opt_val1432 = field1431 + self.pretty_relation_id(opt_val1432) self.newline() self.write("[") - field1423 = unwrapped_fields1419[2] - for i1425, elem1424 in enumerate(field1423): - if (i1425 > 0): + field1433 = unwrapped_fields1429[2] + for i1435, elem1434 in enumerate(field1433): + if (i1435 > 0): self.newline() - self.pretty_type(elem1424) + self.pretty_type(elem1434) self.write("]") self.dedent() self.write(")") def pretty_gnf_column_path(self, msg: Sequence[str]): - flat1433 = self._try_flat(msg, self.pretty_gnf_column_path) - if flat1433 is not None: - assert flat1433 is not None - self.write(flat1433) + flat1443 = self._try_flat(msg, self.pretty_gnf_column_path) + if flat1443 is not None: + assert flat1443 is not None + self.write(flat1443) return None else: _dollar_dollar = msg if len(_dollar_dollar) == 1: - _t1722 = _dollar_dollar[0] + _t1742 = _dollar_dollar[0] else: - _t1722 = None - deconstruct_result1431 = _t1722 - if deconstruct_result1431 is not None: - assert deconstruct_result1431 is not None - unwrapped1432 = deconstruct_result1431 - self.write(self.format_string_value(unwrapped1432)) + _t1742 = None + deconstruct_result1441 = _t1742 + if deconstruct_result1441 is not None: + assert deconstruct_result1441 is not None + unwrapped1442 = deconstruct_result1441 + self.write(self.format_string_value(unwrapped1442)) else: _dollar_dollar = msg if len(_dollar_dollar) != 1: - _t1723 = _dollar_dollar + _t1743 = _dollar_dollar else: - _t1723 = None - deconstruct_result1427 = _t1723 - if deconstruct_result1427 is not None: - assert deconstruct_result1427 is not None - unwrapped1428 = deconstruct_result1427 + _t1743 = None + deconstruct_result1437 = _t1743 + if deconstruct_result1437 is not None: + assert deconstruct_result1437 is not None + unwrapped1438 = deconstruct_result1437 self.write("[") self.indent() - for i1430, elem1429 in enumerate(unwrapped1428): - if (i1430 > 0): + for i1440, elem1439 in enumerate(unwrapped1438): + if (i1440 > 0): self.newline() - self.write(self.format_string_value(elem1429)) + self.write(self.format_string_value(elem1439)) self.dedent() self.write("]") else: raise ParseError("No matching rule for gnf_column_path") def pretty_csv_asof(self, msg: str): - flat1435 = self._try_flat(msg, self.pretty_csv_asof) - if flat1435 is not None: - assert flat1435 is not None - self.write(flat1435) + flat1445 = self._try_flat(msg, self.pretty_csv_asof) + if flat1445 is not None: + assert flat1445 is not None + self.write(flat1445) return None else: - fields1434 = msg + fields1444 = msg self.write("(asof") self.indent_sexp() self.newline() - self.write(self.format_string_value(fields1434)) + self.write(self.format_string_value(fields1444)) self.dedent() self.write(")") def pretty_iceberg_data(self, msg: logic_pb2.IcebergData): - flat1446 = self._try_flat(msg, self.pretty_iceberg_data) - if flat1446 is not None: - assert flat1446 is not None - self.write(flat1446) + flat1456 = self._try_flat(msg, self.pretty_iceberg_data) + if flat1456 is not None: + assert flat1456 is not None + self.write(flat1456) return None else: _dollar_dollar = msg - _t1724 = self.deconstruct_iceberg_data_from_snapshot_optional(_dollar_dollar) - _t1725 = self.deconstruct_iceberg_data_to_snapshot_optional(_dollar_dollar) - fields1436 = (_dollar_dollar.locator, _dollar_dollar.config, _dollar_dollar.columns, _t1724, _t1725, _dollar_dollar.returns_delta,) - assert fields1436 is not None - unwrapped_fields1437 = fields1436 + _t1744 = self.deconstruct_iceberg_data_from_snapshot_optional(_dollar_dollar) + _t1745 = self.deconstruct_iceberg_data_to_snapshot_optional(_dollar_dollar) + fields1446 = (_dollar_dollar.locator, _dollar_dollar.config, _dollar_dollar.columns, _t1744, _t1745, _dollar_dollar.returns_delta,) + assert fields1446 is not None + unwrapped_fields1447 = fields1446 self.write("(iceberg_data") self.indent_sexp() self.newline() - field1438 = unwrapped_fields1437[0] - self.pretty_iceberg_locator(field1438) + field1448 = unwrapped_fields1447[0] + self.pretty_iceberg_locator(field1448) self.newline() - field1439 = unwrapped_fields1437[1] - self.pretty_iceberg_catalog_config(field1439) + field1449 = unwrapped_fields1447[1] + self.pretty_iceberg_catalog_config(field1449) self.newline() - field1440 = unwrapped_fields1437[2] - self.pretty_gnf_columns(field1440) - field1441 = unwrapped_fields1437[3] - if field1441 is not None: + field1450 = unwrapped_fields1447[2] + self.pretty_gnf_columns(field1450) + field1451 = unwrapped_fields1447[3] + if field1451 is not None: self.newline() - assert field1441 is not None - opt_val1442 = field1441 - self.pretty_iceberg_from_snapshot(opt_val1442) - field1443 = unwrapped_fields1437[4] - if field1443 is not None: + assert field1451 is not None + opt_val1452 = field1451 + self.pretty_iceberg_from_snapshot(opt_val1452) + field1453 = unwrapped_fields1447[4] + if field1453 is not None: self.newline() - assert field1443 is not None - opt_val1444 = field1443 - self.pretty_iceberg_to_snapshot(opt_val1444) + assert field1453 is not None + opt_val1454 = field1453 + self.pretty_iceberg_to_snapshot(opt_val1454) self.newline() - field1445 = unwrapped_fields1437[5] - self.pretty_boolean_value(field1445) + field1455 = unwrapped_fields1447[5] + self.pretty_boolean_value(field1455) self.dedent() self.write(")") def pretty_iceberg_locator(self, msg: logic_pb2.IcebergLocator): - flat1452 = self._try_flat(msg, self.pretty_iceberg_locator) - if flat1452 is not None: - assert flat1452 is not None - self.write(flat1452) + flat1462 = self._try_flat(msg, self.pretty_iceberg_locator) + if flat1462 is not None: + assert flat1462 is not None + self.write(flat1462) return None else: _dollar_dollar = msg - fields1447 = (_dollar_dollar.table_name, _dollar_dollar.namespace, _dollar_dollar.warehouse,) - assert fields1447 is not None - unwrapped_fields1448 = fields1447 + fields1457 = (_dollar_dollar.table_name, _dollar_dollar.namespace, _dollar_dollar.warehouse,) + assert fields1457 is not None + unwrapped_fields1458 = fields1457 self.write("(iceberg_locator") self.indent_sexp() self.newline() - field1449 = unwrapped_fields1448[0] - self.pretty_iceberg_locator_table_name(field1449) + field1459 = unwrapped_fields1458[0] + self.pretty_iceberg_locator_table_name(field1459) self.newline() - field1450 = unwrapped_fields1448[1] - self.pretty_iceberg_locator_namespace(field1450) + field1460 = unwrapped_fields1458[1] + self.pretty_iceberg_locator_namespace(field1460) self.newline() - field1451 = unwrapped_fields1448[2] - self.pretty_iceberg_locator_warehouse(field1451) + field1461 = unwrapped_fields1458[2] + self.pretty_iceberg_locator_warehouse(field1461) self.dedent() self.write(")") def pretty_iceberg_locator_table_name(self, msg: str): - flat1454 = self._try_flat(msg, self.pretty_iceberg_locator_table_name) - if flat1454 is not None: - assert flat1454 is not None - self.write(flat1454) + flat1464 = self._try_flat(msg, self.pretty_iceberg_locator_table_name) + if flat1464 is not None: + assert flat1464 is not None + self.write(flat1464) return None else: - fields1453 = msg + fields1463 = msg self.write("(table_name") self.indent_sexp() self.newline() - self.write(self.format_string_value(fields1453)) + self.write(self.format_string_value(fields1463)) self.dedent() self.write(")") def pretty_iceberg_locator_namespace(self, msg: Sequence[str]): - flat1458 = self._try_flat(msg, self.pretty_iceberg_locator_namespace) - if flat1458 is not None: - assert flat1458 is not None - self.write(flat1458) + flat1468 = self._try_flat(msg, self.pretty_iceberg_locator_namespace) + if flat1468 is not None: + assert flat1468 is not None + self.write(flat1468) return None else: - fields1455 = msg + fields1465 = msg self.write("(namespace") self.indent_sexp() - if not len(fields1455) == 0: + if not len(fields1465) == 0: self.newline() - for i1457, elem1456 in enumerate(fields1455): - if (i1457 > 0): + for i1467, elem1466 in enumerate(fields1465): + if (i1467 > 0): self.newline() - self.write(self.format_string_value(elem1456)) + self.write(self.format_string_value(elem1466)) self.dedent() self.write(")") def pretty_iceberg_locator_warehouse(self, msg: str): - flat1460 = self._try_flat(msg, self.pretty_iceberg_locator_warehouse) - if flat1460 is not None: - assert flat1460 is not None - self.write(flat1460) + flat1470 = self._try_flat(msg, self.pretty_iceberg_locator_warehouse) + if flat1470 is not None: + assert flat1470 is not None + self.write(flat1470) return None else: - fields1459 = msg + fields1469 = msg self.write("(warehouse") self.indent_sexp() self.newline() - self.write(self.format_string_value(fields1459)) + self.write(self.format_string_value(fields1469)) self.dedent() self.write(")") def pretty_iceberg_catalog_config(self, msg: logic_pb2.IcebergCatalogConfig): - flat1468 = self._try_flat(msg, self.pretty_iceberg_catalog_config) - if flat1468 is not None: - assert flat1468 is not None - self.write(flat1468) + flat1478 = self._try_flat(msg, self.pretty_iceberg_catalog_config) + if flat1478 is not None: + assert flat1478 is not None + self.write(flat1478) return None else: _dollar_dollar = msg - _t1726 = self.deconstruct_iceberg_catalog_config_scope_optional(_dollar_dollar) - fields1461 = (_dollar_dollar.catalog_uri, _t1726, sorted(_dollar_dollar.properties.items()), sorted(_dollar_dollar.auth_properties.items()),) - assert fields1461 is not None - unwrapped_fields1462 = fields1461 + _t1746 = self.deconstruct_iceberg_catalog_config_scope_optional(_dollar_dollar) + fields1471 = (_dollar_dollar.catalog_uri, _t1746, sorted(_dollar_dollar.properties.items()), sorted(_dollar_dollar.auth_properties.items()),) + assert fields1471 is not None + unwrapped_fields1472 = fields1471 self.write("(iceberg_catalog_config") self.indent_sexp() self.newline() - field1463 = unwrapped_fields1462[0] - self.pretty_iceberg_catalog_uri(field1463) - field1464 = unwrapped_fields1462[1] - if field1464 is not None: + field1473 = unwrapped_fields1472[0] + self.pretty_iceberg_catalog_uri(field1473) + field1474 = unwrapped_fields1472[1] + if field1474 is not None: self.newline() - assert field1464 is not None - opt_val1465 = field1464 - self.pretty_iceberg_catalog_config_scope(opt_val1465) + assert field1474 is not None + opt_val1475 = field1474 + self.pretty_iceberg_catalog_config_scope(opt_val1475) self.newline() - field1466 = unwrapped_fields1462[2] - self.pretty_iceberg_properties(field1466) + field1476 = unwrapped_fields1472[2] + self.pretty_iceberg_properties(field1476) self.newline() - field1467 = unwrapped_fields1462[3] - self.pretty_iceberg_auth_properties(field1467) + field1477 = unwrapped_fields1472[3] + self.pretty_iceberg_auth_properties(field1477) self.dedent() self.write(")") def pretty_iceberg_catalog_uri(self, msg: str): - flat1470 = self._try_flat(msg, self.pretty_iceberg_catalog_uri) - if flat1470 is not None: - assert flat1470 is not None - self.write(flat1470) + flat1480 = self._try_flat(msg, self.pretty_iceberg_catalog_uri) + if flat1480 is not None: + assert flat1480 is not None + self.write(flat1480) return None else: - fields1469 = msg + fields1479 = msg self.write("(catalog_uri") self.indent_sexp() self.newline() - self.write(self.format_string_value(fields1469)) + self.write(self.format_string_value(fields1479)) self.dedent() self.write(")") def pretty_iceberg_catalog_config_scope(self, msg: str): - flat1472 = self._try_flat(msg, self.pretty_iceberg_catalog_config_scope) - if flat1472 is not None: - assert flat1472 is not None - self.write(flat1472) + flat1482 = self._try_flat(msg, self.pretty_iceberg_catalog_config_scope) + if flat1482 is not None: + assert flat1482 is not None + self.write(flat1482) return None else: - fields1471 = msg + fields1481 = msg self.write("(scope") self.indent_sexp() self.newline() - self.write(self.format_string_value(fields1471)) + self.write(self.format_string_value(fields1481)) self.dedent() self.write(")") def pretty_iceberg_properties(self, msg: Sequence[tuple[str, str]]): - flat1476 = self._try_flat(msg, self.pretty_iceberg_properties) - if flat1476 is not None: - assert flat1476 is not None - self.write(flat1476) + flat1486 = self._try_flat(msg, self.pretty_iceberg_properties) + if flat1486 is not None: + assert flat1486 is not None + self.write(flat1486) return None else: - fields1473 = msg + fields1483 = msg self.write("(properties") self.indent_sexp() - if not len(fields1473) == 0: + if not len(fields1483) == 0: self.newline() - for i1475, elem1474 in enumerate(fields1473): - if (i1475 > 0): + for i1485, elem1484 in enumerate(fields1483): + if (i1485 > 0): self.newline() - self.pretty_iceberg_property_entry(elem1474) + self.pretty_iceberg_property_entry(elem1484) self.dedent() self.write(")") def pretty_iceberg_property_entry(self, msg: tuple[str, str]): - flat1481 = self._try_flat(msg, self.pretty_iceberg_property_entry) - if flat1481 is not None: - assert flat1481 is not None - self.write(flat1481) + flat1491 = self._try_flat(msg, self.pretty_iceberg_property_entry) + if flat1491 is not None: + assert flat1491 is not None + self.write(flat1491) return None else: _dollar_dollar = msg - fields1477 = (_dollar_dollar[0], _dollar_dollar[1],) - assert fields1477 is not None - unwrapped_fields1478 = fields1477 + fields1487 = (_dollar_dollar[0], _dollar_dollar[1],) + assert fields1487 is not None + unwrapped_fields1488 = fields1487 self.write("(prop") self.indent_sexp() self.newline() - field1479 = unwrapped_fields1478[0] - self.write(self.format_string_value(field1479)) + field1489 = unwrapped_fields1488[0] + self.write(self.format_string_value(field1489)) self.newline() - field1480 = unwrapped_fields1478[1] - self.write(self.format_string_value(field1480)) + field1490 = unwrapped_fields1488[1] + self.write(self.format_string_value(field1490)) self.dedent() self.write(")") def pretty_iceberg_auth_properties(self, msg: Sequence[tuple[str, str]]): - flat1485 = self._try_flat(msg, self.pretty_iceberg_auth_properties) - if flat1485 is not None: - assert flat1485 is not None - self.write(flat1485) + flat1495 = self._try_flat(msg, self.pretty_iceberg_auth_properties) + if flat1495 is not None: + assert flat1495 is not None + self.write(flat1495) return None else: - fields1482 = msg + fields1492 = msg self.write("(auth_properties") self.indent_sexp() - if not len(fields1482) == 0: + if not len(fields1492) == 0: self.newline() - for i1484, elem1483 in enumerate(fields1482): - if (i1484 > 0): + for i1494, elem1493 in enumerate(fields1492): + if (i1494 > 0): self.newline() - self.pretty_iceberg_masked_property_entry(elem1483) + self.pretty_iceberg_masked_property_entry(elem1493) self.dedent() self.write(")") def pretty_iceberg_masked_property_entry(self, msg: tuple[str, str]): - flat1490 = self._try_flat(msg, self.pretty_iceberg_masked_property_entry) - if flat1490 is not None: - assert flat1490 is not None - self.write(flat1490) + flat1500 = self._try_flat(msg, self.pretty_iceberg_masked_property_entry) + if flat1500 is not None: + assert flat1500 is not None + self.write(flat1500) return None else: _dollar_dollar = msg - _t1727 = self.mask_secret_value(_dollar_dollar) - fields1486 = (_dollar_dollar[0], _t1727,) - assert fields1486 is not None - unwrapped_fields1487 = fields1486 + _t1747 = self.mask_secret_value(_dollar_dollar) + fields1496 = (_dollar_dollar[0], _t1747,) + assert fields1496 is not None + unwrapped_fields1497 = fields1496 self.write("(prop") self.indent_sexp() self.newline() - field1488 = unwrapped_fields1487[0] - self.write(self.format_string_value(field1488)) + field1498 = unwrapped_fields1497[0] + self.write(self.format_string_value(field1498)) self.newline() - field1489 = unwrapped_fields1487[1] - self.write(self.format_string_value(field1489)) + field1499 = unwrapped_fields1497[1] + self.write(self.format_string_value(field1499)) self.dedent() self.write(")") def pretty_iceberg_from_snapshot(self, msg: str): - flat1492 = self._try_flat(msg, self.pretty_iceberg_from_snapshot) - if flat1492 is not None: - assert flat1492 is not None - self.write(flat1492) + flat1502 = self._try_flat(msg, self.pretty_iceberg_from_snapshot) + if flat1502 is not None: + assert flat1502 is not None + self.write(flat1502) return None else: - fields1491 = msg + fields1501 = msg self.write("(from_snapshot") self.indent_sexp() self.newline() - self.write(self.format_string_value(fields1491)) + self.write(self.format_string_value(fields1501)) self.dedent() self.write(")") def pretty_iceberg_to_snapshot(self, msg: str): - flat1494 = self._try_flat(msg, self.pretty_iceberg_to_snapshot) - if flat1494 is not None: - assert flat1494 is not None - self.write(flat1494) + flat1504 = self._try_flat(msg, self.pretty_iceberg_to_snapshot) + if flat1504 is not None: + assert flat1504 is not None + self.write(flat1504) return None else: - fields1493 = msg + fields1503 = msg self.write("(to_snapshot") self.indent_sexp() self.newline() - self.write(self.format_string_value(fields1493)) + self.write(self.format_string_value(fields1503)) self.dedent() self.write(")") def pretty_undefine(self, msg: transactions_pb2.Undefine): - flat1497 = self._try_flat(msg, self.pretty_undefine) - if flat1497 is not None: - assert flat1497 is not None - self.write(flat1497) + flat1507 = self._try_flat(msg, self.pretty_undefine) + if flat1507 is not None: + assert flat1507 is not None + self.write(flat1507) return None else: _dollar_dollar = msg - fields1495 = _dollar_dollar.fragment_id - assert fields1495 is not None - unwrapped_fields1496 = fields1495 + fields1505 = _dollar_dollar.fragment_id + assert fields1505 is not None + unwrapped_fields1506 = fields1505 self.write("(undefine") self.indent_sexp() self.newline() - self.pretty_fragment_id(unwrapped_fields1496) + self.pretty_fragment_id(unwrapped_fields1506) self.dedent() self.write(")") def pretty_context(self, msg: transactions_pb2.Context): - flat1502 = self._try_flat(msg, self.pretty_context) - if flat1502 is not None: - assert flat1502 is not None - self.write(flat1502) + flat1512 = self._try_flat(msg, self.pretty_context) + if flat1512 is not None: + assert flat1512 is not None + self.write(flat1512) return None else: _dollar_dollar = msg - fields1498 = _dollar_dollar.relations - assert fields1498 is not None - unwrapped_fields1499 = fields1498 + fields1508 = _dollar_dollar.relations + assert fields1508 is not None + unwrapped_fields1509 = fields1508 self.write("(context") self.indent_sexp() - if not len(unwrapped_fields1499) == 0: + if not len(unwrapped_fields1509) == 0: self.newline() - for i1501, elem1500 in enumerate(unwrapped_fields1499): - if (i1501 > 0): + for i1511, elem1510 in enumerate(unwrapped_fields1509): + if (i1511 > 0): self.newline() - self.pretty_relation_id(elem1500) + self.pretty_relation_id(elem1510) self.dedent() self.write(")") def pretty_snapshot(self, msg: transactions_pb2.Snapshot): - flat1509 = self._try_flat(msg, self.pretty_snapshot) - if flat1509 is not None: - assert flat1509 is not None - self.write(flat1509) + flat1519 = self._try_flat(msg, self.pretty_snapshot) + if flat1519 is not None: + assert flat1519 is not None + self.write(flat1519) return None else: _dollar_dollar = msg - fields1503 = (_dollar_dollar.prefix, _dollar_dollar.mappings,) - assert fields1503 is not None - unwrapped_fields1504 = fields1503 + fields1513 = (_dollar_dollar.prefix, _dollar_dollar.mappings,) + assert fields1513 is not None + unwrapped_fields1514 = fields1513 self.write("(snapshot") self.indent_sexp() self.newline() - field1505 = unwrapped_fields1504[0] - self.pretty_edb_path(field1505) - field1506 = unwrapped_fields1504[1] - if not len(field1506) == 0: + field1515 = unwrapped_fields1514[0] + self.pretty_edb_path(field1515) + field1516 = unwrapped_fields1514[1] + if not len(field1516) == 0: self.newline() - for i1508, elem1507 in enumerate(field1506): - if (i1508 > 0): + for i1518, elem1517 in enumerate(field1516): + if (i1518 > 0): self.newline() - self.pretty_snapshot_mapping(elem1507) + self.pretty_snapshot_mapping(elem1517) self.dedent() self.write(")") def pretty_snapshot_mapping(self, msg: transactions_pb2.SnapshotMapping): - flat1514 = self._try_flat(msg, self.pretty_snapshot_mapping) - if flat1514 is not None: - assert flat1514 is not None - self.write(flat1514) + flat1524 = self._try_flat(msg, self.pretty_snapshot_mapping) + if flat1524 is not None: + assert flat1524 is not None + self.write(flat1524) return None else: _dollar_dollar = msg - fields1510 = (_dollar_dollar.destination_path, _dollar_dollar.source_relation,) - assert fields1510 is not None - unwrapped_fields1511 = fields1510 - field1512 = unwrapped_fields1511[0] - self.pretty_edb_path(field1512) + fields1520 = (_dollar_dollar.destination_path, _dollar_dollar.source_relation,) + assert fields1520 is not None + unwrapped_fields1521 = fields1520 + field1522 = unwrapped_fields1521[0] + self.pretty_edb_path(field1522) self.write(" ") - field1513 = unwrapped_fields1511[1] - self.pretty_relation_id(field1513) + field1523 = unwrapped_fields1521[1] + self.pretty_relation_id(field1523) def pretty_epoch_reads(self, msg: Sequence[transactions_pb2.Read]): - flat1518 = self._try_flat(msg, self.pretty_epoch_reads) - if flat1518 is not None: - assert flat1518 is not None - self.write(flat1518) + flat1528 = self._try_flat(msg, self.pretty_epoch_reads) + if flat1528 is not None: + assert flat1528 is not None + self.write(flat1528) return None else: - fields1515 = msg + fields1525 = msg self.write("(reads") self.indent_sexp() - if not len(fields1515) == 0: + if not len(fields1525) == 0: self.newline() - for i1517, elem1516 in enumerate(fields1515): - if (i1517 > 0): + for i1527, elem1526 in enumerate(fields1525): + if (i1527 > 0): self.newline() - self.pretty_read(elem1516) + self.pretty_read(elem1526) self.dedent() self.write(")") def pretty_read(self, msg: transactions_pb2.Read): - flat1529 = self._try_flat(msg, self.pretty_read) - if flat1529 is not None: - assert flat1529 is not None - self.write(flat1529) + flat1541 = self._try_flat(msg, self.pretty_read) + if flat1541 is not None: + assert flat1541 is not None + self.write(flat1541) return None else: _dollar_dollar = msg if _dollar_dollar.HasField("demand"): - _t1728 = _dollar_dollar.demand + _t1748 = _dollar_dollar.demand else: - _t1728 = None - deconstruct_result1527 = _t1728 - if deconstruct_result1527 is not None: - assert deconstruct_result1527 is not None - unwrapped1528 = deconstruct_result1527 - self.pretty_demand(unwrapped1528) + _t1748 = None + deconstruct_result1539 = _t1748 + if deconstruct_result1539 is not None: + assert deconstruct_result1539 is not None + unwrapped1540 = deconstruct_result1539 + self.pretty_demand(unwrapped1540) else: _dollar_dollar = msg if _dollar_dollar.HasField("output"): - _t1729 = _dollar_dollar.output + _t1749 = _dollar_dollar.output else: - _t1729 = None - deconstruct_result1525 = _t1729 - if deconstruct_result1525 is not None: - assert deconstruct_result1525 is not None - unwrapped1526 = deconstruct_result1525 - self.pretty_output(unwrapped1526) + _t1749 = None + deconstruct_result1537 = _t1749 + if deconstruct_result1537 is not None: + assert deconstruct_result1537 is not None + unwrapped1538 = deconstruct_result1537 + self.pretty_output(unwrapped1538) else: _dollar_dollar = msg if _dollar_dollar.HasField("what_if"): - _t1730 = _dollar_dollar.what_if + _t1750 = _dollar_dollar.what_if else: - _t1730 = None - deconstruct_result1523 = _t1730 - if deconstruct_result1523 is not None: - assert deconstruct_result1523 is not None - unwrapped1524 = deconstruct_result1523 - self.pretty_what_if(unwrapped1524) + _t1750 = None + deconstruct_result1535 = _t1750 + if deconstruct_result1535 is not None: + assert deconstruct_result1535 is not None + unwrapped1536 = deconstruct_result1535 + self.pretty_what_if(unwrapped1536) else: _dollar_dollar = msg if _dollar_dollar.HasField("abort"): - _t1731 = _dollar_dollar.abort + _t1751 = _dollar_dollar.abort else: - _t1731 = None - deconstruct_result1521 = _t1731 - if deconstruct_result1521 is not None: - assert deconstruct_result1521 is not None - unwrapped1522 = deconstruct_result1521 - self.pretty_abort(unwrapped1522) + _t1751 = None + deconstruct_result1533 = _t1751 + if deconstruct_result1533 is not None: + assert deconstruct_result1533 is not None + unwrapped1534 = deconstruct_result1533 + self.pretty_abort(unwrapped1534) else: _dollar_dollar = msg if _dollar_dollar.HasField("export"): - _t1732 = _dollar_dollar.export + _t1752 = _dollar_dollar.export else: - _t1732 = None - deconstruct_result1519 = _t1732 - if deconstruct_result1519 is not None: - assert deconstruct_result1519 is not None - unwrapped1520 = deconstruct_result1519 - self.pretty_export(unwrapped1520) + _t1752 = None + deconstruct_result1531 = _t1752 + if deconstruct_result1531 is not None: + assert deconstruct_result1531 is not None + unwrapped1532 = deconstruct_result1531 + self.pretty_export(unwrapped1532) else: - raise ParseError("No matching rule for read") + _dollar_dollar = msg + if _dollar_dollar.HasField("export_output"): + _t1753 = _dollar_dollar.export_output + else: + _t1753 = None + deconstruct_result1529 = _t1753 + if deconstruct_result1529 is not None: + assert deconstruct_result1529 is not None + unwrapped1530 = deconstruct_result1529 + self.pretty_export_output(unwrapped1530) + else: + raise ParseError("No matching rule for read") def pretty_demand(self, msg: transactions_pb2.Demand): - flat1532 = self._try_flat(msg, self.pretty_demand) - if flat1532 is not None: - assert flat1532 is not None - self.write(flat1532) + flat1544 = self._try_flat(msg, self.pretty_demand) + if flat1544 is not None: + assert flat1544 is not None + self.write(flat1544) return None else: _dollar_dollar = msg - fields1530 = _dollar_dollar.relation_id - assert fields1530 is not None - unwrapped_fields1531 = fields1530 + fields1542 = _dollar_dollar.relation_id + assert fields1542 is not None + unwrapped_fields1543 = fields1542 self.write("(demand") self.indent_sexp() self.newline() - self.pretty_relation_id(unwrapped_fields1531) + self.pretty_relation_id(unwrapped_fields1543) self.dedent() self.write(")") def pretty_output(self, msg: transactions_pb2.Output): - flat1537 = self._try_flat(msg, self.pretty_output) - if flat1537 is not None: - assert flat1537 is not None - self.write(flat1537) + flat1549 = self._try_flat(msg, self.pretty_output) + if flat1549 is not None: + assert flat1549 is not None + self.write(flat1549) return None else: _dollar_dollar = msg - fields1533 = (_dollar_dollar.name, _dollar_dollar.relation_id,) - assert fields1533 is not None - unwrapped_fields1534 = fields1533 + fields1545 = (_dollar_dollar.name, _dollar_dollar.relation_id,) + assert fields1545 is not None + unwrapped_fields1546 = fields1545 self.write("(output") self.indent_sexp() self.newline() - field1535 = unwrapped_fields1534[0] - self.pretty_name(field1535) + field1547 = unwrapped_fields1546[0] + self.pretty_name(field1547) self.newline() - field1536 = unwrapped_fields1534[1] - self.pretty_relation_id(field1536) + field1548 = unwrapped_fields1546[1] + self.pretty_relation_id(field1548) self.dedent() self.write(")") def pretty_what_if(self, msg: transactions_pb2.WhatIf): - flat1542 = self._try_flat(msg, self.pretty_what_if) - if flat1542 is not None: - assert flat1542 is not None - self.write(flat1542) + flat1554 = self._try_flat(msg, self.pretty_what_if) + if flat1554 is not None: + assert flat1554 is not None + self.write(flat1554) return None else: _dollar_dollar = msg - fields1538 = (_dollar_dollar.branch, _dollar_dollar.epoch,) - assert fields1538 is not None - unwrapped_fields1539 = fields1538 + fields1550 = (_dollar_dollar.branch, _dollar_dollar.epoch,) + assert fields1550 is not None + unwrapped_fields1551 = fields1550 self.write("(what_if") self.indent_sexp() self.newline() - field1540 = unwrapped_fields1539[0] - self.pretty_name(field1540) + field1552 = unwrapped_fields1551[0] + self.pretty_name(field1552) self.newline() - field1541 = unwrapped_fields1539[1] - self.pretty_epoch(field1541) + field1553 = unwrapped_fields1551[1] + self.pretty_epoch(field1553) self.dedent() self.write(")") def pretty_abort(self, msg: transactions_pb2.Abort): - flat1548 = self._try_flat(msg, self.pretty_abort) - if flat1548 is not None: - assert flat1548 is not None - self.write(flat1548) + flat1560 = self._try_flat(msg, self.pretty_abort) + if flat1560 is not None: + assert flat1560 is not None + self.write(flat1560) return None else: _dollar_dollar = msg if _dollar_dollar.name != "abort": - _t1733 = _dollar_dollar.name + _t1754 = _dollar_dollar.name else: - _t1733 = None - fields1543 = (_t1733, _dollar_dollar.relation_id,) - assert fields1543 is not None - unwrapped_fields1544 = fields1543 + _t1754 = None + fields1555 = (_t1754, _dollar_dollar.relation_id,) + assert fields1555 is not None + unwrapped_fields1556 = fields1555 self.write("(abort") self.indent_sexp() - field1545 = unwrapped_fields1544[0] - if field1545 is not None: + field1557 = unwrapped_fields1556[0] + if field1557 is not None: self.newline() - assert field1545 is not None - opt_val1546 = field1545 - self.pretty_name(opt_val1546) + assert field1557 is not None + opt_val1558 = field1557 + self.pretty_name(opt_val1558) self.newline() - field1547 = unwrapped_fields1544[1] - self.pretty_relation_id(field1547) + field1559 = unwrapped_fields1556[1] + self.pretty_relation_id(field1559) self.dedent() self.write(")") def pretty_export(self, msg: transactions_pb2.Export): - flat1553 = self._try_flat(msg, self.pretty_export) - if flat1553 is not None: - assert flat1553 is not None - self.write(flat1553) + flat1565 = self._try_flat(msg, self.pretty_export) + if flat1565 is not None: + assert flat1565 is not None + self.write(flat1565) return None else: _dollar_dollar = msg if _dollar_dollar.HasField("csv_config"): - _t1734 = _dollar_dollar.csv_config + _t1755 = _dollar_dollar.csv_config else: - _t1734 = None - deconstruct_result1551 = _t1734 - if deconstruct_result1551 is not None: - assert deconstruct_result1551 is not None - unwrapped1552 = deconstruct_result1551 + _t1755 = None + deconstruct_result1563 = _t1755 + if deconstruct_result1563 is not None: + assert deconstruct_result1563 is not None + unwrapped1564 = deconstruct_result1563 self.write("(export") self.indent_sexp() self.newline() - self.pretty_export_csv_config(unwrapped1552) + self.pretty_export_csv_config(unwrapped1564) self.dedent() self.write(")") else: _dollar_dollar = msg if _dollar_dollar.HasField("iceberg_config"): - _t1735 = _dollar_dollar.iceberg_config + _t1756 = _dollar_dollar.iceberg_config else: - _t1735 = None - deconstruct_result1549 = _t1735 - if deconstruct_result1549 is not None: - assert deconstruct_result1549 is not None - unwrapped1550 = deconstruct_result1549 + _t1756 = None + deconstruct_result1561 = _t1756 + if deconstruct_result1561 is not None: + assert deconstruct_result1561 is not None + unwrapped1562 = deconstruct_result1561 self.write("(export_iceberg") self.indent_sexp() self.newline() - self.pretty_export_iceberg_config(unwrapped1550) + self.pretty_export_iceberg_config(unwrapped1562) self.dedent() self.write(")") else: raise ParseError("No matching rule for export") def pretty_export_csv_config(self, msg: transactions_pb2.ExportCSVConfig): - flat1564 = self._try_flat(msg, self.pretty_export_csv_config) - if flat1564 is not None: - assert flat1564 is not None - self.write(flat1564) + flat1576 = self._try_flat(msg, self.pretty_export_csv_config) + if flat1576 is not None: + assert flat1576 is not None + self.write(flat1576) return None else: _dollar_dollar = msg if len(_dollar_dollar.data_columns) == 0: - _t1736 = (_dollar_dollar.path, _dollar_dollar.csv_source, _dollar_dollar.csv_config,) + _t1757 = (_dollar_dollar.path, _dollar_dollar.csv_source, _dollar_dollar.csv_config,) else: - _t1736 = None - deconstruct_result1559 = _t1736 - if deconstruct_result1559 is not None: - assert deconstruct_result1559 is not None - unwrapped1560 = deconstruct_result1559 + _t1757 = None + deconstruct_result1571 = _t1757 + if deconstruct_result1571 is not None: + assert deconstruct_result1571 is not None + unwrapped1572 = deconstruct_result1571 self.write("(export_csv_config_v2") self.indent_sexp() self.newline() - field1561 = unwrapped1560[0] - self.pretty_export_csv_path(field1561) + field1573 = unwrapped1572[0] + self.pretty_export_csv_path(field1573) self.newline() - field1562 = unwrapped1560[1] - self.pretty_export_csv_source(field1562) + field1574 = unwrapped1572[1] + self.pretty_export_csv_source(field1574) self.newline() - field1563 = unwrapped1560[2] - self.pretty_csv_config(field1563) + field1575 = unwrapped1572[2] + self.pretty_csv_config(field1575) self.dedent() self.write(")") else: _dollar_dollar = msg if len(_dollar_dollar.data_columns) != 0: - _t1738 = self.deconstruct_export_csv_config(_dollar_dollar) - _t1737 = (_dollar_dollar.path, _dollar_dollar.data_columns, _t1738,) + _t1759 = self.deconstruct_export_csv_config(_dollar_dollar) + _t1758 = (_dollar_dollar.path, _dollar_dollar.data_columns, _t1759,) else: - _t1737 = None - deconstruct_result1554 = _t1737 - if deconstruct_result1554 is not None: - assert deconstruct_result1554 is not None - unwrapped1555 = deconstruct_result1554 + _t1758 = None + deconstruct_result1566 = _t1758 + if deconstruct_result1566 is not None: + assert deconstruct_result1566 is not None + unwrapped1567 = deconstruct_result1566 self.write("(export_csv_config") self.indent_sexp() self.newline() - field1556 = unwrapped1555[0] - self.pretty_export_csv_path(field1556) + field1568 = unwrapped1567[0] + self.pretty_export_csv_path(field1568) self.newline() - field1557 = unwrapped1555[1] - self.pretty_export_csv_columns_list(field1557) + field1569 = unwrapped1567[1] + self.pretty_export_csv_columns_list(field1569) self.newline() - field1558 = unwrapped1555[2] - self.pretty_config_dict(field1558) + field1570 = unwrapped1567[2] + self.pretty_config_dict(field1570) self.dedent() self.write(")") else: raise ParseError("No matching rule for export_csv_config") def pretty_export_csv_path(self, msg: str): - flat1566 = self._try_flat(msg, self.pretty_export_csv_path) - if flat1566 is not None: - assert flat1566 is not None - self.write(flat1566) + flat1578 = self._try_flat(msg, self.pretty_export_csv_path) + if flat1578 is not None: + assert flat1578 is not None + self.write(flat1578) return None else: - fields1565 = msg + fields1577 = msg self.write("(path") self.indent_sexp() self.newline() - self.write(self.format_string_value(fields1565)) + self.write(self.format_string_value(fields1577)) self.dedent() self.write(")") def pretty_export_csv_source(self, msg: transactions_pb2.ExportCSVSource): - flat1573 = self._try_flat(msg, self.pretty_export_csv_source) - if flat1573 is not None: - assert flat1573 is not None - self.write(flat1573) + flat1585 = self._try_flat(msg, self.pretty_export_csv_source) + if flat1585 is not None: + assert flat1585 is not None + self.write(flat1585) return None else: _dollar_dollar = msg if _dollar_dollar.HasField("gnf_columns"): - _t1739 = _dollar_dollar.gnf_columns.columns + _t1760 = _dollar_dollar.gnf_columns.columns else: - _t1739 = None - deconstruct_result1569 = _t1739 - if deconstruct_result1569 is not None: - assert deconstruct_result1569 is not None - unwrapped1570 = deconstruct_result1569 + _t1760 = None + deconstruct_result1581 = _t1760 + if deconstruct_result1581 is not None: + assert deconstruct_result1581 is not None + unwrapped1582 = deconstruct_result1581 self.write("(gnf_columns") self.indent_sexp() - if not len(unwrapped1570) == 0: + if not len(unwrapped1582) == 0: self.newline() - for i1572, elem1571 in enumerate(unwrapped1570): - if (i1572 > 0): + for i1584, elem1583 in enumerate(unwrapped1582): + if (i1584 > 0): self.newline() - self.pretty_export_csv_column(elem1571) + self.pretty_export_csv_column(elem1583) self.dedent() self.write(")") else: _dollar_dollar = msg if _dollar_dollar.HasField("table_def"): - _t1740 = _dollar_dollar.table_def + _t1761 = _dollar_dollar.table_def else: - _t1740 = None - deconstruct_result1567 = _t1740 - if deconstruct_result1567 is not None: - assert deconstruct_result1567 is not None - unwrapped1568 = deconstruct_result1567 + _t1761 = None + deconstruct_result1579 = _t1761 + if deconstruct_result1579 is not None: + assert deconstruct_result1579 is not None + unwrapped1580 = deconstruct_result1579 self.write("(table_def") self.indent_sexp() self.newline() - self.pretty_relation_id(unwrapped1568) + self.pretty_relation_id(unwrapped1580) self.dedent() self.write(")") else: raise ParseError("No matching rule for export_csv_source") def pretty_export_csv_column(self, msg: transactions_pb2.ExportCSVColumn): - flat1578 = self._try_flat(msg, self.pretty_export_csv_column) - if flat1578 is not None: - assert flat1578 is not None - self.write(flat1578) + flat1590 = self._try_flat(msg, self.pretty_export_csv_column) + if flat1590 is not None: + assert flat1590 is not None + self.write(flat1590) return None else: _dollar_dollar = msg - fields1574 = (_dollar_dollar.column_name, _dollar_dollar.column_data,) - assert fields1574 is not None - unwrapped_fields1575 = fields1574 + fields1586 = (_dollar_dollar.column_name, _dollar_dollar.column_data,) + assert fields1586 is not None + unwrapped_fields1587 = fields1586 self.write("(column") self.indent_sexp() self.newline() - field1576 = unwrapped_fields1575[0] - self.write(self.format_string_value(field1576)) + field1588 = unwrapped_fields1587[0] + self.write(self.format_string_value(field1588)) self.newline() - field1577 = unwrapped_fields1575[1] - self.pretty_relation_id(field1577) + field1589 = unwrapped_fields1587[1] + self.pretty_relation_id(field1589) self.dedent() self.write(")") def pretty_export_csv_columns_list(self, msg: Sequence[transactions_pb2.ExportCSVColumn]): - flat1582 = self._try_flat(msg, self.pretty_export_csv_columns_list) - if flat1582 is not None: - assert flat1582 is not None - self.write(flat1582) + flat1594 = self._try_flat(msg, self.pretty_export_csv_columns_list) + if flat1594 is not None: + assert flat1594 is not None + self.write(flat1594) return None else: - fields1579 = msg + fields1591 = msg self.write("(columns") self.indent_sexp() - if not len(fields1579) == 0: + if not len(fields1591) == 0: self.newline() - for i1581, elem1580 in enumerate(fields1579): - if (i1581 > 0): + for i1593, elem1592 in enumerate(fields1591): + if (i1593 > 0): self.newline() - self.pretty_export_csv_column(elem1580) + self.pretty_export_csv_column(elem1592) self.dedent() self.write(")") def pretty_export_iceberg_config(self, msg: transactions_pb2.ExportIcebergConfig): - flat1591 = self._try_flat(msg, self.pretty_export_iceberg_config) - if flat1591 is not None: - assert flat1591 is not None - self.write(flat1591) + flat1603 = self._try_flat(msg, self.pretty_export_iceberg_config) + if flat1603 is not None: + assert flat1603 is not None + self.write(flat1603) return None else: _dollar_dollar = msg - _t1741 = self.deconstruct_export_iceberg_config_optional(_dollar_dollar) - fields1583 = (_dollar_dollar.locator, _dollar_dollar.config, _dollar_dollar.table_def, sorted(_dollar_dollar.table_properties.items()), _t1741,) - assert fields1583 is not None - unwrapped_fields1584 = fields1583 + _t1762 = self.deconstruct_export_iceberg_config_optional(_dollar_dollar) + fields1595 = (_dollar_dollar.locator, _dollar_dollar.config, _dollar_dollar.table_def, sorted(_dollar_dollar.table_properties.items()), _t1762,) + assert fields1595 is not None + unwrapped_fields1596 = fields1595 self.write("(export_iceberg_config") self.indent_sexp() self.newline() - field1585 = unwrapped_fields1584[0] - self.pretty_iceberg_locator(field1585) + field1597 = unwrapped_fields1596[0] + self.pretty_iceberg_locator(field1597) self.newline() - field1586 = unwrapped_fields1584[1] - self.pretty_iceberg_catalog_config(field1586) + field1598 = unwrapped_fields1596[1] + self.pretty_iceberg_catalog_config(field1598) self.newline() - field1587 = unwrapped_fields1584[2] - self.pretty_export_iceberg_table_def(field1587) + field1599 = unwrapped_fields1596[2] + self.pretty_export_iceberg_table_def(field1599) self.newline() - field1588 = unwrapped_fields1584[3] - self.pretty_iceberg_table_properties(field1588) - field1589 = unwrapped_fields1584[4] - if field1589 is not None: + field1600 = unwrapped_fields1596[3] + self.pretty_iceberg_table_properties(field1600) + field1601 = unwrapped_fields1596[4] + if field1601 is not None: self.newline() - assert field1589 is not None - opt_val1590 = field1589 - self.pretty_config_dict(opt_val1590) + assert field1601 is not None + opt_val1602 = field1601 + self.pretty_config_dict(opt_val1602) self.dedent() self.write(")") def pretty_export_iceberg_table_def(self, msg: logic_pb2.RelationId): - flat1593 = self._try_flat(msg, self.pretty_export_iceberg_table_def) - if flat1593 is not None: - assert flat1593 is not None - self.write(flat1593) + flat1605 = self._try_flat(msg, self.pretty_export_iceberg_table_def) + if flat1605 is not None: + assert flat1605 is not None + self.write(flat1605) return None else: - fields1592 = msg + fields1604 = msg self.write("(table_def") self.indent_sexp() self.newline() - self.pretty_relation_id(fields1592) + self.pretty_relation_id(fields1604) self.dedent() self.write(")") def pretty_iceberg_table_properties(self, msg: Sequence[tuple[str, str]]): - flat1597 = self._try_flat(msg, self.pretty_iceberg_table_properties) - if flat1597 is not None: - assert flat1597 is not None - self.write(flat1597) + flat1609 = self._try_flat(msg, self.pretty_iceberg_table_properties) + if flat1609 is not None: + assert flat1609 is not None + self.write(flat1609) return None else: - fields1594 = msg + fields1606 = msg self.write("(table_properties") self.indent_sexp() - if not len(fields1594) == 0: + if not len(fields1606) == 0: self.newline() - for i1596, elem1595 in enumerate(fields1594): - if (i1596 > 0): + for i1608, elem1607 in enumerate(fields1606): + if (i1608 > 0): self.newline() - self.pretty_iceberg_property_entry(elem1595) + self.pretty_iceberg_property_entry(elem1607) + self.dedent() + self.write(")") + + def pretty_export_output(self, msg: transactions_pb2.ExportOutput): + flat1612 = self._try_flat(msg, self.pretty_export_output) + if flat1612 is not None: + assert flat1612 is not None + self.write(flat1612) + return None + else: + _dollar_dollar = msg + if _dollar_dollar.HasField("csv"): + _t1763 = _dollar_dollar.csv + else: + _t1763 = None + fields1610 = _t1763 + assert fields1610 is not None + unwrapped_fields1611 = fields1610 + self.write("(output_export") + self.indent_sexp() + self.newline() + self.pretty_export_csv_output(unwrapped_fields1611) + self.dedent() + self.write(")") + + def pretty_export_csv_output(self, msg: transactions_pb2.ExportCSVOutput): + flat1617 = self._try_flat(msg, self.pretty_export_csv_output) + if flat1617 is not None: + assert flat1617 is not None + self.write(flat1617) + return None + else: + _dollar_dollar = msg + fields1613 = (_dollar_dollar.csv_source, _dollar_dollar.csv_config,) + assert fields1613 is not None + unwrapped_fields1614 = fields1613 + self.write("(csv") + self.indent_sexp() + self.newline() + field1615 = unwrapped_fields1614[0] + self.pretty_export_csv_source(field1615) + self.newline() + field1616 = unwrapped_fields1614[1] + self.pretty_csv_config(field1616) self.dedent() self.write(")") @@ -4390,8 +4445,8 @@ def pretty_debug_info(self, msg: fragments_pb2.DebugInfo): for _idx, _rid in enumerate(msg.ids): self.newline() self.write("(") - _t1793 = logic_pb2.UInt128Value(low=_rid.id_low, high=_rid.id_high) - self.pprint_dispatch(_t1793) + _t1815 = logic_pb2.UInt128Value(low=_rid.id_low, high=_rid.id_high) + self.pprint_dispatch(_t1815) self.write(" ") self.write(self.format_string_value(msg.orig_names[_idx])) self.write(")") @@ -4713,6 +4768,10 @@ def pprint_dispatch(self, msg): self.pretty_export_csv_column(msg) elif isinstance(msg, transactions_pb2.ExportIcebergConfig): self.pretty_export_iceberg_config(msg) + elif isinstance(msg, transactions_pb2.ExportOutput): + self.pretty_export_output(msg) + elif isinstance(msg, transactions_pb2.ExportCSVOutput): + self.pretty_export_csv_output(msg) elif isinstance(msg, fragments_pb2.DebugInfo): self.pretty_debug_info(msg) elif isinstance(msg, logic_pb2.BeTreeConfig): diff --git a/sdks/python/src/lqp/proto/v1/transactions_pb2.py b/sdks/python/src/lqp/proto/v1/transactions_pb2.py index 7485f539..85e5708b 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\"\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\"\xee\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\x65xport\x12H\n\rexport_output\x18\x06 \x01(\x0b\x32!.relationalai.lqp.v1.ExportOutputH\x00R\x0c\x65xportOutputB\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\"\x95\x01\n\x0f\x45xportCSVOutput\x12\x43\n\ncsv_source\x18\x01 \x01(\x0b\x32$.relationalai.lqp.v1.ExportCSVSourceR\tcsvSource\x12=\n\ncsv_config\x18\x02 \x01(\x0b\x32\x1e.relationalai.lqp.v1.CSVConfigR\tcsvConfig\"Y\n\x0c\x45xportOutput\x12\x38\n\x03\x63sv\x18\x01 \x01(\x0b\x32$.relationalai.lqp.v1.ExportCSVOutputH\x00R\x03\x63svB\x0f\n\rexport_output*\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=4215 + _globals['_MAINTENANCELEVEL']._serialized_end=4350 _globals['_TRANSACTION']._serialized_start=134 _globals['_TRANSACTION']._serialized_end=322 _globals['_CONFIGURE']._serialized_start=324 @@ -73,15 +73,19 @@ _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['_READ']._serialized_end=3436 + _globals['_DEMAND']._serialized_start=3438 + _globals['_DEMAND']._serialized_end=3512 + _globals['_OUTPUT']._serialized_start=3514 + _globals['_OUTPUT']._serialized_end=3608 + _globals['_EXPORT']._serialized_start=3611 + _globals['_EXPORT']._serialized_end=3790 + _globals['_WHATIF']._serialized_start=3792 + _globals['_WHATIF']._serialized_end=3874 + _globals['_ABORT']._serialized_start=3876 + _globals['_ABORT']._serialized_end=3969 + _globals['_EXPORTCSVOUTPUT']._serialized_start=3972 + _globals['_EXPORTCSVOUTPUT']._serialized_end=4121 + _globals['_EXPORTOUTPUT']._serialized_start=4123 + _globals['_EXPORTOUTPUT']._serialized_end=4212 # @@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..be5666fe 100644 --- a/sdks/python/src/lqp/proto/v1/transactions_pb2.pyi +++ b/sdks/python/src/lqp/proto/v1/transactions_pb2.pyi @@ -178,18 +178,20 @@ class ExportIcebergConfig(_message.Message): def __init__(self, locator: _Optional[_Union[_logic_pb2.IcebergLocator, _Mapping]] = ..., config: _Optional[_Union[_logic_pb2.IcebergCatalogConfig, _Mapping]] = ..., table_def: _Optional[_Union[_logic_pb2.RelationId, _Mapping]] = ..., prefix: _Optional[str] = ..., target_file_size_bytes: _Optional[int] = ..., compression: _Optional[str] = ..., table_properties: _Optional[_Mapping[str, str]] = ...) -> None: ... class Read(_message.Message): - __slots__ = ("demand", "output", "what_if", "abort", "export") + __slots__ = ("demand", "output", "what_if", "abort", "export", "export_output") DEMAND_FIELD_NUMBER: _ClassVar[int] OUTPUT_FIELD_NUMBER: _ClassVar[int] WHAT_IF_FIELD_NUMBER: _ClassVar[int] ABORT_FIELD_NUMBER: _ClassVar[int] EXPORT_FIELD_NUMBER: _ClassVar[int] + EXPORT_OUTPUT_FIELD_NUMBER: _ClassVar[int] demand: Demand output: Output what_if: WhatIf abort: Abort export: Export - def __init__(self, demand: _Optional[_Union[Demand, _Mapping]] = ..., output: _Optional[_Union[Output, _Mapping]] = ..., what_if: _Optional[_Union[WhatIf, _Mapping]] = ..., abort: _Optional[_Union[Abort, _Mapping]] = ..., export: _Optional[_Union[Export, _Mapping]] = ...) -> None: ... + export_output: ExportOutput + def __init__(self, demand: _Optional[_Union[Demand, _Mapping]] = ..., output: _Optional[_Union[Output, _Mapping]] = ..., what_if: _Optional[_Union[WhatIf, _Mapping]] = ..., abort: _Optional[_Union[Abort, _Mapping]] = ..., export: _Optional[_Union[Export, _Mapping]] = ..., export_output: _Optional[_Union[ExportOutput, _Mapping]] = ...) -> None: ... class Demand(_message.Message): __slots__ = ("relation_id",) @@ -228,3 +230,17 @@ class Abort(_message.Message): name: str relation_id: _logic_pb2.RelationId def __init__(self, name: _Optional[str] = ..., relation_id: _Optional[_Union[_logic_pb2.RelationId, _Mapping]] = ...) -> None: ... + +class ExportCSVOutput(_message.Message): + __slots__ = ("csv_source", "csv_config") + CSV_SOURCE_FIELD_NUMBER: _ClassVar[int] + CSV_CONFIG_FIELD_NUMBER: _ClassVar[int] + csv_source: ExportCSVSource + csv_config: _logic_pb2.CSVConfig + def __init__(self, csv_source: _Optional[_Union[ExportCSVSource, _Mapping]] = ..., csv_config: _Optional[_Union[_logic_pb2.CSVConfig, _Mapping]] = ...) -> None: ... + +class ExportOutput(_message.Message): + __slots__ = ("csv",) + CSV_FIELD_NUMBER: _ClassVar[int] + csv: ExportCSVOutput + def __init__(self, csv: _Optional[_Union[ExportCSVOutput, _Mapping]] = ...) -> None: ... From 46d424c176ca7a1f271d187d2cdebb0b91da96d7 Mon Sep 17 00:00:00 2001 From: David Zhao Date: Thu, 18 Jun 2026 22:50:34 +1000 Subject: [PATCH 4/8] Add ExportOutput equality and relation collection to Julia SDK Co-Authored-By: Claude Opus 4.8 (1M context) --- .../LogicalQueryProtocol.jl/src/equality.jl | 32 +++++++++++++++++++ .../LogicalQueryProtocol.jl/src/properties.jl | 20 ++++++++++++ 2 files changed, 52 insertions(+) diff --git a/sdks/julia/LogicalQueryProtocol.jl/src/equality.jl b/sdks/julia/LogicalQueryProtocol.jl/src/equality.jl index 744d9de7..a81b4b85 100644 --- a/sdks/julia/LogicalQueryProtocol.jl/src/equality.jl +++ b/sdks/julia/LogicalQueryProtocol.jl/src/equality.jl @@ -478,6 +478,38 @@ function Base.isequal(a::Export, b::Export) _isequal_oneof(a.export_config, b.export_config) end +# 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 +function Base.:(==)(a::ExportCSVSource, b::ExportCSVSource) + _isequal_oneof(a.csv_source, b.csv_source) +end +function Base.hash(a::ExportCSVSource, h::UInt) + _hash_oneof(a.csv_source, h) +end +function Base.isequal(a::ExportCSVSource, b::ExportCSVSource) + _isequal_oneof(a.csv_source, b.csv_source) +end + +# ExportCSVOutput +Base.:(==)(a::ExportCSVOutput, b::ExportCSVOutput) = a.csv_source == b.csv_source && a.csv_config == b.csv_config +Base.hash(a::ExportCSVOutput, h::UInt) = hash(a.csv_config, hash(a.csv_source, h)) +Base.isequal(a::ExportCSVOutput, b::ExportCSVOutput) = isequal(a.csv_source, b.csv_source) && isequal(a.csv_config, b.csv_config) + +# ExportOutput +function Base.:(==)(a::ExportOutput, b::ExportOutput) + _isequal_oneof(a.export_output, b.export_output) +end +function Base.hash(a::ExportOutput, h::UInt) + _hash_oneof(a.export_output, h) +end +function Base.isequal(a::ExportOutput, b::ExportOutput) + _isequal_oneof(a.export_output, b.export_output) +end + # IVMConfig Base.:(==)(a::IVMConfig, b::IVMConfig) = a.level == b.level Base.hash(a::IVMConfig, h::UInt) = hash(a.level, h) diff --git a/sdks/julia/LogicalQueryProtocol.jl/src/properties.jl b/sdks/julia/LogicalQueryProtocol.jl/src/properties.jl index 1ad25287..7ee225d3 100644 --- a/sdks/julia/LogicalQueryProtocol.jl/src/properties.jl +++ b/sdks/julia/LogicalQueryProtocol.jl/src/properties.jl @@ -132,6 +132,8 @@ function _collect_read_ids!(ids::Set{LQPRelationId}, read::Read) _collect_read_ids!(ids, read.read_type[]::Abort) elseif read.read_type.name == :var"#export" _collect_read_ids!(ids, read.read_type[]::Export) + elseif read.read_type.name == :export_output + _collect_read_ids!(ids, read.read_type[]::ExportOutput) else @assert false end @@ -178,6 +180,24 @@ function _collect_read_ids!(ids::Set{LQPRelationId}, _export::Export) end return nothing end +function _collect_read_ids!(ids::Set{LQPRelationId}, export_output::ExportOutput) + isnothing(export_output.export_output) && return nothing + config = export_output.export_output + if config.name == :csv + csv_output = config[]::ExportCSVOutput + src = isnothing(csv_output.csv_source) ? nothing : csv_output.csv_source.csv_source + if !isnothing(src) + if src.name == :gnf_columns + for column in (src[]::ExportCSVColumns).columns + !isnothing(column.column_data) && push!(ids, persistent_id(column.column_data)) + end + elseif src.name == :table_def + push!(ids, persistent_id(src[]::RelationId)) + end + end + end + return nothing +end persistent_id(fragment::Fragment) = persistent_id(fragment.id::FragmentId) persistent_id(id::FragmentId) = LQPFragmentId(id.id) From f906238799c789b9a95d7afa4e51913511fffc84 Mon Sep 17 00:00:00 2001 From: David Zhao Date: Thu, 18 Jun 2026 22:51:17 +1000 Subject: [PATCH 5/8] Add ExportOutput test case and snapshots Co-Authored-By: Claude Opus 4.8 (1M context) --- tests/bin/csv_output.bin | Bin 0 -> 199 bytes tests/lqp/csv_output.lqp | 14 ++++++++++++++ tests/pretty/csv_output.lqp | 18 ++++++++++++++++++ tests/pretty_debug/csv_output.lqp | 25 +++++++++++++++++++++++++ 4 files changed, 57 insertions(+) create mode 100644 tests/bin/csv_output.bin create mode 100644 tests/lqp/csv_output.lqp create mode 100644 tests/pretty/csv_output.lqp create mode 100644 tests/pretty_debug/csv_output.lqp diff --git a/tests/bin/csv_output.bin b/tests/bin/csv_output.bin new file mode 100644 index 0000000000000000000000000000000000000000..5a11ccf122e52b8be26939376c1b7ab90efcd698 GIT binary patch literal 199 zcmd*e$koco)x^lf#>J9Wl$b6Q!xhCP#L2<+VS{K+>_tJHCT?wM|NV=FT(~&7 zn7J4$gqWllgv`B6xul9xbK(n%GIKLaGRsoq6H`*+bMy1^ODYReh1i5xgqQ>v;WWDt zD_FCX6jrlYN>YnUgba=JxpcWigs|Bz%E73_sH4TGWW=cC#i$p=T3V8(YXP!_gAo8f CEiD)T literal 0 HcmV?d00001 diff --git a/tests/lqp/csv_output.lqp b/tests/lqp/csv_output.lqp new file mode 100644 index 00000000..6b714613 --- /dev/null +++ b/tests/lqp/csv_output.lqp @@ -0,0 +1,14 @@ +(transaction + (epoch + (writes + (define + (fragment :frag + (def :test + ([x::INT] + (+ 1 1 x)))))) + + (reads + (output_export + (csv + (table_def :test) + (csv_config {})))))) diff --git a/tests/pretty/csv_output.lqp b/tests/pretty/csv_output.lqp new file mode 100644 index 00000000..bf0280a5 --- /dev/null +++ b/tests/pretty/csv_output.lqp @@ -0,0 +1,18 @@ +(transaction + (configure { :ivm.maintenance_level "off" :semantics_version 0}) + (epoch + (writes (define (fragment :frag (def :test ([x::INT] (+ 1 1 x)))))) + (reads + (output_export + (csv + (table_def :test) + (csv_config + { + :csv_compression "" + :csv_decimal_separator "." + :csv_delimiter "," + :csv_encoding "utf-8" + :csv_escapechar "\"" + :csv_header_row 1i32 + :csv_quotechar "\"" + :csv_skip 0})))))) diff --git a/tests/pretty_debug/csv_output.lqp b/tests/pretty_debug/csv_output.lqp new file mode 100644 index 00000000..bc63e654 --- /dev/null +++ b/tests/pretty_debug/csv_output.lqp @@ -0,0 +1,25 @@ +(transaction + (configure { :ivm.maintenance_level "off" :semantics_version 0}) + (epoch + (writes + (define + (fragment :frag (def 0xa3bf4f1b2b0b822cd15d6c15b0f00a08 ([x::INT] (+ 1 1 x)))))) + (reads + (output_export + (csv + (table_def 0xa3bf4f1b2b0b822cd15d6c15b0f00a08) + (csv_config + { + :csv_compression "" + :csv_decimal_separator "." + :csv_delimiter "," + :csv_encoding "utf-8" + :csv_escapechar "\"" + :csv_header_row 1i32 + :csv_quotechar "\"" + :csv_skip 0})))))) + +;; Debug information +;; ----------------------- +;; Original names +;; ID `0xa3bf4f1b2b0b822cd15d6c15b0f00a08` -> `test` From 6c4eedaf7665c281851867a275ede5087d3a7d7f Mon Sep 17 00:00:00 2001 From: David Zhao Date: Thu, 18 Jun 2026 22:53:41 +1000 Subject: [PATCH 6/8] Update LQP version in uv.lock --- sdks/python/uv.lock | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) 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" }, From 1232fb4a0c578a63113b163da0524b4eb88f0958 Mon Sep 17 00:00:00 2001 From: David Zhao Date: Fri, 19 Jun 2026 10:24:23 +1000 Subject: [PATCH 7/8] Rename grammar keyword output_export to export_output Co-Authored-By: Claude Opus 4.8 (1M context) --- meta/src/meta/grammar.y | 2 +- sdks/go/src/parser.go | 10 +++++----- sdks/go/src/pretty.go | 2 +- sdks/julia/LogicalQueryProtocol.jl/src/parser.jl | 10 +++++----- sdks/julia/LogicalQueryProtocol.jl/src/pretty.jl | 2 +- sdks/python/src/lqp/gen/parser.py | 10 +++++----- sdks/python/src/lqp/gen/pretty.py | 2 +- tests/lqp/csv_output.lqp | 2 +- tests/pretty/csv_output.lqp | 2 +- tests/pretty_debug/csv_output.lqp | 2 +- 10 files changed, 22 insertions(+), 22 deletions(-) diff --git a/meta/src/meta/grammar.y b/meta/src/meta/grammar.y index 17945067..dc3a41d1 100644 --- a/meta/src/meta/grammar.y +++ b/meta/src/meta/grammar.y @@ -1339,7 +1339,7 @@ export # Like `export`, but the engine treats the result as part of the transaction results # and chooses the output path itself (so no `path` is specified here). export_output - : "(" "output_export" export_csv_output ")" + : "(" "export_output" export_csv_output ")" construct: $$ = transactions.ExportOutput(csv=$3) deconstruct if builtin.has_proto_field($$, 'csv'): $3: transactions.ExportCSVOutput = $$.csv diff --git a/sdks/go/src/parser.go b/sdks/go/src/parser.go index 1514fad8..57204608 100644 --- a/sdks/go/src/parser.go +++ b/sdks/go/src/parser.go @@ -4696,12 +4696,12 @@ func (p *Parser) parse_read() *pb.Read { _t2040 = 2 } else { var _t2041 int64 - if p.matchLookaheadLiteral("output_export", 1) { - _t2041 = 5 + if p.matchLookaheadLiteral("output", 1) { + _t2041 = 1 } else { var _t2042 int64 - if p.matchLookaheadLiteral("output", 1) { - _t2042 = 1 + if p.matchLookaheadLiteral("export_output", 1) { + _t2042 = 5 } else { var _t2043 int64 if p.matchLookaheadLiteral("export_iceberg", 1) { @@ -5129,7 +5129,7 @@ func (p *Parser) parse_iceberg_table_properties() [][]interface{} { func (p *Parser) parse_export_output() *pb.ExportOutput { span_start1344 := int64(p.spanStart()) p.consumeLiteral("(") - p.consumeLiteral("output_export") + p.consumeLiteral("export_output") _t2121 := p.parse_export_csv_output() export_csv_output1343 := _t2121 p.consumeLiteral(")") diff --git a/sdks/go/src/pretty.go b/sdks/go/src/pretty.go index 65770285..b0e3cb3f 100644 --- a/sdks/go/src/pretty.go +++ b/sdks/go/src/pretty.go @@ -5030,7 +5030,7 @@ func (p *PrettyPrinter) pretty_export_output(msg *pb.ExportOutput) interface{} { fields1610 := _t1763 unwrapped_fields1611 := fields1610 p.write("(") - p.write("output_export") + p.write("export_output") p.indentSexp() p.newline() p.pretty_export_csv_output(unwrapped_fields1611) diff --git a/sdks/julia/LogicalQueryProtocol.jl/src/parser.jl b/sdks/julia/LogicalQueryProtocol.jl/src/parser.jl index 360e6aa0..a539d18c 100644 --- a/sdks/julia/LogicalQueryProtocol.jl/src/parser.jl +++ b/sdks/julia/LogicalQueryProtocol.jl/src/parser.jl @@ -4018,11 +4018,11 @@ function parse_read(parser::ParserState)::Proto.Read if match_lookahead_literal(parser, "what_if", 1) _t2027 = 2 else - if match_lookahead_literal(parser, "output_export", 1) - _t2028 = 5 + if match_lookahead_literal(parser, "output", 1) + _t2028 = 1 else - if match_lookahead_literal(parser, "output", 1) - _t2029 = 1 + if match_lookahead_literal(parser, "export_output", 1) + _t2029 = 5 else if match_lookahead_literal(parser, "export_iceberg", 1) _t2030 = 4 @@ -4417,7 +4417,7 @@ end function parse_export_output(parser::ParserState)::Proto.ExportOutput span_start1344 = span_start(parser) consume_literal!(parser, "(") - consume_literal!(parser, "output_export") + consume_literal!(parser, "export_output") _t2108 = parse_export_csv_output(parser) export_csv_output1343 = _t2108 consume_literal!(parser, ")") diff --git a/sdks/julia/LogicalQueryProtocol.jl/src/pretty.jl b/sdks/julia/LogicalQueryProtocol.jl/src/pretty.jl index f4551822..ffce8b41 100644 --- a/sdks/julia/LogicalQueryProtocol.jl/src/pretty.jl +++ b/sdks/julia/LogicalQueryProtocol.jl/src/pretty.jl @@ -5101,7 +5101,7 @@ function pretty_export_output(pp::PrettyPrinter, msg::Proto.ExportOutput) end fields1610 = _t1802 unwrapped_fields1611 = fields1610 - write(pp, "(output_export") + write(pp, "(export_output") indent_sexp!(pp) newline(pp) pretty_export_csv_output(pp, unwrapped_fields1611) diff --git a/sdks/python/src/lqp/gen/parser.py b/sdks/python/src/lqp/gen/parser.py index 02845b09..8556c158 100644 --- a/sdks/python/src/lqp/gen/parser.py +++ b/sdks/python/src/lqp/gen/parser.py @@ -3664,11 +3664,11 @@ def parse_read(self) -> transactions_pb2.Read: if self.match_lookahead_literal("what_if", 1): _t2027 = 2 else: - if self.match_lookahead_literal("output_export", 1): - _t2028 = 5 + if self.match_lookahead_literal("output", 1): + _t2028 = 1 else: - if self.match_lookahead_literal("output", 1): - _t2029 = 1 + if self.match_lookahead_literal("export_output", 1): + _t2029 = 5 else: if self.match_lookahead_literal("export_iceberg", 1): _t2030 = 4 @@ -4015,7 +4015,7 @@ def parse_iceberg_table_properties(self) -> Sequence[tuple[str, str]]: def parse_export_output(self) -> transactions_pb2.ExportOutput: span_start1344 = self.span_start() self.consume_literal("(") - self.consume_literal("output_export") + self.consume_literal("export_output") _t2108 = self.parse_export_csv_output() export_csv_output1343 = _t2108 self.consume_literal(")") diff --git a/sdks/python/src/lqp/gen/pretty.py b/sdks/python/src/lqp/gen/pretty.py index 7b4a5fa9..ec5ce3b5 100644 --- a/sdks/python/src/lqp/gen/pretty.py +++ b/sdks/python/src/lqp/gen/pretty.py @@ -4407,7 +4407,7 @@ def pretty_export_output(self, msg: transactions_pb2.ExportOutput): fields1610 = _t1763 assert fields1610 is not None unwrapped_fields1611 = fields1610 - self.write("(output_export") + self.write("(export_output") self.indent_sexp() self.newline() self.pretty_export_csv_output(unwrapped_fields1611) diff --git a/tests/lqp/csv_output.lqp b/tests/lqp/csv_output.lqp index 6b714613..cea04fe9 100644 --- a/tests/lqp/csv_output.lqp +++ b/tests/lqp/csv_output.lqp @@ -8,7 +8,7 @@ (+ 1 1 x)))))) (reads - (output_export + (export_output (csv (table_def :test) (csv_config {})))))) diff --git a/tests/pretty/csv_output.lqp b/tests/pretty/csv_output.lqp index bf0280a5..07132c1e 100644 --- a/tests/pretty/csv_output.lqp +++ b/tests/pretty/csv_output.lqp @@ -3,7 +3,7 @@ (epoch (writes (define (fragment :frag (def :test ([x::INT] (+ 1 1 x)))))) (reads - (output_export + (export_output (csv (table_def :test) (csv_config diff --git a/tests/pretty_debug/csv_output.lqp b/tests/pretty_debug/csv_output.lqp index bc63e654..ba62e0b3 100644 --- a/tests/pretty_debug/csv_output.lqp +++ b/tests/pretty_debug/csv_output.lqp @@ -5,7 +5,7 @@ (define (fragment :frag (def 0xa3bf4f1b2b0b822cd15d6c15b0f00a08 ([x::INT] (+ 1 1 x)))))) (reads - (output_export + (export_output (csv (table_def 0xa3bf4f1b2b0b822cd15d6c15b0f00a08) (csv_config From d351946d683da68b04f8a9fb2787ba642b03e772 Mon Sep 17 00:00:00 2001 From: David Zhao Date: Fri, 19 Jun 2026 14:30:09 +1000 Subject: [PATCH 8/8] Add name field to ExportOutput Co-Authored-By: Claude Opus 4.8 (1M context) --- meta/src/meta/grammar.y | 7 +- proto/relationalai/lqp/v1/transactions.proto | 4 +- sdks/go/src/lqp/v1/transactions.pb.go | 51 +- sdks/go/src/parser.go | 5582 +++++++++-------- sdks/go/src/pretty.go | 3904 ++++++------ .../LogicalQueryProtocol.jl/src/equality.jl | 6 +- .../relationalai/lqp/v1/transactions_pb.jl | 18 +- .../LogicalQueryProtocol.jl/src/parser.jl | 4598 +++++++------- .../LogicalQueryProtocol.jl/src/pretty.jl | 3934 ++++++------ sdks/python/src/lqp/gen/parser.py | 4764 +++++++------- sdks/python/src/lqp/gen/pretty.py | 4470 ++++++------- .../src/lqp/proto/v1/transactions_pb2.py | 8 +- .../src/lqp/proto/v1/transactions_pb2.pyi | 6 +- tests/bin/csv_output.bin | Bin 199 -> 210 bytes tests/lqp/csv_output.lqp | 2 +- tests/pretty/csv_output.lqp | 1 + tests/pretty_debug/csv_output.lqp | 1 + 17 files changed, 13698 insertions(+), 13658 deletions(-) diff --git a/meta/src/meta/grammar.y b/meta/src/meta/grammar.y index dc3a41d1..c1098d64 100644 --- a/meta/src/meta/grammar.y +++ b/meta/src/meta/grammar.y @@ -1339,10 +1339,11 @@ export # Like `export`, but the engine treats the result as part of the transaction results # and chooses the output path itself (so no `path` is specified here). export_output - : "(" "export_output" export_csv_output ")" - construct: $$ = transactions.ExportOutput(csv=$3) + : "(" "export_output" name export_csv_output ")" + construct: $$ = transactions.ExportOutput(name=$3, csv=$4) deconstruct if builtin.has_proto_field($$, 'csv'): - $3: transactions.ExportCSVOutput = $$.csv + $3: String = $$.name + $4: transactions.ExportCSVOutput = $$.csv export_csv_output : "(" "csv" export_csv_source csv_config ")" diff --git a/proto/relationalai/lqp/v1/transactions.proto b/proto/relationalai/lqp/v1/transactions.proto index ccceb560..f92c8cd0 100644 --- a/proto/relationalai/lqp/v1/transactions.proto +++ b/proto/relationalai/lqp/v1/transactions.proto @@ -182,9 +182,11 @@ message ExportCSVOutput { } message ExportOutput { + string name = 1; + // Supports export formats e.g., CSV and Iceberg, but considered to be part of txn results oneof export_output { - ExportCSVOutput csv = 1; + ExportCSVOutput csv = 2; } } diff --git a/sdks/go/src/lqp/v1/transactions.pb.go b/sdks/go/src/lqp/v1/transactions.pb.go index 2096e0aa..cfe67896 100644 --- a/sdks/go/src/lqp/v1/transactions.pb.go +++ b/sdks/go/src/lqp/v1/transactions.pb.go @@ -1558,6 +1558,7 @@ func (x *ExportCSVOutput) GetCsvConfig() *CSVConfig { type ExportOutput struct { state protoimpl.MessageState `protogen:"open.v1"` + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` // Supports export formats e.g., CSV and Iceberg, but considered to be part of txn results // // Types that are valid to be assigned to ExportOutput: @@ -1598,6 +1599,13 @@ func (*ExportOutput) Descriptor() ([]byte, []int) { return file_relationalai_lqp_v1_transactions_proto_rawDescGZIP(), []int{23} } +func (x *ExportOutput) GetName() string { + if x != nil { + return x.Name + } + return "" +} + func (x *ExportOutput) GetExportOutput() isExportOutput_ExportOutput { if x != nil { return x.ExportOutput @@ -1619,7 +1627,7 @@ type isExportOutput_ExportOutput interface { } type ExportOutput_Csv struct { - Csv *ExportCSVOutput `protobuf:"bytes,1,opt,name=csv,proto3,oneof"` + Csv *ExportCSVOutput `protobuf:"bytes,2,opt,name=csv,proto3,oneof"` } func (*ExportOutput_Csv) isExportOutput_ExportOutput() {} @@ -1884,26 +1892,27 @@ var file_relationalai_lqp_v1_transactions_proto_rawDesc = string([]byte{ 0x76, 0x5f, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x53, 0x56, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x52, 0x09, - 0x63, 0x73, 0x76, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x22, 0x59, 0x0a, 0x0c, 0x45, 0x78, 0x70, - 0x6f, 0x72, 0x74, 0x4f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x12, 0x38, 0x0a, 0x03, 0x63, 0x73, 0x76, - 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, 0x4f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x48, 0x00, 0x52, 0x03, - 0x63, 0x73, 0x76, 0x42, 0x0f, 0x0a, 0x0d, 0x65, 0x78, 0x70, 0x6f, 0x72, 0x74, 0x5f, 0x6f, 0x75, - 0x74, 0x70, 0x75, 0x74, 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, + 0x63, 0x73, 0x76, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x22, 0x6d, 0x0a, 0x0c, 0x45, 0x78, 0x70, + 0x6f, 0x72, 0x74, 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, 0x38, 0x0a, + 0x03, 0x63, 0x73, 0x76, 0x18, 0x02, 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, 0x4f, 0x75, 0x74, 0x70, 0x75, 0x74, + 0x48, 0x00, 0x52, 0x03, 0x63, 0x73, 0x76, 0x42, 0x0f, 0x0a, 0x0d, 0x65, 0x78, 0x70, 0x6f, 0x72, + 0x74, 0x5f, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 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 57204608..4c39422c 100644 --- a/sdks/go/src/parser.go +++ b/sdks/go/src/parser.go @@ -655,170 +655,170 @@ func toPascalCase(s string) string { // --- Helper functions --- func (p *Parser) _extract_value_int32(value *pb.Value, default_ int64) int32 { - var _t2126 interface{} + var _t2129 interface{} if (value != nil && hasProtoField(value, "int32_value")) { return value.GetInt32Value() } - _ = _t2126 + _ = _t2129 return int32(default_) } func (p *Parser) _extract_value_int64(value *pb.Value, default_ int64) int64 { - var _t2127 interface{} + var _t2130 interface{} if (value != nil && hasProtoField(value, "int_value")) { return value.GetIntValue() } - _ = _t2127 + _ = _t2130 return default_ } func (p *Parser) _extract_value_string(value *pb.Value, default_ string) string { - var _t2128 interface{} + var _t2131 interface{} if (value != nil && hasProtoField(value, "string_value")) { return value.GetStringValue() } - _ = _t2128 + _ = _t2131 return default_ } func (p *Parser) _extract_value_boolean(value *pb.Value, default_ bool) bool { - var _t2129 interface{} + var _t2132 interface{} if (value != nil && hasProtoField(value, "boolean_value")) { return value.GetBooleanValue() } - _ = _t2129 + _ = _t2132 return default_ } func (p *Parser) _extract_value_string_list(value *pb.Value, default_ []string) []string { - var _t2130 interface{} + var _t2133 interface{} if (value != nil && hasProtoField(value, "string_value")) { return []string{value.GetStringValue()} } - _ = _t2130 + _ = _t2133 return default_ } func (p *Parser) _try_extract_value_int64(value *pb.Value) *int64 { - var _t2131 interface{} + var _t2134 interface{} if (value != nil && hasProtoField(value, "int_value")) { return ptr(value.GetIntValue()) } - _ = _t2131 + _ = _t2134 return nil } func (p *Parser) _try_extract_value_float64(value *pb.Value) *float64 { - var _t2132 interface{} + var _t2135 interface{} if (value != nil && hasProtoField(value, "float_value")) { return ptr(value.GetFloatValue()) } - _ = _t2132 + _ = _t2135 return nil } func (p *Parser) _try_extract_value_bytes(value *pb.Value) []byte { - var _t2133 interface{} + var _t2136 interface{} if (value != nil && hasProtoField(value, "string_value")) { return []byte(value.GetStringValue()) } - _ = _t2133 + _ = _t2136 return nil } func (p *Parser) _try_extract_value_uint128(value *pb.Value) *pb.UInt128Value { - var _t2134 interface{} + var _t2137 interface{} if (value != nil && hasProtoField(value, "uint128_value")) { return value.GetUint128Value() } - _ = _t2134 + _ = _t2137 return nil } func (p *Parser) construct_csv_config(config_dict [][]interface{}, storage_integration_opt [][]interface{}) *pb.CSVConfig { config := dictFromList(config_dict) - _t2135 := p._extract_value_int32(dictGetValue(config, "csv_header_row"), 1) - header_row := _t2135 - _t2136 := p._extract_value_int64(dictGetValue(config, "csv_skip"), 0) - skip := _t2136 - _t2137 := p._extract_value_string(dictGetValue(config, "csv_new_line"), "") - new_line := _t2137 - _t2138 := p._extract_value_string(dictGetValue(config, "csv_delimiter"), ",") - delimiter := _t2138 - _t2139 := p._extract_value_string(dictGetValue(config, "csv_quotechar"), "\"") - quotechar := _t2139 - _t2140 := p._extract_value_string(dictGetValue(config, "csv_escapechar"), "\"") - escapechar := _t2140 - _t2141 := p._extract_value_string(dictGetValue(config, "csv_comment"), "") - comment := _t2141 - _t2142 := p._extract_value_string_list(dictGetValue(config, "csv_missing_strings"), []string{}) - missing_strings := _t2142 - _t2143 := p._extract_value_string(dictGetValue(config, "csv_decimal_separator"), ".") - decimal_separator := _t2143 - _t2144 := p._extract_value_string(dictGetValue(config, "csv_encoding"), "utf-8") - encoding := _t2144 - _t2145 := p._extract_value_string(dictGetValue(config, "csv_compression"), "") - compression := _t2145 - _t2146 := p._extract_value_int64(dictGetValue(config, "csv_partition_size_mb"), 0) - partition_size_mb := _t2146 - _t2147 := p.construct_csv_storage_integration(storage_integration_opt) - storage_integration := _t2147 - _t2148 := &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 _t2148 + _t2138 := p._extract_value_int32(dictGetValue(config, "csv_header_row"), 1) + header_row := _t2138 + _t2139 := p._extract_value_int64(dictGetValue(config, "csv_skip"), 0) + skip := _t2139 + _t2140 := p._extract_value_string(dictGetValue(config, "csv_new_line"), "") + new_line := _t2140 + _t2141 := p._extract_value_string(dictGetValue(config, "csv_delimiter"), ",") + delimiter := _t2141 + _t2142 := p._extract_value_string(dictGetValue(config, "csv_quotechar"), "\"") + quotechar := _t2142 + _t2143 := p._extract_value_string(dictGetValue(config, "csv_escapechar"), "\"") + escapechar := _t2143 + _t2144 := p._extract_value_string(dictGetValue(config, "csv_comment"), "") + comment := _t2144 + _t2145 := p._extract_value_string_list(dictGetValue(config, "csv_missing_strings"), []string{}) + missing_strings := _t2145 + _t2146 := p._extract_value_string(dictGetValue(config, "csv_decimal_separator"), ".") + decimal_separator := _t2146 + _t2147 := p._extract_value_string(dictGetValue(config, "csv_encoding"), "utf-8") + encoding := _t2147 + _t2148 := p._extract_value_string(dictGetValue(config, "csv_compression"), "") + compression := _t2148 + _t2149 := p._extract_value_int64(dictGetValue(config, "csv_partition_size_mb"), 0) + partition_size_mb := _t2149 + _t2150 := p.construct_csv_storage_integration(storage_integration_opt) + storage_integration := _t2150 + _t2151 := &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 _t2151 } func (p *Parser) construct_csv_storage_integration(storage_integration_opt [][]interface{}) *pb.StorageIntegration { - var _t2149 interface{} + var _t2152 interface{} if storage_integration_opt == nil { return nil } - _ = _t2149 + _ = _t2152 config := dictFromList(storage_integration_opt) - _t2150 := p._extract_value_string(dictGetValue(config, "provider"), "") - _t2151 := p._extract_value_string(dictGetValue(config, "azure_sas_token"), "") - _t2152 := p._extract_value_string(dictGetValue(config, "s3_region"), "") - _t2153 := p._extract_value_string(dictGetValue(config, "s3_access_key_id"), "") - _t2154 := p._extract_value_string(dictGetValue(config, "s3_secret_access_key"), "") - _t2155 := &pb.StorageIntegration{Provider: _t2150, AzureSasToken: _t2151, S3Region: _t2152, S3AccessKeyId: _t2153, S3SecretAccessKey: _t2154} - return _t2155 + _t2153 := p._extract_value_string(dictGetValue(config, "provider"), "") + _t2154 := p._extract_value_string(dictGetValue(config, "azure_sas_token"), "") + _t2155 := p._extract_value_string(dictGetValue(config, "s3_region"), "") + _t2156 := p._extract_value_string(dictGetValue(config, "s3_access_key_id"), "") + _t2157 := p._extract_value_string(dictGetValue(config, "s3_secret_access_key"), "") + _t2158 := &pb.StorageIntegration{Provider: _t2153, AzureSasToken: _t2154, S3Region: _t2155, S3AccessKeyId: _t2156, S3SecretAccessKey: _t2157} + return _t2158 } func (p *Parser) construct_betree_info(key_types []*pb.Type, value_types []*pb.Type, config_dict [][]interface{}) *pb.BeTreeInfo { config := dictFromList(config_dict) - _t2156 := p._try_extract_value_float64(dictGetValue(config, "betree_config_epsilon")) - epsilon := _t2156 - _t2157 := p._try_extract_value_int64(dictGetValue(config, "betree_config_max_pivots")) - max_pivots := _t2157 - _t2158 := p._try_extract_value_int64(dictGetValue(config, "betree_config_max_deltas")) - max_deltas := _t2158 - _t2159 := p._try_extract_value_int64(dictGetValue(config, "betree_config_max_leaf")) - max_leaf := _t2159 - _t2160 := &pb.BeTreeConfig{Epsilon: deref(epsilon, 0.0), MaxPivots: deref(max_pivots, 0), MaxDeltas: deref(max_deltas, 0), MaxLeaf: deref(max_leaf, 0)} - storage_config := _t2160 - _t2161 := p._try_extract_value_uint128(dictGetValue(config, "betree_locator_root_pageid")) - root_pageid := _t2161 - _t2162 := p._try_extract_value_bytes(dictGetValue(config, "betree_locator_inline_data")) - inline_data := _t2162 - _t2163 := p._try_extract_value_int64(dictGetValue(config, "betree_locator_element_count")) - element_count := _t2163 - _t2164 := p._try_extract_value_int64(dictGetValue(config, "betree_locator_tree_height")) - tree_height := _t2164 - _t2165 := &pb.BeTreeLocator{ElementCount: deref(element_count, 0), TreeHeight: deref(tree_height, 0)} + _t2159 := p._try_extract_value_float64(dictGetValue(config, "betree_config_epsilon")) + epsilon := _t2159 + _t2160 := p._try_extract_value_int64(dictGetValue(config, "betree_config_max_pivots")) + max_pivots := _t2160 + _t2161 := p._try_extract_value_int64(dictGetValue(config, "betree_config_max_deltas")) + max_deltas := _t2161 + _t2162 := p._try_extract_value_int64(dictGetValue(config, "betree_config_max_leaf")) + max_leaf := _t2162 + _t2163 := &pb.BeTreeConfig{Epsilon: deref(epsilon, 0.0), MaxPivots: deref(max_pivots, 0), MaxDeltas: deref(max_deltas, 0), MaxLeaf: deref(max_leaf, 0)} + storage_config := _t2163 + _t2164 := p._try_extract_value_uint128(dictGetValue(config, "betree_locator_root_pageid")) + root_pageid := _t2164 + _t2165 := p._try_extract_value_bytes(dictGetValue(config, "betree_locator_inline_data")) + inline_data := _t2165 + _t2166 := p._try_extract_value_int64(dictGetValue(config, "betree_locator_element_count")) + element_count := _t2166 + _t2167 := p._try_extract_value_int64(dictGetValue(config, "betree_locator_tree_height")) + tree_height := _t2167 + _t2168 := &pb.BeTreeLocator{ElementCount: deref(element_count, 0), TreeHeight: deref(tree_height, 0)} if root_pageid != nil { - _t2165.Location = &pb.BeTreeLocator_RootPageid{RootPageid: root_pageid} + _t2168.Location = &pb.BeTreeLocator_RootPageid{RootPageid: root_pageid} } else { - _t2165.Location = &pb.BeTreeLocator_InlineData{InlineData: inline_data} + _t2168.Location = &pb.BeTreeLocator_InlineData{InlineData: inline_data} } - relation_locator := _t2165 - _t2166 := &pb.BeTreeInfo{KeyTypes: key_types, ValueTypes: value_types, StorageConfig: storage_config, RelationLocator: relation_locator} - return _t2166 + relation_locator := _t2168 + _t2169 := &pb.BeTreeInfo{KeyTypes: key_types, ValueTypes: value_types, StorageConfig: storage_config, RelationLocator: relation_locator} + return _t2169 } func (p *Parser) default_configure() *pb.Configure { - _t2167 := &pb.IVMConfig{Level: pb.MaintenanceLevel_MAINTENANCE_LEVEL_OFF} - ivm_config := _t2167 - _t2168 := &pb.Configure{SemanticsVersion: 0, IvmConfig: ivm_config} - return _t2168 + _t2170 := &pb.IVMConfig{Level: pb.MaintenanceLevel_MAINTENANCE_LEVEL_OFF} + ivm_config := _t2170 + _t2171 := &pb.Configure{SemanticsVersion: 0, IvmConfig: ivm_config} + return _t2171 } func (p *Parser) construct_configure(config_dict [][]interface{}) *pb.Configure { @@ -840,4319 +840,4321 @@ func (p *Parser) construct_configure(config_dict [][]interface{}) *pb.Configure } } } - _t2169 := &pb.IVMConfig{Level: maintenance_level} - ivm_config := _t2169 - _t2170 := p._extract_value_int64(dictGetValue(config, "semantics_version"), 0) - semantics_version := _t2170 - _t2171 := &pb.Configure{SemanticsVersion: semantics_version, IvmConfig: ivm_config} - return _t2171 + _t2172 := &pb.IVMConfig{Level: maintenance_level} + ivm_config := _t2172 + _t2173 := p._extract_value_int64(dictGetValue(config, "semantics_version"), 0) + semantics_version := _t2173 + _t2174 := &pb.Configure{SemanticsVersion: semantics_version, IvmConfig: ivm_config} + return _t2174 } func (p *Parser) construct_export_csv_config(path string, columns []*pb.ExportCSVColumn, config_dict [][]interface{}) *pb.ExportCSVConfig { config := dictFromList(config_dict) - _t2172 := p._extract_value_int64(dictGetValue(config, "partition_size"), 0) - partition_size := _t2172 - _t2173 := p._extract_value_string(dictGetValue(config, "compression"), "") - compression := _t2173 - _t2174 := p._extract_value_boolean(dictGetValue(config, "syntax_header_row"), true) - syntax_header_row := _t2174 - _t2175 := p._extract_value_string(dictGetValue(config, "syntax_missing_string"), "") - syntax_missing_string := _t2175 - _t2176 := p._extract_value_string(dictGetValue(config, "syntax_delim"), ",") - syntax_delim := _t2176 - _t2177 := p._extract_value_string(dictGetValue(config, "syntax_quotechar"), "\"") - syntax_quotechar := _t2177 - _t2178 := p._extract_value_string(dictGetValue(config, "syntax_escapechar"), "\\") - syntax_escapechar := _t2178 - _t2179 := &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 _t2179 + _t2175 := p._extract_value_int64(dictGetValue(config, "partition_size"), 0) + partition_size := _t2175 + _t2176 := p._extract_value_string(dictGetValue(config, "compression"), "") + compression := _t2176 + _t2177 := p._extract_value_boolean(dictGetValue(config, "syntax_header_row"), true) + syntax_header_row := _t2177 + _t2178 := p._extract_value_string(dictGetValue(config, "syntax_missing_string"), "") + syntax_missing_string := _t2178 + _t2179 := p._extract_value_string(dictGetValue(config, "syntax_delim"), ",") + syntax_delim := _t2179 + _t2180 := p._extract_value_string(dictGetValue(config, "syntax_quotechar"), "\"") + syntax_quotechar := _t2180 + _t2181 := p._extract_value_string(dictGetValue(config, "syntax_escapechar"), "\\") + syntax_escapechar := _t2181 + _t2182 := &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 _t2182 } func (p *Parser) construct_export_csv_config_with_source(path string, csv_source *pb.ExportCSVSource, csv_config *pb.CSVConfig) *pb.ExportCSVConfig { - _t2180 := &pb.ExportCSVConfig{Path: path, CsvSource: csv_source, CsvConfig: csv_config} - return _t2180 + _t2183 := &pb.ExportCSVConfig{Path: path, CsvSource: csv_source, CsvConfig: csv_config} + return _t2183 } 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) - _t2181 := &pb.IcebergCatalogConfig{CatalogUri: catalog_uri, Scope: ptr(deref(scope_opt, "")), Properties: props, AuthProperties: auth_props} - return _t2181 + _t2184 := &pb.IcebergCatalogConfig{CatalogUri: catalog_uri, Scope: ptr(deref(scope_opt, "")), Properties: props, AuthProperties: auth_props} + return _t2184 } 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 { - _t2182 := &pb.IcebergData{Locator: locator, Config: config, Columns: columns, FromSnapshot: ptr(deref(from_snapshot_opt, "")), ToSnapshot: ptr(deref(to_snapshot_opt, "")), ReturnsDelta: returns_delta} - return _t2182 + _t2185 := &pb.IcebergData{Locator: locator, Config: config, Columns: columns, FromSnapshot: ptr(deref(from_snapshot_opt, "")), ToSnapshot: ptr(deref(to_snapshot_opt, "")), ReturnsDelta: returns_delta} + return _t2185 } 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 { - _t2183 := config_dict + _t2186 := config_dict if config_dict == nil { - _t2183 = [][]interface{}{} - } - cfg := dictFromList(_t2183) - _t2184 := p._extract_value_string(dictGetValue(cfg, "prefix"), "") - prefix := _t2184 - _t2185 := p._extract_value_int64(dictGetValue(cfg, "target_file_size_bytes"), 0) - target_file_size_bytes := _t2185 - _t2186 := p._extract_value_string(dictGetValue(cfg, "compression"), "") - compression := _t2186 + _t2186 = [][]interface{}{} + } + cfg := dictFromList(_t2186) + _t2187 := p._extract_value_string(dictGetValue(cfg, "prefix"), "") + prefix := _t2187 + _t2188 := p._extract_value_int64(dictGetValue(cfg, "target_file_size_bytes"), 0) + target_file_size_bytes := _t2188 + _t2189 := p._extract_value_string(dictGetValue(cfg, "compression"), "") + compression := _t2189 table_props := stringMapFromPairs(table_property_pairs) - _t2187 := &pb.ExportIcebergConfig{Locator: locator, Config: config, TableDef: table_def, Prefix: ptr(prefix), TargetFileSizeBytes: ptr(target_file_size_bytes), Compression: compression, TableProperties: table_props} - return _t2187 + _t2190 := &pb.ExportIcebergConfig{Locator: locator, Config: config, TableDef: table_def, Prefix: ptr(prefix), TargetFileSizeBytes: ptr(target_file_size_bytes), Compression: compression, TableProperties: table_props} + return _t2190 } // --- Parse functions --- func (p *Parser) parse_transaction() *pb.Transaction { - span_start681 := int64(p.spanStart()) + span_start682 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("transaction") - var _t1350 *pb.Configure + var _t1352 *pb.Configure if (p.matchLookaheadLiteral("(", 0) && p.matchLookaheadLiteral("configure", 1)) { - _t1351 := p.parse_configure() - _t1350 = _t1351 - } - configure675 := _t1350 - var _t1352 *pb.Sync - if (p.matchLookaheadLiteral("(", 0) && p.matchLookaheadLiteral("sync", 1)) { - _t1353 := p.parse_sync() + _t1353 := p.parse_configure() _t1352 = _t1353 } - sync676 := _t1352 - xs677 := []*pb.Epoch{} - cond678 := p.matchLookaheadLiteral("(", 0) - for cond678 { - _t1354 := p.parse_epoch() - item679 := _t1354 - xs677 = append(xs677, item679) - cond678 = p.matchLookaheadLiteral("(", 0) - } - epochs680 := xs677 + configure676 := _t1352 + var _t1354 *pb.Sync + if (p.matchLookaheadLiteral("(", 0) && p.matchLookaheadLiteral("sync", 1)) { + _t1355 := p.parse_sync() + _t1354 = _t1355 + } + sync677 := _t1354 + xs678 := []*pb.Epoch{} + cond679 := p.matchLookaheadLiteral("(", 0) + for cond679 { + _t1356 := p.parse_epoch() + item680 := _t1356 + xs678 = append(xs678, item680) + cond679 = p.matchLookaheadLiteral("(", 0) + } + epochs681 := xs678 p.consumeLiteral(")") - _t1355 := p.default_configure() - _t1356 := configure675 - if configure675 == nil { - _t1356 = _t1355 + _t1357 := p.default_configure() + _t1358 := configure676 + if configure676 == nil { + _t1358 = _t1357 } - _t1357 := &pb.Transaction{Epochs: epochs680, Configure: _t1356, Sync: sync676} - result682 := _t1357 - p.recordSpan(int(span_start681), "Transaction") - return result682 + _t1359 := &pb.Transaction{Epochs: epochs681, Configure: _t1358, Sync: sync677} + result683 := _t1359 + p.recordSpan(int(span_start682), "Transaction") + return result683 } func (p *Parser) parse_configure() *pb.Configure { - span_start684 := int64(p.spanStart()) + span_start685 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("configure") - _t1358 := p.parse_config_dict() - config_dict683 := _t1358 + _t1360 := p.parse_config_dict() + config_dict684 := _t1360 p.consumeLiteral(")") - _t1359 := p.construct_configure(config_dict683) - result685 := _t1359 - p.recordSpan(int(span_start684), "Configure") - return result685 + _t1361 := p.construct_configure(config_dict684) + result686 := _t1361 + p.recordSpan(int(span_start685), "Configure") + return result686 } func (p *Parser) parse_config_dict() [][]interface{} { p.consumeLiteral("{") - xs686 := [][]interface{}{} - cond687 := p.matchLookaheadLiteral(":", 0) - for cond687 { - _t1360 := p.parse_config_key_value() - item688 := _t1360 - xs686 = append(xs686, item688) - cond687 = p.matchLookaheadLiteral(":", 0) - } - config_key_values689 := xs686 + xs687 := [][]interface{}{} + cond688 := p.matchLookaheadLiteral(":", 0) + for cond688 { + _t1362 := p.parse_config_key_value() + item689 := _t1362 + xs687 = append(xs687, item689) + cond688 = p.matchLookaheadLiteral(":", 0) + } + config_key_values690 := xs687 p.consumeLiteral("}") - return config_key_values689 + return config_key_values690 } func (p *Parser) parse_config_key_value() []interface{} { p.consumeLiteral(":") - symbol690 := p.consumeTerminal("SYMBOL").Value.str - _t1361 := p.parse_raw_value() - raw_value691 := _t1361 - return []interface{}{symbol690, raw_value691} + symbol691 := p.consumeTerminal("SYMBOL").Value.str + _t1363 := p.parse_raw_value() + raw_value692 := _t1363 + return []interface{}{symbol691, raw_value692} } func (p *Parser) parse_raw_value() *pb.Value { - span_start705 := int64(p.spanStart()) - var _t1362 int64 + span_start706 := int64(p.spanStart()) + var _t1364 int64 if p.matchLookaheadLiteral("true", 0) { - _t1362 = 12 + _t1364 = 12 } else { - var _t1363 int64 + var _t1365 int64 if p.matchLookaheadLiteral("missing", 0) { - _t1363 = 11 + _t1365 = 11 } else { - var _t1364 int64 + var _t1366 int64 if p.matchLookaheadLiteral("false", 0) { - _t1364 = 12 + _t1366 = 12 } else { - var _t1365 int64 + var _t1367 int64 if p.matchLookaheadLiteral("(", 0) { - var _t1366 int64 + var _t1368 int64 if p.matchLookaheadLiteral("datetime", 1) { - _t1366 = 1 + _t1368 = 1 } else { - var _t1367 int64 + var _t1369 int64 if p.matchLookaheadLiteral("date", 1) { - _t1367 = 0 + _t1369 = 0 } else { - _t1367 = -1 + _t1369 = -1 } - _t1366 = _t1367 + _t1368 = _t1369 } - _t1365 = _t1366 + _t1367 = _t1368 } else { - var _t1368 int64 + var _t1370 int64 if p.matchLookaheadTerminal("UINT32", 0) { - _t1368 = 7 + _t1370 = 7 } else { - var _t1369 int64 + var _t1371 int64 if p.matchLookaheadTerminal("UINT128", 0) { - _t1369 = 8 + _t1371 = 8 } else { - var _t1370 int64 + var _t1372 int64 if p.matchLookaheadTerminal("STRING", 0) { - _t1370 = 2 + _t1372 = 2 } else { - var _t1371 int64 + var _t1373 int64 if p.matchLookaheadTerminal("INT32", 0) { - _t1371 = 3 + _t1373 = 3 } else { - var _t1372 int64 + var _t1374 int64 if p.matchLookaheadTerminal("INT128", 0) { - _t1372 = 9 + _t1374 = 9 } else { - var _t1373 int64 + var _t1375 int64 if p.matchLookaheadTerminal("INT", 0) { - _t1373 = 4 + _t1375 = 4 } else { - var _t1374 int64 + var _t1376 int64 if p.matchLookaheadTerminal("FLOAT32", 0) { - _t1374 = 5 + _t1376 = 5 } else { - var _t1375 int64 + var _t1377 int64 if p.matchLookaheadTerminal("FLOAT", 0) { - _t1375 = 6 + _t1377 = 6 } else { - var _t1376 int64 + var _t1378 int64 if p.matchLookaheadTerminal("DECIMAL", 0) { - _t1376 = 10 + _t1378 = 10 } else { - _t1376 = -1 + _t1378 = -1 } - _t1375 = _t1376 + _t1377 = _t1378 } - _t1374 = _t1375 + _t1376 = _t1377 } - _t1373 = _t1374 + _t1375 = _t1376 } - _t1372 = _t1373 + _t1374 = _t1375 } - _t1371 = _t1372 + _t1373 = _t1374 } - _t1370 = _t1371 + _t1372 = _t1373 } - _t1369 = _t1370 + _t1371 = _t1372 } - _t1368 = _t1369 + _t1370 = _t1371 } - _t1365 = _t1368 + _t1367 = _t1370 } - _t1364 = _t1365 + _t1366 = _t1367 } - _t1363 = _t1364 + _t1365 = _t1366 } - _t1362 = _t1363 - } - prediction692 := _t1362 - var _t1377 *pb.Value - if prediction692 == 12 { - _t1378 := p.parse_boolean_value() - boolean_value704 := _t1378 - _t1379 := &pb.Value{} - _t1379.Value = &pb.Value_BooleanValue{BooleanValue: boolean_value704} - _t1377 = _t1379 + _t1364 = _t1365 + } + prediction693 := _t1364 + var _t1379 *pb.Value + if prediction693 == 12 { + _t1380 := p.parse_boolean_value() + boolean_value705 := _t1380 + _t1381 := &pb.Value{} + _t1381.Value = &pb.Value_BooleanValue{BooleanValue: boolean_value705} + _t1379 = _t1381 } else { - var _t1380 *pb.Value - if prediction692 == 11 { + var _t1382 *pb.Value + if prediction693 == 11 { p.consumeLiteral("missing") - _t1381 := &pb.MissingValue{} - _t1382 := &pb.Value{} - _t1382.Value = &pb.Value_MissingValue{MissingValue: _t1381} - _t1380 = _t1382 + _t1383 := &pb.MissingValue{} + _t1384 := &pb.Value{} + _t1384.Value = &pb.Value_MissingValue{MissingValue: _t1383} + _t1382 = _t1384 } else { - var _t1383 *pb.Value - if prediction692 == 10 { - decimal703 := p.consumeTerminal("DECIMAL").Value.decimal - _t1384 := &pb.Value{} - _t1384.Value = &pb.Value_DecimalValue{DecimalValue: decimal703} - _t1383 = _t1384 + var _t1385 *pb.Value + if prediction693 == 10 { + decimal704 := p.consumeTerminal("DECIMAL").Value.decimal + _t1386 := &pb.Value{} + _t1386.Value = &pb.Value_DecimalValue{DecimalValue: decimal704} + _t1385 = _t1386 } else { - var _t1385 *pb.Value - if prediction692 == 9 { - int128702 := p.consumeTerminal("INT128").Value.int128 - _t1386 := &pb.Value{} - _t1386.Value = &pb.Value_Int128Value{Int128Value: int128702} - _t1385 = _t1386 + var _t1387 *pb.Value + if prediction693 == 9 { + int128703 := p.consumeTerminal("INT128").Value.int128 + _t1388 := &pb.Value{} + _t1388.Value = &pb.Value_Int128Value{Int128Value: int128703} + _t1387 = _t1388 } else { - var _t1387 *pb.Value - if prediction692 == 8 { - uint128701 := p.consumeTerminal("UINT128").Value.uint128 - _t1388 := &pb.Value{} - _t1388.Value = &pb.Value_Uint128Value{Uint128Value: uint128701} - _t1387 = _t1388 + var _t1389 *pb.Value + if prediction693 == 8 { + uint128702 := p.consumeTerminal("UINT128").Value.uint128 + _t1390 := &pb.Value{} + _t1390.Value = &pb.Value_Uint128Value{Uint128Value: uint128702} + _t1389 = _t1390 } else { - var _t1389 *pb.Value - if prediction692 == 7 { - uint32700 := p.consumeTerminal("UINT32").Value.u32 - _t1390 := &pb.Value{} - _t1390.Value = &pb.Value_Uint32Value{Uint32Value: uint32700} - _t1389 = _t1390 + var _t1391 *pb.Value + if prediction693 == 7 { + uint32701 := p.consumeTerminal("UINT32").Value.u32 + _t1392 := &pb.Value{} + _t1392.Value = &pb.Value_Uint32Value{Uint32Value: uint32701} + _t1391 = _t1392 } else { - var _t1391 *pb.Value - if prediction692 == 6 { - float699 := p.consumeTerminal("FLOAT").Value.f64 - _t1392 := &pb.Value{} - _t1392.Value = &pb.Value_FloatValue{FloatValue: float699} - _t1391 = _t1392 + var _t1393 *pb.Value + if prediction693 == 6 { + float700 := p.consumeTerminal("FLOAT").Value.f64 + _t1394 := &pb.Value{} + _t1394.Value = &pb.Value_FloatValue{FloatValue: float700} + _t1393 = _t1394 } else { - var _t1393 *pb.Value - if prediction692 == 5 { - float32698 := p.consumeTerminal("FLOAT32").Value.f32 - _t1394 := &pb.Value{} - _t1394.Value = &pb.Value_Float32Value{Float32Value: float32698} - _t1393 = _t1394 + var _t1395 *pb.Value + if prediction693 == 5 { + float32699 := p.consumeTerminal("FLOAT32").Value.f32 + _t1396 := &pb.Value{} + _t1396.Value = &pb.Value_Float32Value{Float32Value: float32699} + _t1395 = _t1396 } else { - var _t1395 *pb.Value - if prediction692 == 4 { - int697 := p.consumeTerminal("INT").Value.i64 - _t1396 := &pb.Value{} - _t1396.Value = &pb.Value_IntValue{IntValue: int697} - _t1395 = _t1396 + var _t1397 *pb.Value + if prediction693 == 4 { + int698 := p.consumeTerminal("INT").Value.i64 + _t1398 := &pb.Value{} + _t1398.Value = &pb.Value_IntValue{IntValue: int698} + _t1397 = _t1398 } else { - var _t1397 *pb.Value - if prediction692 == 3 { - int32696 := p.consumeTerminal("INT32").Value.i32 - _t1398 := &pb.Value{} - _t1398.Value = &pb.Value_Int32Value{Int32Value: int32696} - _t1397 = _t1398 + var _t1399 *pb.Value + if prediction693 == 3 { + int32697 := p.consumeTerminal("INT32").Value.i32 + _t1400 := &pb.Value{} + _t1400.Value = &pb.Value_Int32Value{Int32Value: int32697} + _t1399 = _t1400 } else { - var _t1399 *pb.Value - if prediction692 == 2 { - string695 := p.consumeTerminal("STRING").Value.str - _t1400 := &pb.Value{} - _t1400.Value = &pb.Value_StringValue{StringValue: string695} - _t1399 = _t1400 + var _t1401 *pb.Value + if prediction693 == 2 { + string696 := p.consumeTerminal("STRING").Value.str + _t1402 := &pb.Value{} + _t1402.Value = &pb.Value_StringValue{StringValue: string696} + _t1401 = _t1402 } else { - var _t1401 *pb.Value - if prediction692 == 1 { - _t1402 := p.parse_raw_datetime() - raw_datetime694 := _t1402 - _t1403 := &pb.Value{} - _t1403.Value = &pb.Value_DatetimeValue{DatetimeValue: raw_datetime694} - _t1401 = _t1403 + var _t1403 *pb.Value + if prediction693 == 1 { + _t1404 := p.parse_raw_datetime() + raw_datetime695 := _t1404 + _t1405 := &pb.Value{} + _t1405.Value = &pb.Value_DatetimeValue{DatetimeValue: raw_datetime695} + _t1403 = _t1405 } else { - var _t1404 *pb.Value - if prediction692 == 0 { - _t1405 := p.parse_raw_date() - raw_date693 := _t1405 - _t1406 := &pb.Value{} - _t1406.Value = &pb.Value_DateValue{DateValue: raw_date693} - _t1404 = _t1406 + var _t1406 *pb.Value + if prediction693 == 0 { + _t1407 := p.parse_raw_date() + raw_date694 := _t1407 + _t1408 := &pb.Value{} + _t1408.Value = &pb.Value_DateValue{DateValue: raw_date694} + _t1406 = _t1408 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in raw_value", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1401 = _t1404 + _t1403 = _t1406 } - _t1399 = _t1401 + _t1401 = _t1403 } - _t1397 = _t1399 + _t1399 = _t1401 } - _t1395 = _t1397 + _t1397 = _t1399 } - _t1393 = _t1395 + _t1395 = _t1397 } - _t1391 = _t1393 + _t1393 = _t1395 } - _t1389 = _t1391 + _t1391 = _t1393 } - _t1387 = _t1389 + _t1389 = _t1391 } - _t1385 = _t1387 + _t1387 = _t1389 } - _t1383 = _t1385 + _t1385 = _t1387 } - _t1380 = _t1383 + _t1382 = _t1385 } - _t1377 = _t1380 + _t1379 = _t1382 } - result706 := _t1377 - p.recordSpan(int(span_start705), "Value") - return result706 + result707 := _t1379 + p.recordSpan(int(span_start706), "Value") + return result707 } func (p *Parser) parse_raw_date() *pb.DateValue { - span_start710 := int64(p.spanStart()) + span_start711 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("date") - int707 := p.consumeTerminal("INT").Value.i64 - int_3708 := p.consumeTerminal("INT").Value.i64 - int_4709 := p.consumeTerminal("INT").Value.i64 + int708 := p.consumeTerminal("INT").Value.i64 + int_3709 := p.consumeTerminal("INT").Value.i64 + int_4710 := p.consumeTerminal("INT").Value.i64 p.consumeLiteral(")") - _t1407 := &pb.DateValue{Year: int32(int707), Month: int32(int_3708), Day: int32(int_4709)} - result711 := _t1407 - p.recordSpan(int(span_start710), "DateValue") - return result711 + _t1409 := &pb.DateValue{Year: int32(int708), Month: int32(int_3709), Day: int32(int_4710)} + result712 := _t1409 + p.recordSpan(int(span_start711), "DateValue") + return result712 } func (p *Parser) parse_raw_datetime() *pb.DateTimeValue { - span_start719 := int64(p.spanStart()) + span_start720 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("datetime") - int712 := p.consumeTerminal("INT").Value.i64 - int_3713 := p.consumeTerminal("INT").Value.i64 - int_4714 := p.consumeTerminal("INT").Value.i64 - int_5715 := p.consumeTerminal("INT").Value.i64 - int_6716 := p.consumeTerminal("INT").Value.i64 - int_7717 := p.consumeTerminal("INT").Value.i64 - var _t1408 *int64 + int713 := p.consumeTerminal("INT").Value.i64 + int_3714 := p.consumeTerminal("INT").Value.i64 + int_4715 := p.consumeTerminal("INT").Value.i64 + int_5716 := p.consumeTerminal("INT").Value.i64 + int_6717 := p.consumeTerminal("INT").Value.i64 + int_7718 := p.consumeTerminal("INT").Value.i64 + var _t1410 *int64 if p.matchLookaheadTerminal("INT", 0) { - _t1408 = ptr(p.consumeTerminal("INT").Value.i64) + _t1410 = ptr(p.consumeTerminal("INT").Value.i64) } - int_8718 := _t1408 + int_8719 := _t1410 p.consumeLiteral(")") - _t1409 := &pb.DateTimeValue{Year: int32(int712), Month: int32(int_3713), Day: int32(int_4714), Hour: int32(int_5715), Minute: int32(int_6716), Second: int32(int_7717), Microsecond: int32(deref(int_8718, 0))} - result720 := _t1409 - p.recordSpan(int(span_start719), "DateTimeValue") - return result720 + _t1411 := &pb.DateTimeValue{Year: int32(int713), Month: int32(int_3714), Day: int32(int_4715), Hour: int32(int_5716), Minute: int32(int_6717), Second: int32(int_7718), Microsecond: int32(deref(int_8719, 0))} + result721 := _t1411 + p.recordSpan(int(span_start720), "DateTimeValue") + return result721 } func (p *Parser) parse_boolean_value() bool { - var _t1410 int64 + var _t1412 int64 if p.matchLookaheadLiteral("true", 0) { - _t1410 = 0 + _t1412 = 0 } else { - var _t1411 int64 + var _t1413 int64 if p.matchLookaheadLiteral("false", 0) { - _t1411 = 1 + _t1413 = 1 } else { - _t1411 = -1 + _t1413 = -1 } - _t1410 = _t1411 + _t1412 = _t1413 } - prediction721 := _t1410 - var _t1412 bool - if prediction721 == 1 { + prediction722 := _t1412 + var _t1414 bool + if prediction722 == 1 { p.consumeLiteral("false") - _t1412 = false + _t1414 = false } else { - var _t1413 bool - if prediction721 == 0 { + var _t1415 bool + if prediction722 == 0 { p.consumeLiteral("true") - _t1413 = true + _t1415 = true } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in boolean_value", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1412 = _t1413 + _t1414 = _t1415 } - return _t1412 + return _t1414 } func (p *Parser) parse_sync() *pb.Sync { - span_start726 := int64(p.spanStart()) + span_start727 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("sync") - xs722 := []*pb.FragmentId{} - cond723 := p.matchLookaheadLiteral(":", 0) - for cond723 { - _t1414 := p.parse_fragment_id() - item724 := _t1414 - xs722 = append(xs722, item724) - cond723 = p.matchLookaheadLiteral(":", 0) - } - fragment_ids725 := xs722 + xs723 := []*pb.FragmentId{} + cond724 := p.matchLookaheadLiteral(":", 0) + for cond724 { + _t1416 := p.parse_fragment_id() + item725 := _t1416 + xs723 = append(xs723, item725) + cond724 = p.matchLookaheadLiteral(":", 0) + } + fragment_ids726 := xs723 p.consumeLiteral(")") - _t1415 := &pb.Sync{Fragments: fragment_ids725} - result727 := _t1415 - p.recordSpan(int(span_start726), "Sync") - return result727 + _t1417 := &pb.Sync{Fragments: fragment_ids726} + result728 := _t1417 + p.recordSpan(int(span_start727), "Sync") + return result728 } func (p *Parser) parse_fragment_id() *pb.FragmentId { - span_start729 := int64(p.spanStart()) + span_start730 := int64(p.spanStart()) p.consumeLiteral(":") - symbol728 := p.consumeTerminal("SYMBOL").Value.str - result730 := &pb.FragmentId{Id: []byte(symbol728)} - p.recordSpan(int(span_start729), "FragmentId") - return result730 + symbol729 := p.consumeTerminal("SYMBOL").Value.str + result731 := &pb.FragmentId{Id: []byte(symbol729)} + p.recordSpan(int(span_start730), "FragmentId") + return result731 } func (p *Parser) parse_epoch() *pb.Epoch { - span_start733 := int64(p.spanStart()) + span_start734 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("epoch") - var _t1416 []*pb.Write + var _t1418 []*pb.Write if (p.matchLookaheadLiteral("(", 0) && p.matchLookaheadLiteral("writes", 1)) { - _t1417 := p.parse_epoch_writes() - _t1416 = _t1417 + _t1419 := p.parse_epoch_writes() + _t1418 = _t1419 } - epoch_writes731 := _t1416 - var _t1418 []*pb.Read + epoch_writes732 := _t1418 + var _t1420 []*pb.Read if p.matchLookaheadLiteral("(", 0) { - _t1419 := p.parse_epoch_reads() - _t1418 = _t1419 + _t1421 := p.parse_epoch_reads() + _t1420 = _t1421 } - epoch_reads732 := _t1418 + epoch_reads733 := _t1420 p.consumeLiteral(")") - _t1420 := epoch_writes731 - if epoch_writes731 == nil { - _t1420 = []*pb.Write{} + _t1422 := epoch_writes732 + if epoch_writes732 == nil { + _t1422 = []*pb.Write{} } - _t1421 := epoch_reads732 - if epoch_reads732 == nil { - _t1421 = []*pb.Read{} + _t1423 := epoch_reads733 + if epoch_reads733 == nil { + _t1423 = []*pb.Read{} } - _t1422 := &pb.Epoch{Writes: _t1420, Reads: _t1421} - result734 := _t1422 - p.recordSpan(int(span_start733), "Epoch") - return result734 + _t1424 := &pb.Epoch{Writes: _t1422, Reads: _t1423} + result735 := _t1424 + p.recordSpan(int(span_start734), "Epoch") + return result735 } func (p *Parser) parse_epoch_writes() []*pb.Write { p.consumeLiteral("(") p.consumeLiteral("writes") - xs735 := []*pb.Write{} - cond736 := p.matchLookaheadLiteral("(", 0) - for cond736 { - _t1423 := p.parse_write() - item737 := _t1423 - xs735 = append(xs735, item737) - cond736 = p.matchLookaheadLiteral("(", 0) - } - writes738 := xs735 + xs736 := []*pb.Write{} + cond737 := p.matchLookaheadLiteral("(", 0) + for cond737 { + _t1425 := p.parse_write() + item738 := _t1425 + xs736 = append(xs736, item738) + cond737 = p.matchLookaheadLiteral("(", 0) + } + writes739 := xs736 p.consumeLiteral(")") - return writes738 + return writes739 } func (p *Parser) parse_write() *pb.Write { - span_start744 := int64(p.spanStart()) - var _t1424 int64 + span_start745 := int64(p.spanStart()) + var _t1426 int64 if p.matchLookaheadLiteral("(", 0) { - var _t1425 int64 + var _t1427 int64 if p.matchLookaheadLiteral("undefine", 1) { - _t1425 = 1 + _t1427 = 1 } else { - var _t1426 int64 + var _t1428 int64 if p.matchLookaheadLiteral("snapshot", 1) { - _t1426 = 3 + _t1428 = 3 } else { - var _t1427 int64 + var _t1429 int64 if p.matchLookaheadLiteral("define", 1) { - _t1427 = 0 + _t1429 = 0 } else { - var _t1428 int64 + var _t1430 int64 if p.matchLookaheadLiteral("context", 1) { - _t1428 = 2 + _t1430 = 2 } else { - _t1428 = -1 + _t1430 = -1 } - _t1427 = _t1428 + _t1429 = _t1430 } - _t1426 = _t1427 + _t1428 = _t1429 } - _t1425 = _t1426 + _t1427 = _t1428 } - _t1424 = _t1425 + _t1426 = _t1427 } else { - _t1424 = -1 - } - prediction739 := _t1424 - var _t1429 *pb.Write - if prediction739 == 3 { - _t1430 := p.parse_snapshot() - snapshot743 := _t1430 - _t1431 := &pb.Write{} - _t1431.WriteType = &pb.Write_Snapshot{Snapshot: snapshot743} - _t1429 = _t1431 + _t1426 = -1 + } + prediction740 := _t1426 + var _t1431 *pb.Write + if prediction740 == 3 { + _t1432 := p.parse_snapshot() + snapshot744 := _t1432 + _t1433 := &pb.Write{} + _t1433.WriteType = &pb.Write_Snapshot{Snapshot: snapshot744} + _t1431 = _t1433 } else { - var _t1432 *pb.Write - if prediction739 == 2 { - _t1433 := p.parse_context() - context742 := _t1433 - _t1434 := &pb.Write{} - _t1434.WriteType = &pb.Write_Context{Context: context742} - _t1432 = _t1434 + var _t1434 *pb.Write + if prediction740 == 2 { + _t1435 := p.parse_context() + context743 := _t1435 + _t1436 := &pb.Write{} + _t1436.WriteType = &pb.Write_Context{Context: context743} + _t1434 = _t1436 } else { - var _t1435 *pb.Write - if prediction739 == 1 { - _t1436 := p.parse_undefine() - undefine741 := _t1436 - _t1437 := &pb.Write{} - _t1437.WriteType = &pb.Write_Undefine{Undefine: undefine741} - _t1435 = _t1437 + var _t1437 *pb.Write + if prediction740 == 1 { + _t1438 := p.parse_undefine() + undefine742 := _t1438 + _t1439 := &pb.Write{} + _t1439.WriteType = &pb.Write_Undefine{Undefine: undefine742} + _t1437 = _t1439 } else { - var _t1438 *pb.Write - if prediction739 == 0 { - _t1439 := p.parse_define() - define740 := _t1439 - _t1440 := &pb.Write{} - _t1440.WriteType = &pb.Write_Define{Define: define740} - _t1438 = _t1440 + var _t1440 *pb.Write + if prediction740 == 0 { + _t1441 := p.parse_define() + define741 := _t1441 + _t1442 := &pb.Write{} + _t1442.WriteType = &pb.Write_Define{Define: define741} + _t1440 = _t1442 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in write", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1435 = _t1438 + _t1437 = _t1440 } - _t1432 = _t1435 + _t1434 = _t1437 } - _t1429 = _t1432 + _t1431 = _t1434 } - result745 := _t1429 - p.recordSpan(int(span_start744), "Write") - return result745 + result746 := _t1431 + p.recordSpan(int(span_start745), "Write") + return result746 } func (p *Parser) parse_define() *pb.Define { - span_start747 := int64(p.spanStart()) + span_start748 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("define") - _t1441 := p.parse_fragment() - fragment746 := _t1441 + _t1443 := p.parse_fragment() + fragment747 := _t1443 p.consumeLiteral(")") - _t1442 := &pb.Define{Fragment: fragment746} - result748 := _t1442 - p.recordSpan(int(span_start747), "Define") - return result748 + _t1444 := &pb.Define{Fragment: fragment747} + result749 := _t1444 + p.recordSpan(int(span_start748), "Define") + return result749 } func (p *Parser) parse_fragment() *pb.Fragment { - span_start754 := int64(p.spanStart()) + span_start755 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("fragment") - _t1443 := p.parse_new_fragment_id() - new_fragment_id749 := _t1443 - xs750 := []*pb.Declaration{} - cond751 := p.matchLookaheadLiteral("(", 0) - for cond751 { - _t1444 := p.parse_declaration() - item752 := _t1444 - xs750 = append(xs750, item752) - cond751 = p.matchLookaheadLiteral("(", 0) - } - declarations753 := xs750 + _t1445 := p.parse_new_fragment_id() + new_fragment_id750 := _t1445 + xs751 := []*pb.Declaration{} + cond752 := p.matchLookaheadLiteral("(", 0) + for cond752 { + _t1446 := p.parse_declaration() + item753 := _t1446 + xs751 = append(xs751, item753) + cond752 = p.matchLookaheadLiteral("(", 0) + } + declarations754 := xs751 p.consumeLiteral(")") - result755 := p.constructFragment(new_fragment_id749, declarations753) - p.recordSpan(int(span_start754), "Fragment") - return result755 + result756 := p.constructFragment(new_fragment_id750, declarations754) + p.recordSpan(int(span_start755), "Fragment") + return result756 } func (p *Parser) parse_new_fragment_id() *pb.FragmentId { - span_start757 := int64(p.spanStart()) - _t1445 := p.parse_fragment_id() - fragment_id756 := _t1445 - p.startFragment(fragment_id756) - result758 := fragment_id756 - p.recordSpan(int(span_start757), "FragmentId") - return result758 + span_start758 := int64(p.spanStart()) + _t1447 := p.parse_fragment_id() + fragment_id757 := _t1447 + p.startFragment(fragment_id757) + result759 := fragment_id757 + p.recordSpan(int(span_start758), "FragmentId") + return result759 } func (p *Parser) parse_declaration() *pb.Declaration { - span_start764 := int64(p.spanStart()) - var _t1446 int64 + span_start765 := int64(p.spanStart()) + var _t1448 int64 if p.matchLookaheadLiteral("(", 0) { - var _t1447 int64 + var _t1449 int64 if p.matchLookaheadLiteral("iceberg_data", 1) { - _t1447 = 3 + _t1449 = 3 } else { - var _t1448 int64 + var _t1450 int64 if p.matchLookaheadLiteral("functional_dependency", 1) { - _t1448 = 2 + _t1450 = 2 } else { - var _t1449 int64 + var _t1451 int64 if p.matchLookaheadLiteral("edb", 1) { - _t1449 = 3 + _t1451 = 3 } else { - var _t1450 int64 + var _t1452 int64 if p.matchLookaheadLiteral("def", 1) { - _t1450 = 0 + _t1452 = 0 } else { - var _t1451 int64 + var _t1453 int64 if p.matchLookaheadLiteral("csv_data", 1) { - _t1451 = 3 + _t1453 = 3 } else { - var _t1452 int64 + var _t1454 int64 if p.matchLookaheadLiteral("betree_relation", 1) { - _t1452 = 3 + _t1454 = 3 } else { - var _t1453 int64 + var _t1455 int64 if p.matchLookaheadLiteral("algorithm", 1) { - _t1453 = 1 + _t1455 = 1 } else { - _t1453 = -1 + _t1455 = -1 } - _t1452 = _t1453 + _t1454 = _t1455 } - _t1451 = _t1452 + _t1453 = _t1454 } - _t1450 = _t1451 + _t1452 = _t1453 } - _t1449 = _t1450 + _t1451 = _t1452 } - _t1448 = _t1449 + _t1450 = _t1451 } - _t1447 = _t1448 + _t1449 = _t1450 } - _t1446 = _t1447 + _t1448 = _t1449 } else { - _t1446 = -1 - } - prediction759 := _t1446 - var _t1454 *pb.Declaration - if prediction759 == 3 { - _t1455 := p.parse_data() - data763 := _t1455 - _t1456 := &pb.Declaration{} - _t1456.DeclarationType = &pb.Declaration_Data{Data: data763} - _t1454 = _t1456 + _t1448 = -1 + } + prediction760 := _t1448 + var _t1456 *pb.Declaration + if prediction760 == 3 { + _t1457 := p.parse_data() + data764 := _t1457 + _t1458 := &pb.Declaration{} + _t1458.DeclarationType = &pb.Declaration_Data{Data: data764} + _t1456 = _t1458 } else { - var _t1457 *pb.Declaration - if prediction759 == 2 { - _t1458 := p.parse_constraint() - constraint762 := _t1458 - _t1459 := &pb.Declaration{} - _t1459.DeclarationType = &pb.Declaration_Constraint{Constraint: constraint762} - _t1457 = _t1459 + var _t1459 *pb.Declaration + if prediction760 == 2 { + _t1460 := p.parse_constraint() + constraint763 := _t1460 + _t1461 := &pb.Declaration{} + _t1461.DeclarationType = &pb.Declaration_Constraint{Constraint: constraint763} + _t1459 = _t1461 } else { - var _t1460 *pb.Declaration - if prediction759 == 1 { - _t1461 := p.parse_algorithm() - algorithm761 := _t1461 - _t1462 := &pb.Declaration{} - _t1462.DeclarationType = &pb.Declaration_Algorithm{Algorithm: algorithm761} - _t1460 = _t1462 + var _t1462 *pb.Declaration + if prediction760 == 1 { + _t1463 := p.parse_algorithm() + algorithm762 := _t1463 + _t1464 := &pb.Declaration{} + _t1464.DeclarationType = &pb.Declaration_Algorithm{Algorithm: algorithm762} + _t1462 = _t1464 } else { - var _t1463 *pb.Declaration - if prediction759 == 0 { - _t1464 := p.parse_def() - def760 := _t1464 - _t1465 := &pb.Declaration{} - _t1465.DeclarationType = &pb.Declaration_Def{Def: def760} - _t1463 = _t1465 + var _t1465 *pb.Declaration + if prediction760 == 0 { + _t1466 := p.parse_def() + def761 := _t1466 + _t1467 := &pb.Declaration{} + _t1467.DeclarationType = &pb.Declaration_Def{Def: def761} + _t1465 = _t1467 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in declaration", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1460 = _t1463 + _t1462 = _t1465 } - _t1457 = _t1460 + _t1459 = _t1462 } - _t1454 = _t1457 + _t1456 = _t1459 } - result765 := _t1454 - p.recordSpan(int(span_start764), "Declaration") - return result765 + result766 := _t1456 + p.recordSpan(int(span_start765), "Declaration") + return result766 } func (p *Parser) parse_def() *pb.Def { - span_start769 := int64(p.spanStart()) + span_start770 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("def") - _t1466 := p.parse_relation_id() - relation_id766 := _t1466 - _t1467 := p.parse_abstraction() - abstraction767 := _t1467 - var _t1468 []*pb.Attribute + _t1468 := p.parse_relation_id() + relation_id767 := _t1468 + _t1469 := p.parse_abstraction() + abstraction768 := _t1469 + var _t1470 []*pb.Attribute if p.matchLookaheadLiteral("(", 0) { - _t1469 := p.parse_attrs() - _t1468 = _t1469 + _t1471 := p.parse_attrs() + _t1470 = _t1471 } - attrs768 := _t1468 + attrs769 := _t1470 p.consumeLiteral(")") - _t1470 := attrs768 - if attrs768 == nil { - _t1470 = []*pb.Attribute{} + _t1472 := attrs769 + if attrs769 == nil { + _t1472 = []*pb.Attribute{} } - _t1471 := &pb.Def{Name: relation_id766, Body: abstraction767, Attrs: _t1470} - result770 := _t1471 - p.recordSpan(int(span_start769), "Def") - return result770 + _t1473 := &pb.Def{Name: relation_id767, Body: abstraction768, Attrs: _t1472} + result771 := _t1473 + p.recordSpan(int(span_start770), "Def") + return result771 } func (p *Parser) parse_relation_id() *pb.RelationId { - span_start774 := int64(p.spanStart()) - var _t1472 int64 + span_start775 := int64(p.spanStart()) + var _t1474 int64 if p.matchLookaheadLiteral(":", 0) { - _t1472 = 0 + _t1474 = 0 } else { - var _t1473 int64 + var _t1475 int64 if p.matchLookaheadTerminal("UINT128", 0) { - _t1473 = 1 + _t1475 = 1 } else { - _t1473 = -1 + _t1475 = -1 } - _t1472 = _t1473 - } - prediction771 := _t1472 - var _t1474 *pb.RelationId - if prediction771 == 1 { - uint128773 := p.consumeTerminal("UINT128").Value.uint128 - _ = uint128773 - _t1474 = &pb.RelationId{IdLow: uint128773.Low, IdHigh: uint128773.High} + _t1474 = _t1475 + } + prediction772 := _t1474 + var _t1476 *pb.RelationId + if prediction772 == 1 { + uint128774 := p.consumeTerminal("UINT128").Value.uint128 + _ = uint128774 + _t1476 = &pb.RelationId{IdLow: uint128774.Low, IdHigh: uint128774.High} } else { - var _t1475 *pb.RelationId - if prediction771 == 0 { + var _t1477 *pb.RelationId + if prediction772 == 0 { p.consumeLiteral(":") - symbol772 := p.consumeTerminal("SYMBOL").Value.str - _t1475 = p.relationIdFromString(symbol772) + symbol773 := p.consumeTerminal("SYMBOL").Value.str + _t1477 = p.relationIdFromString(symbol773) } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in relation_id", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1474 = _t1475 + _t1476 = _t1477 } - result775 := _t1474 - p.recordSpan(int(span_start774), "RelationId") - return result775 + result776 := _t1476 + p.recordSpan(int(span_start775), "RelationId") + return result776 } func (p *Parser) parse_abstraction() *pb.Abstraction { - span_start778 := int64(p.spanStart()) + span_start779 := int64(p.spanStart()) p.consumeLiteral("(") - _t1476 := p.parse_bindings() - bindings776 := _t1476 - _t1477 := p.parse_formula() - formula777 := _t1477 + _t1478 := p.parse_bindings() + bindings777 := _t1478 + _t1479 := p.parse_formula() + formula778 := _t1479 p.consumeLiteral(")") - _t1478 := &pb.Abstraction{Vars: listConcat(bindings776[0].([]*pb.Binding), bindings776[1].([]*pb.Binding)), Value: formula777} - result779 := _t1478 - p.recordSpan(int(span_start778), "Abstraction") - return result779 + _t1480 := &pb.Abstraction{Vars: listConcat(bindings777[0].([]*pb.Binding), bindings777[1].([]*pb.Binding)), Value: formula778} + result780 := _t1480 + p.recordSpan(int(span_start779), "Abstraction") + return result780 } func (p *Parser) parse_bindings() []interface{} { p.consumeLiteral("[") - xs780 := []*pb.Binding{} - cond781 := p.matchLookaheadTerminal("SYMBOL", 0) - for cond781 { - _t1479 := p.parse_binding() - item782 := _t1479 - xs780 = append(xs780, item782) - cond781 = p.matchLookaheadTerminal("SYMBOL", 0) - } - bindings783 := xs780 - var _t1480 []*pb.Binding + xs781 := []*pb.Binding{} + cond782 := p.matchLookaheadTerminal("SYMBOL", 0) + for cond782 { + _t1481 := p.parse_binding() + item783 := _t1481 + xs781 = append(xs781, item783) + cond782 = p.matchLookaheadTerminal("SYMBOL", 0) + } + bindings784 := xs781 + var _t1482 []*pb.Binding if p.matchLookaheadLiteral("|", 0) { - _t1481 := p.parse_value_bindings() - _t1480 = _t1481 + _t1483 := p.parse_value_bindings() + _t1482 = _t1483 } - value_bindings784 := _t1480 + value_bindings785 := _t1482 p.consumeLiteral("]") - _t1482 := value_bindings784 - if value_bindings784 == nil { - _t1482 = []*pb.Binding{} + _t1484 := value_bindings785 + if value_bindings785 == nil { + _t1484 = []*pb.Binding{} } - return []interface{}{bindings783, _t1482} + return []interface{}{bindings784, _t1484} } func (p *Parser) parse_binding() *pb.Binding { - span_start787 := int64(p.spanStart()) - symbol785 := p.consumeTerminal("SYMBOL").Value.str + span_start788 := int64(p.spanStart()) + symbol786 := p.consumeTerminal("SYMBOL").Value.str p.consumeLiteral("::") - _t1483 := p.parse_type() - type786 := _t1483 - _t1484 := &pb.Var{Name: symbol785} - _t1485 := &pb.Binding{Var: _t1484, Type: type786} - result788 := _t1485 - p.recordSpan(int(span_start787), "Binding") - return result788 + _t1485 := p.parse_type() + type787 := _t1485 + _t1486 := &pb.Var{Name: symbol786} + _t1487 := &pb.Binding{Var: _t1486, Type: type787} + result789 := _t1487 + p.recordSpan(int(span_start788), "Binding") + return result789 } func (p *Parser) parse_type() *pb.Type { - span_start804 := int64(p.spanStart()) - var _t1486 int64 + span_start805 := int64(p.spanStart()) + var _t1488 int64 if p.matchLookaheadLiteral("UNKNOWN", 0) { - _t1486 = 0 + _t1488 = 0 } else { - var _t1487 int64 + var _t1489 int64 if p.matchLookaheadLiteral("UINT32", 0) { - _t1487 = 13 + _t1489 = 13 } else { - var _t1488 int64 + var _t1490 int64 if p.matchLookaheadLiteral("UINT128", 0) { - _t1488 = 4 + _t1490 = 4 } else { - var _t1489 int64 + var _t1491 int64 if p.matchLookaheadLiteral("STRING", 0) { - _t1489 = 1 + _t1491 = 1 } else { - var _t1490 int64 + var _t1492 int64 if p.matchLookaheadLiteral("MISSING", 0) { - _t1490 = 8 + _t1492 = 8 } else { - var _t1491 int64 + var _t1493 int64 if p.matchLookaheadLiteral("INT32", 0) { - _t1491 = 11 + _t1493 = 11 } else { - var _t1492 int64 + var _t1494 int64 if p.matchLookaheadLiteral("INT128", 0) { - _t1492 = 5 + _t1494 = 5 } else { - var _t1493 int64 + var _t1495 int64 if p.matchLookaheadLiteral("INT", 0) { - _t1493 = 2 + _t1495 = 2 } else { - var _t1494 int64 + var _t1496 int64 if p.matchLookaheadLiteral("FLOAT32", 0) { - _t1494 = 12 + _t1496 = 12 } else { - var _t1495 int64 + var _t1497 int64 if p.matchLookaheadLiteral("FLOAT", 0) { - _t1495 = 3 + _t1497 = 3 } else { - var _t1496 int64 + var _t1498 int64 if p.matchLookaheadLiteral("DATETIME", 0) { - _t1496 = 7 + _t1498 = 7 } else { - var _t1497 int64 + var _t1499 int64 if p.matchLookaheadLiteral("DATE", 0) { - _t1497 = 6 + _t1499 = 6 } else { - var _t1498 int64 + var _t1500 int64 if p.matchLookaheadLiteral("BOOLEAN", 0) { - _t1498 = 10 + _t1500 = 10 } else { - var _t1499 int64 + var _t1501 int64 if p.matchLookaheadLiteral("(", 0) { - _t1499 = 9 + _t1501 = 9 } else { - _t1499 = -1 + _t1501 = -1 } - _t1498 = _t1499 + _t1500 = _t1501 } - _t1497 = _t1498 + _t1499 = _t1500 } - _t1496 = _t1497 + _t1498 = _t1499 } - _t1495 = _t1496 + _t1497 = _t1498 } - _t1494 = _t1495 + _t1496 = _t1497 } - _t1493 = _t1494 + _t1495 = _t1496 } - _t1492 = _t1493 + _t1494 = _t1495 } - _t1491 = _t1492 + _t1493 = _t1494 } - _t1490 = _t1491 + _t1492 = _t1493 } - _t1489 = _t1490 + _t1491 = _t1492 } - _t1488 = _t1489 + _t1490 = _t1491 } - _t1487 = _t1488 + _t1489 = _t1490 } - _t1486 = _t1487 - } - prediction789 := _t1486 - var _t1500 *pb.Type - if prediction789 == 13 { - _t1501 := p.parse_uint32_type() - uint32_type803 := _t1501 - _t1502 := &pb.Type{} - _t1502.Type = &pb.Type_Uint32Type{Uint32Type: uint32_type803} - _t1500 = _t1502 + _t1488 = _t1489 + } + prediction790 := _t1488 + var _t1502 *pb.Type + if prediction790 == 13 { + _t1503 := p.parse_uint32_type() + uint32_type804 := _t1503 + _t1504 := &pb.Type{} + _t1504.Type = &pb.Type_Uint32Type{Uint32Type: uint32_type804} + _t1502 = _t1504 } else { - var _t1503 *pb.Type - if prediction789 == 12 { - _t1504 := p.parse_float32_type() - float32_type802 := _t1504 - _t1505 := &pb.Type{} - _t1505.Type = &pb.Type_Float32Type{Float32Type: float32_type802} - _t1503 = _t1505 + var _t1505 *pb.Type + if prediction790 == 12 { + _t1506 := p.parse_float32_type() + float32_type803 := _t1506 + _t1507 := &pb.Type{} + _t1507.Type = &pb.Type_Float32Type{Float32Type: float32_type803} + _t1505 = _t1507 } else { - var _t1506 *pb.Type - if prediction789 == 11 { - _t1507 := p.parse_int32_type() - int32_type801 := _t1507 - _t1508 := &pb.Type{} - _t1508.Type = &pb.Type_Int32Type{Int32Type: int32_type801} - _t1506 = _t1508 + var _t1508 *pb.Type + if prediction790 == 11 { + _t1509 := p.parse_int32_type() + int32_type802 := _t1509 + _t1510 := &pb.Type{} + _t1510.Type = &pb.Type_Int32Type{Int32Type: int32_type802} + _t1508 = _t1510 } else { - var _t1509 *pb.Type - if prediction789 == 10 { - _t1510 := p.parse_boolean_type() - boolean_type800 := _t1510 - _t1511 := &pb.Type{} - _t1511.Type = &pb.Type_BooleanType{BooleanType: boolean_type800} - _t1509 = _t1511 + var _t1511 *pb.Type + if prediction790 == 10 { + _t1512 := p.parse_boolean_type() + boolean_type801 := _t1512 + _t1513 := &pb.Type{} + _t1513.Type = &pb.Type_BooleanType{BooleanType: boolean_type801} + _t1511 = _t1513 } else { - var _t1512 *pb.Type - if prediction789 == 9 { - _t1513 := p.parse_decimal_type() - decimal_type799 := _t1513 - _t1514 := &pb.Type{} - _t1514.Type = &pb.Type_DecimalType{DecimalType: decimal_type799} - _t1512 = _t1514 + var _t1514 *pb.Type + if prediction790 == 9 { + _t1515 := p.parse_decimal_type() + decimal_type800 := _t1515 + _t1516 := &pb.Type{} + _t1516.Type = &pb.Type_DecimalType{DecimalType: decimal_type800} + _t1514 = _t1516 } else { - var _t1515 *pb.Type - if prediction789 == 8 { - _t1516 := p.parse_missing_type() - missing_type798 := _t1516 - _t1517 := &pb.Type{} - _t1517.Type = &pb.Type_MissingType{MissingType: missing_type798} - _t1515 = _t1517 + var _t1517 *pb.Type + if prediction790 == 8 { + _t1518 := p.parse_missing_type() + missing_type799 := _t1518 + _t1519 := &pb.Type{} + _t1519.Type = &pb.Type_MissingType{MissingType: missing_type799} + _t1517 = _t1519 } else { - var _t1518 *pb.Type - if prediction789 == 7 { - _t1519 := p.parse_datetime_type() - datetime_type797 := _t1519 - _t1520 := &pb.Type{} - _t1520.Type = &pb.Type_DatetimeType{DatetimeType: datetime_type797} - _t1518 = _t1520 + var _t1520 *pb.Type + if prediction790 == 7 { + _t1521 := p.parse_datetime_type() + datetime_type798 := _t1521 + _t1522 := &pb.Type{} + _t1522.Type = &pb.Type_DatetimeType{DatetimeType: datetime_type798} + _t1520 = _t1522 } else { - var _t1521 *pb.Type - if prediction789 == 6 { - _t1522 := p.parse_date_type() - date_type796 := _t1522 - _t1523 := &pb.Type{} - _t1523.Type = &pb.Type_DateType{DateType: date_type796} - _t1521 = _t1523 + var _t1523 *pb.Type + if prediction790 == 6 { + _t1524 := p.parse_date_type() + date_type797 := _t1524 + _t1525 := &pb.Type{} + _t1525.Type = &pb.Type_DateType{DateType: date_type797} + _t1523 = _t1525 } else { - var _t1524 *pb.Type - if prediction789 == 5 { - _t1525 := p.parse_int128_type() - int128_type795 := _t1525 - _t1526 := &pb.Type{} - _t1526.Type = &pb.Type_Int128Type{Int128Type: int128_type795} - _t1524 = _t1526 + var _t1526 *pb.Type + if prediction790 == 5 { + _t1527 := p.parse_int128_type() + int128_type796 := _t1527 + _t1528 := &pb.Type{} + _t1528.Type = &pb.Type_Int128Type{Int128Type: int128_type796} + _t1526 = _t1528 } else { - var _t1527 *pb.Type - if prediction789 == 4 { - _t1528 := p.parse_uint128_type() - uint128_type794 := _t1528 - _t1529 := &pb.Type{} - _t1529.Type = &pb.Type_Uint128Type{Uint128Type: uint128_type794} - _t1527 = _t1529 + var _t1529 *pb.Type + if prediction790 == 4 { + _t1530 := p.parse_uint128_type() + uint128_type795 := _t1530 + _t1531 := &pb.Type{} + _t1531.Type = &pb.Type_Uint128Type{Uint128Type: uint128_type795} + _t1529 = _t1531 } else { - var _t1530 *pb.Type - if prediction789 == 3 { - _t1531 := p.parse_float_type() - float_type793 := _t1531 - _t1532 := &pb.Type{} - _t1532.Type = &pb.Type_FloatType{FloatType: float_type793} - _t1530 = _t1532 + var _t1532 *pb.Type + if prediction790 == 3 { + _t1533 := p.parse_float_type() + float_type794 := _t1533 + _t1534 := &pb.Type{} + _t1534.Type = &pb.Type_FloatType{FloatType: float_type794} + _t1532 = _t1534 } else { - var _t1533 *pb.Type - if prediction789 == 2 { - _t1534 := p.parse_int_type() - int_type792 := _t1534 - _t1535 := &pb.Type{} - _t1535.Type = &pb.Type_IntType{IntType: int_type792} - _t1533 = _t1535 + var _t1535 *pb.Type + if prediction790 == 2 { + _t1536 := p.parse_int_type() + int_type793 := _t1536 + _t1537 := &pb.Type{} + _t1537.Type = &pb.Type_IntType{IntType: int_type793} + _t1535 = _t1537 } else { - var _t1536 *pb.Type - if prediction789 == 1 { - _t1537 := p.parse_string_type() - string_type791 := _t1537 - _t1538 := &pb.Type{} - _t1538.Type = &pb.Type_StringType{StringType: string_type791} - _t1536 = _t1538 + var _t1538 *pb.Type + if prediction790 == 1 { + _t1539 := p.parse_string_type() + string_type792 := _t1539 + _t1540 := &pb.Type{} + _t1540.Type = &pb.Type_StringType{StringType: string_type792} + _t1538 = _t1540 } else { - var _t1539 *pb.Type - if prediction789 == 0 { - _t1540 := p.parse_unspecified_type() - unspecified_type790 := _t1540 - _t1541 := &pb.Type{} - _t1541.Type = &pb.Type_UnspecifiedType{UnspecifiedType: unspecified_type790} - _t1539 = _t1541 + var _t1541 *pb.Type + if prediction790 == 0 { + _t1542 := p.parse_unspecified_type() + unspecified_type791 := _t1542 + _t1543 := &pb.Type{} + _t1543.Type = &pb.Type_UnspecifiedType{UnspecifiedType: unspecified_type791} + _t1541 = _t1543 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in type", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1536 = _t1539 + _t1538 = _t1541 } - _t1533 = _t1536 + _t1535 = _t1538 } - _t1530 = _t1533 + _t1532 = _t1535 } - _t1527 = _t1530 + _t1529 = _t1532 } - _t1524 = _t1527 + _t1526 = _t1529 } - _t1521 = _t1524 + _t1523 = _t1526 } - _t1518 = _t1521 + _t1520 = _t1523 } - _t1515 = _t1518 + _t1517 = _t1520 } - _t1512 = _t1515 + _t1514 = _t1517 } - _t1509 = _t1512 + _t1511 = _t1514 } - _t1506 = _t1509 + _t1508 = _t1511 } - _t1503 = _t1506 + _t1505 = _t1508 } - _t1500 = _t1503 + _t1502 = _t1505 } - result805 := _t1500 - p.recordSpan(int(span_start804), "Type") - return result805 + result806 := _t1502 + p.recordSpan(int(span_start805), "Type") + return result806 } func (p *Parser) parse_unspecified_type() *pb.UnspecifiedType { - span_start806 := int64(p.spanStart()) + span_start807 := int64(p.spanStart()) p.consumeLiteral("UNKNOWN") - _t1542 := &pb.UnspecifiedType{} - result807 := _t1542 - p.recordSpan(int(span_start806), "UnspecifiedType") - return result807 + _t1544 := &pb.UnspecifiedType{} + result808 := _t1544 + p.recordSpan(int(span_start807), "UnspecifiedType") + return result808 } func (p *Parser) parse_string_type() *pb.StringType { - span_start808 := int64(p.spanStart()) + span_start809 := int64(p.spanStart()) p.consumeLiteral("STRING") - _t1543 := &pb.StringType{} - result809 := _t1543 - p.recordSpan(int(span_start808), "StringType") - return result809 + _t1545 := &pb.StringType{} + result810 := _t1545 + p.recordSpan(int(span_start809), "StringType") + return result810 } func (p *Parser) parse_int_type() *pb.IntType { - span_start810 := int64(p.spanStart()) + span_start811 := int64(p.spanStart()) p.consumeLiteral("INT") - _t1544 := &pb.IntType{} - result811 := _t1544 - p.recordSpan(int(span_start810), "IntType") - return result811 + _t1546 := &pb.IntType{} + result812 := _t1546 + p.recordSpan(int(span_start811), "IntType") + return result812 } func (p *Parser) parse_float_type() *pb.FloatType { - span_start812 := int64(p.spanStart()) + span_start813 := int64(p.spanStart()) p.consumeLiteral("FLOAT") - _t1545 := &pb.FloatType{} - result813 := _t1545 - p.recordSpan(int(span_start812), "FloatType") - return result813 + _t1547 := &pb.FloatType{} + result814 := _t1547 + p.recordSpan(int(span_start813), "FloatType") + return result814 } func (p *Parser) parse_uint128_type() *pb.UInt128Type { - span_start814 := int64(p.spanStart()) + span_start815 := int64(p.spanStart()) p.consumeLiteral("UINT128") - _t1546 := &pb.UInt128Type{} - result815 := _t1546 - p.recordSpan(int(span_start814), "UInt128Type") - return result815 + _t1548 := &pb.UInt128Type{} + result816 := _t1548 + p.recordSpan(int(span_start815), "UInt128Type") + return result816 } func (p *Parser) parse_int128_type() *pb.Int128Type { - span_start816 := int64(p.spanStart()) + span_start817 := int64(p.spanStart()) p.consumeLiteral("INT128") - _t1547 := &pb.Int128Type{} - result817 := _t1547 - p.recordSpan(int(span_start816), "Int128Type") - return result817 + _t1549 := &pb.Int128Type{} + result818 := _t1549 + p.recordSpan(int(span_start817), "Int128Type") + return result818 } func (p *Parser) parse_date_type() *pb.DateType { - span_start818 := int64(p.spanStart()) + span_start819 := int64(p.spanStart()) p.consumeLiteral("DATE") - _t1548 := &pb.DateType{} - result819 := _t1548 - p.recordSpan(int(span_start818), "DateType") - return result819 + _t1550 := &pb.DateType{} + result820 := _t1550 + p.recordSpan(int(span_start819), "DateType") + return result820 } func (p *Parser) parse_datetime_type() *pb.DateTimeType { - span_start820 := int64(p.spanStart()) + span_start821 := int64(p.spanStart()) p.consumeLiteral("DATETIME") - _t1549 := &pb.DateTimeType{} - result821 := _t1549 - p.recordSpan(int(span_start820), "DateTimeType") - return result821 + _t1551 := &pb.DateTimeType{} + result822 := _t1551 + p.recordSpan(int(span_start821), "DateTimeType") + return result822 } func (p *Parser) parse_missing_type() *pb.MissingType { - span_start822 := int64(p.spanStart()) + span_start823 := int64(p.spanStart()) p.consumeLiteral("MISSING") - _t1550 := &pb.MissingType{} - result823 := _t1550 - p.recordSpan(int(span_start822), "MissingType") - return result823 + _t1552 := &pb.MissingType{} + result824 := _t1552 + p.recordSpan(int(span_start823), "MissingType") + return result824 } func (p *Parser) parse_decimal_type() *pb.DecimalType { - span_start826 := int64(p.spanStart()) + span_start827 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("DECIMAL") - int824 := p.consumeTerminal("INT").Value.i64 - int_3825 := p.consumeTerminal("INT").Value.i64 + int825 := p.consumeTerminal("INT").Value.i64 + int_3826 := p.consumeTerminal("INT").Value.i64 p.consumeLiteral(")") - _t1551 := &pb.DecimalType{Precision: int32(int824), Scale: int32(int_3825)} - result827 := _t1551 - p.recordSpan(int(span_start826), "DecimalType") - return result827 + _t1553 := &pb.DecimalType{Precision: int32(int825), Scale: int32(int_3826)} + result828 := _t1553 + p.recordSpan(int(span_start827), "DecimalType") + return result828 } func (p *Parser) parse_boolean_type() *pb.BooleanType { - span_start828 := int64(p.spanStart()) + span_start829 := int64(p.spanStart()) p.consumeLiteral("BOOLEAN") - _t1552 := &pb.BooleanType{} - result829 := _t1552 - p.recordSpan(int(span_start828), "BooleanType") - return result829 + _t1554 := &pb.BooleanType{} + result830 := _t1554 + p.recordSpan(int(span_start829), "BooleanType") + return result830 } func (p *Parser) parse_int32_type() *pb.Int32Type { - span_start830 := int64(p.spanStart()) + span_start831 := int64(p.spanStart()) p.consumeLiteral("INT32") - _t1553 := &pb.Int32Type{} - result831 := _t1553 - p.recordSpan(int(span_start830), "Int32Type") - return result831 + _t1555 := &pb.Int32Type{} + result832 := _t1555 + p.recordSpan(int(span_start831), "Int32Type") + return result832 } func (p *Parser) parse_float32_type() *pb.Float32Type { - span_start832 := int64(p.spanStart()) + span_start833 := int64(p.spanStart()) p.consumeLiteral("FLOAT32") - _t1554 := &pb.Float32Type{} - result833 := _t1554 - p.recordSpan(int(span_start832), "Float32Type") - return result833 + _t1556 := &pb.Float32Type{} + result834 := _t1556 + p.recordSpan(int(span_start833), "Float32Type") + return result834 } func (p *Parser) parse_uint32_type() *pb.UInt32Type { - span_start834 := int64(p.spanStart()) + span_start835 := int64(p.spanStart()) p.consumeLiteral("UINT32") - _t1555 := &pb.UInt32Type{} - result835 := _t1555 - p.recordSpan(int(span_start834), "UInt32Type") - return result835 + _t1557 := &pb.UInt32Type{} + result836 := _t1557 + p.recordSpan(int(span_start835), "UInt32Type") + return result836 } func (p *Parser) parse_value_bindings() []*pb.Binding { p.consumeLiteral("|") - xs836 := []*pb.Binding{} - cond837 := p.matchLookaheadTerminal("SYMBOL", 0) - for cond837 { - _t1556 := p.parse_binding() - item838 := _t1556 - xs836 = append(xs836, item838) - cond837 = p.matchLookaheadTerminal("SYMBOL", 0) + xs837 := []*pb.Binding{} + cond838 := p.matchLookaheadTerminal("SYMBOL", 0) + for cond838 { + _t1558 := p.parse_binding() + item839 := _t1558 + xs837 = append(xs837, item839) + cond838 = p.matchLookaheadTerminal("SYMBOL", 0) } - bindings839 := xs836 - return bindings839 + bindings840 := xs837 + return bindings840 } func (p *Parser) parse_formula() *pb.Formula { - span_start854 := int64(p.spanStart()) - var _t1557 int64 + span_start855 := int64(p.spanStart()) + var _t1559 int64 if p.matchLookaheadLiteral("(", 0) { - var _t1558 int64 + var _t1560 int64 if p.matchLookaheadLiteral("true", 1) { - _t1558 = 0 + _t1560 = 0 } else { - var _t1559 int64 + var _t1561 int64 if p.matchLookaheadLiteral("relatom", 1) { - _t1559 = 11 + _t1561 = 11 } else { - var _t1560 int64 + var _t1562 int64 if p.matchLookaheadLiteral("reduce", 1) { - _t1560 = 3 + _t1562 = 3 } else { - var _t1561 int64 + var _t1563 int64 if p.matchLookaheadLiteral("primitive", 1) { - _t1561 = 10 + _t1563 = 10 } else { - var _t1562 int64 + var _t1564 int64 if p.matchLookaheadLiteral("pragma", 1) { - _t1562 = 9 + _t1564 = 9 } else { - var _t1563 int64 + var _t1565 int64 if p.matchLookaheadLiteral("or", 1) { - _t1563 = 5 + _t1565 = 5 } else { - var _t1564 int64 + var _t1566 int64 if p.matchLookaheadLiteral("not", 1) { - _t1564 = 6 + _t1566 = 6 } else { - var _t1565 int64 + var _t1567 int64 if p.matchLookaheadLiteral("ffi", 1) { - _t1565 = 7 + _t1567 = 7 } else { - var _t1566 int64 + var _t1568 int64 if p.matchLookaheadLiteral("false", 1) { - _t1566 = 1 + _t1568 = 1 } else { - var _t1567 int64 + var _t1569 int64 if p.matchLookaheadLiteral("exists", 1) { - _t1567 = 2 + _t1569 = 2 } else { - var _t1568 int64 + var _t1570 int64 if p.matchLookaheadLiteral("cast", 1) { - _t1568 = 12 + _t1570 = 12 } else { - var _t1569 int64 + var _t1571 int64 if p.matchLookaheadLiteral("atom", 1) { - _t1569 = 8 + _t1571 = 8 } else { - var _t1570 int64 + var _t1572 int64 if p.matchLookaheadLiteral("and", 1) { - _t1570 = 4 + _t1572 = 4 } else { - var _t1571 int64 + var _t1573 int64 if p.matchLookaheadLiteral(">=", 1) { - _t1571 = 10 + _t1573 = 10 } else { - var _t1572 int64 + var _t1574 int64 if p.matchLookaheadLiteral(">", 1) { - _t1572 = 10 + _t1574 = 10 } else { - var _t1573 int64 + var _t1575 int64 if p.matchLookaheadLiteral("=", 1) { - _t1573 = 10 + _t1575 = 10 } else { - var _t1574 int64 + var _t1576 int64 if p.matchLookaheadLiteral("<=", 1) { - _t1574 = 10 + _t1576 = 10 } else { - var _t1575 int64 + var _t1577 int64 if p.matchLookaheadLiteral("<", 1) { - _t1575 = 10 + _t1577 = 10 } else { - var _t1576 int64 + var _t1578 int64 if p.matchLookaheadLiteral("/", 1) { - _t1576 = 10 + _t1578 = 10 } else { - var _t1577 int64 + var _t1579 int64 if p.matchLookaheadLiteral("-", 1) { - _t1577 = 10 + _t1579 = 10 } else { - var _t1578 int64 + var _t1580 int64 if p.matchLookaheadLiteral("+", 1) { - _t1578 = 10 + _t1580 = 10 } else { - var _t1579 int64 + var _t1581 int64 if p.matchLookaheadLiteral("*", 1) { - _t1579 = 10 + _t1581 = 10 } else { - _t1579 = -1 + _t1581 = -1 } - _t1578 = _t1579 + _t1580 = _t1581 } - _t1577 = _t1578 + _t1579 = _t1580 } - _t1576 = _t1577 + _t1578 = _t1579 } - _t1575 = _t1576 + _t1577 = _t1578 } - _t1574 = _t1575 + _t1576 = _t1577 } - _t1573 = _t1574 + _t1575 = _t1576 } - _t1572 = _t1573 + _t1574 = _t1575 } - _t1571 = _t1572 + _t1573 = _t1574 } - _t1570 = _t1571 + _t1572 = _t1573 } - _t1569 = _t1570 + _t1571 = _t1572 } - _t1568 = _t1569 + _t1570 = _t1571 } - _t1567 = _t1568 + _t1569 = _t1570 } - _t1566 = _t1567 + _t1568 = _t1569 } - _t1565 = _t1566 + _t1567 = _t1568 } - _t1564 = _t1565 + _t1566 = _t1567 } - _t1563 = _t1564 + _t1565 = _t1566 } - _t1562 = _t1563 + _t1564 = _t1565 } - _t1561 = _t1562 + _t1563 = _t1564 } - _t1560 = _t1561 + _t1562 = _t1563 } - _t1559 = _t1560 + _t1561 = _t1562 } - _t1558 = _t1559 + _t1560 = _t1561 } - _t1557 = _t1558 + _t1559 = _t1560 } else { - _t1557 = -1 - } - prediction840 := _t1557 - var _t1580 *pb.Formula - if prediction840 == 12 { - _t1581 := p.parse_cast() - cast853 := _t1581 - _t1582 := &pb.Formula{} - _t1582.FormulaType = &pb.Formula_Cast{Cast: cast853} - _t1580 = _t1582 + _t1559 = -1 + } + prediction841 := _t1559 + var _t1582 *pb.Formula + if prediction841 == 12 { + _t1583 := p.parse_cast() + cast854 := _t1583 + _t1584 := &pb.Formula{} + _t1584.FormulaType = &pb.Formula_Cast{Cast: cast854} + _t1582 = _t1584 } else { - var _t1583 *pb.Formula - if prediction840 == 11 { - _t1584 := p.parse_rel_atom() - rel_atom852 := _t1584 - _t1585 := &pb.Formula{} - _t1585.FormulaType = &pb.Formula_RelAtom{RelAtom: rel_atom852} - _t1583 = _t1585 + var _t1585 *pb.Formula + if prediction841 == 11 { + _t1586 := p.parse_rel_atom() + rel_atom853 := _t1586 + _t1587 := &pb.Formula{} + _t1587.FormulaType = &pb.Formula_RelAtom{RelAtom: rel_atom853} + _t1585 = _t1587 } else { - var _t1586 *pb.Formula - if prediction840 == 10 { - _t1587 := p.parse_primitive() - primitive851 := _t1587 - _t1588 := &pb.Formula{} - _t1588.FormulaType = &pb.Formula_Primitive{Primitive: primitive851} - _t1586 = _t1588 + var _t1588 *pb.Formula + if prediction841 == 10 { + _t1589 := p.parse_primitive() + primitive852 := _t1589 + _t1590 := &pb.Formula{} + _t1590.FormulaType = &pb.Formula_Primitive{Primitive: primitive852} + _t1588 = _t1590 } else { - var _t1589 *pb.Formula - if prediction840 == 9 { - _t1590 := p.parse_pragma() - pragma850 := _t1590 - _t1591 := &pb.Formula{} - _t1591.FormulaType = &pb.Formula_Pragma{Pragma: pragma850} - _t1589 = _t1591 + var _t1591 *pb.Formula + if prediction841 == 9 { + _t1592 := p.parse_pragma() + pragma851 := _t1592 + _t1593 := &pb.Formula{} + _t1593.FormulaType = &pb.Formula_Pragma{Pragma: pragma851} + _t1591 = _t1593 } else { - var _t1592 *pb.Formula - if prediction840 == 8 { - _t1593 := p.parse_atom() - atom849 := _t1593 - _t1594 := &pb.Formula{} - _t1594.FormulaType = &pb.Formula_Atom{Atom: atom849} - _t1592 = _t1594 + var _t1594 *pb.Formula + if prediction841 == 8 { + _t1595 := p.parse_atom() + atom850 := _t1595 + _t1596 := &pb.Formula{} + _t1596.FormulaType = &pb.Formula_Atom{Atom: atom850} + _t1594 = _t1596 } else { - var _t1595 *pb.Formula - if prediction840 == 7 { - _t1596 := p.parse_ffi() - ffi848 := _t1596 - _t1597 := &pb.Formula{} - _t1597.FormulaType = &pb.Formula_Ffi{Ffi: ffi848} - _t1595 = _t1597 + var _t1597 *pb.Formula + if prediction841 == 7 { + _t1598 := p.parse_ffi() + ffi849 := _t1598 + _t1599 := &pb.Formula{} + _t1599.FormulaType = &pb.Formula_Ffi{Ffi: ffi849} + _t1597 = _t1599 } else { - var _t1598 *pb.Formula - if prediction840 == 6 { - _t1599 := p.parse_not() - not847 := _t1599 - _t1600 := &pb.Formula{} - _t1600.FormulaType = &pb.Formula_Not{Not: not847} - _t1598 = _t1600 + var _t1600 *pb.Formula + if prediction841 == 6 { + _t1601 := p.parse_not() + not848 := _t1601 + _t1602 := &pb.Formula{} + _t1602.FormulaType = &pb.Formula_Not{Not: not848} + _t1600 = _t1602 } else { - var _t1601 *pb.Formula - if prediction840 == 5 { - _t1602 := p.parse_disjunction() - disjunction846 := _t1602 - _t1603 := &pb.Formula{} - _t1603.FormulaType = &pb.Formula_Disjunction{Disjunction: disjunction846} - _t1601 = _t1603 + var _t1603 *pb.Formula + if prediction841 == 5 { + _t1604 := p.parse_disjunction() + disjunction847 := _t1604 + _t1605 := &pb.Formula{} + _t1605.FormulaType = &pb.Formula_Disjunction{Disjunction: disjunction847} + _t1603 = _t1605 } else { - var _t1604 *pb.Formula - if prediction840 == 4 { - _t1605 := p.parse_conjunction() - conjunction845 := _t1605 - _t1606 := &pb.Formula{} - _t1606.FormulaType = &pb.Formula_Conjunction{Conjunction: conjunction845} - _t1604 = _t1606 + var _t1606 *pb.Formula + if prediction841 == 4 { + _t1607 := p.parse_conjunction() + conjunction846 := _t1607 + _t1608 := &pb.Formula{} + _t1608.FormulaType = &pb.Formula_Conjunction{Conjunction: conjunction846} + _t1606 = _t1608 } else { - var _t1607 *pb.Formula - if prediction840 == 3 { - _t1608 := p.parse_reduce() - reduce844 := _t1608 - _t1609 := &pb.Formula{} - _t1609.FormulaType = &pb.Formula_Reduce{Reduce: reduce844} - _t1607 = _t1609 + var _t1609 *pb.Formula + if prediction841 == 3 { + _t1610 := p.parse_reduce() + reduce845 := _t1610 + _t1611 := &pb.Formula{} + _t1611.FormulaType = &pb.Formula_Reduce{Reduce: reduce845} + _t1609 = _t1611 } else { - var _t1610 *pb.Formula - if prediction840 == 2 { - _t1611 := p.parse_exists() - exists843 := _t1611 - _t1612 := &pb.Formula{} - _t1612.FormulaType = &pb.Formula_Exists{Exists: exists843} - _t1610 = _t1612 + var _t1612 *pb.Formula + if prediction841 == 2 { + _t1613 := p.parse_exists() + exists844 := _t1613 + _t1614 := &pb.Formula{} + _t1614.FormulaType = &pb.Formula_Exists{Exists: exists844} + _t1612 = _t1614 } else { - var _t1613 *pb.Formula - if prediction840 == 1 { - _t1614 := p.parse_false() - false842 := _t1614 - _t1615 := &pb.Formula{} - _t1615.FormulaType = &pb.Formula_Disjunction{Disjunction: false842} - _t1613 = _t1615 + var _t1615 *pb.Formula + if prediction841 == 1 { + _t1616 := p.parse_false() + false843 := _t1616 + _t1617 := &pb.Formula{} + _t1617.FormulaType = &pb.Formula_Disjunction{Disjunction: false843} + _t1615 = _t1617 } else { - var _t1616 *pb.Formula - if prediction840 == 0 { - _t1617 := p.parse_true() - true841 := _t1617 - _t1618 := &pb.Formula{} - _t1618.FormulaType = &pb.Formula_Conjunction{Conjunction: true841} - _t1616 = _t1618 + var _t1618 *pb.Formula + if prediction841 == 0 { + _t1619 := p.parse_true() + true842 := _t1619 + _t1620 := &pb.Formula{} + _t1620.FormulaType = &pb.Formula_Conjunction{Conjunction: true842} + _t1618 = _t1620 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in formula", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1613 = _t1616 + _t1615 = _t1618 } - _t1610 = _t1613 + _t1612 = _t1615 } - _t1607 = _t1610 + _t1609 = _t1612 } - _t1604 = _t1607 + _t1606 = _t1609 } - _t1601 = _t1604 + _t1603 = _t1606 } - _t1598 = _t1601 + _t1600 = _t1603 } - _t1595 = _t1598 + _t1597 = _t1600 } - _t1592 = _t1595 + _t1594 = _t1597 } - _t1589 = _t1592 + _t1591 = _t1594 } - _t1586 = _t1589 + _t1588 = _t1591 } - _t1583 = _t1586 + _t1585 = _t1588 } - _t1580 = _t1583 + _t1582 = _t1585 } - result855 := _t1580 - p.recordSpan(int(span_start854), "Formula") - return result855 + result856 := _t1582 + p.recordSpan(int(span_start855), "Formula") + return result856 } func (p *Parser) parse_true() *pb.Conjunction { - span_start856 := int64(p.spanStart()) + span_start857 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("true") p.consumeLiteral(")") - _t1619 := &pb.Conjunction{Args: []*pb.Formula{}} - result857 := _t1619 - p.recordSpan(int(span_start856), "Conjunction") - return result857 + _t1621 := &pb.Conjunction{Args: []*pb.Formula{}} + result858 := _t1621 + p.recordSpan(int(span_start857), "Conjunction") + return result858 } func (p *Parser) parse_false() *pb.Disjunction { - span_start858 := int64(p.spanStart()) + span_start859 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("false") p.consumeLiteral(")") - _t1620 := &pb.Disjunction{Args: []*pb.Formula{}} - result859 := _t1620 - p.recordSpan(int(span_start858), "Disjunction") - return result859 + _t1622 := &pb.Disjunction{Args: []*pb.Formula{}} + result860 := _t1622 + p.recordSpan(int(span_start859), "Disjunction") + return result860 } func (p *Parser) parse_exists() *pb.Exists { - span_start862 := int64(p.spanStart()) + span_start863 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("exists") - _t1621 := p.parse_bindings() - bindings860 := _t1621 - _t1622 := p.parse_formula() - formula861 := _t1622 + _t1623 := p.parse_bindings() + bindings861 := _t1623 + _t1624 := p.parse_formula() + formula862 := _t1624 p.consumeLiteral(")") - _t1623 := &pb.Abstraction{Vars: listConcat(bindings860[0].([]*pb.Binding), bindings860[1].([]*pb.Binding)), Value: formula861} - _t1624 := &pb.Exists{Body: _t1623} - result863 := _t1624 - p.recordSpan(int(span_start862), "Exists") - return result863 + _t1625 := &pb.Abstraction{Vars: listConcat(bindings861[0].([]*pb.Binding), bindings861[1].([]*pb.Binding)), Value: formula862} + _t1626 := &pb.Exists{Body: _t1625} + result864 := _t1626 + p.recordSpan(int(span_start863), "Exists") + return result864 } func (p *Parser) parse_reduce() *pb.Reduce { - span_start867 := int64(p.spanStart()) + span_start868 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("reduce") - _t1625 := p.parse_abstraction() - abstraction864 := _t1625 - _t1626 := p.parse_abstraction() - abstraction_3865 := _t1626 - _t1627 := p.parse_terms() - terms866 := _t1627 + _t1627 := p.parse_abstraction() + abstraction865 := _t1627 + _t1628 := p.parse_abstraction() + abstraction_3866 := _t1628 + _t1629 := p.parse_terms() + terms867 := _t1629 p.consumeLiteral(")") - _t1628 := &pb.Reduce{Op: abstraction864, Body: abstraction_3865, Terms: terms866} - result868 := _t1628 - p.recordSpan(int(span_start867), "Reduce") - return result868 + _t1630 := &pb.Reduce{Op: abstraction865, Body: abstraction_3866, Terms: terms867} + result869 := _t1630 + p.recordSpan(int(span_start868), "Reduce") + return result869 } func (p *Parser) parse_terms() []*pb.Term { p.consumeLiteral("(") p.consumeLiteral("terms") - xs869 := []*pb.Term{} - cond870 := (((((((((((((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 cond870 { - _t1629 := p.parse_term() - item871 := _t1629 - xs869 = append(xs869, item871) - cond870 = (((((((((((((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)) - } - terms872 := xs869 + xs870 := []*pb.Term{} + cond871 := (((((((((((((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 cond871 { + _t1631 := p.parse_term() + item872 := _t1631 + xs870 = append(xs870, item872) + cond871 = (((((((((((((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)) + } + terms873 := xs870 p.consumeLiteral(")") - return terms872 + return terms873 } func (p *Parser) parse_term() *pb.Term { - span_start876 := int64(p.spanStart()) - var _t1630 int64 + span_start877 := int64(p.spanStart()) + var _t1632 int64 if p.matchLookaheadLiteral("true", 0) { - _t1630 = 1 + _t1632 = 1 } else { - var _t1631 int64 + var _t1633 int64 if p.matchLookaheadLiteral("missing", 0) { - _t1631 = 1 + _t1633 = 1 } else { - var _t1632 int64 + var _t1634 int64 if p.matchLookaheadLiteral("false", 0) { - _t1632 = 1 + _t1634 = 1 } else { - var _t1633 int64 + var _t1635 int64 if p.matchLookaheadLiteral("(", 0) { - _t1633 = 1 + _t1635 = 1 } else { - var _t1634 int64 + var _t1636 int64 if p.matchLookaheadTerminal("SYMBOL", 0) { - _t1634 = 0 + _t1636 = 0 } else { - var _t1635 int64 + var _t1637 int64 if p.matchLookaheadTerminal("UINT32", 0) { - _t1635 = 1 + _t1637 = 1 } else { - var _t1636 int64 + var _t1638 int64 if p.matchLookaheadTerminal("UINT128", 0) { - _t1636 = 1 + _t1638 = 1 } else { - var _t1637 int64 + var _t1639 int64 if p.matchLookaheadTerminal("STRING", 0) { - _t1637 = 1 + _t1639 = 1 } else { - var _t1638 int64 + var _t1640 int64 if p.matchLookaheadTerminal("INT32", 0) { - _t1638 = 1 + _t1640 = 1 } else { - var _t1639 int64 + var _t1641 int64 if p.matchLookaheadTerminal("INT128", 0) { - _t1639 = 1 + _t1641 = 1 } else { - var _t1640 int64 + var _t1642 int64 if p.matchLookaheadTerminal("INT", 0) { - _t1640 = 1 + _t1642 = 1 } else { - var _t1641 int64 + var _t1643 int64 if p.matchLookaheadTerminal("FLOAT32", 0) { - _t1641 = 1 + _t1643 = 1 } else { - var _t1642 int64 + var _t1644 int64 if p.matchLookaheadTerminal("FLOAT", 0) { - _t1642 = 1 + _t1644 = 1 } else { - var _t1643 int64 + var _t1645 int64 if p.matchLookaheadTerminal("DECIMAL", 0) { - _t1643 = 1 + _t1645 = 1 } else { - _t1643 = -1 + _t1645 = -1 } - _t1642 = _t1643 + _t1644 = _t1645 } - _t1641 = _t1642 + _t1643 = _t1644 } - _t1640 = _t1641 + _t1642 = _t1643 } - _t1639 = _t1640 + _t1641 = _t1642 } - _t1638 = _t1639 + _t1640 = _t1641 } - _t1637 = _t1638 + _t1639 = _t1640 } - _t1636 = _t1637 + _t1638 = _t1639 } - _t1635 = _t1636 + _t1637 = _t1638 } - _t1634 = _t1635 + _t1636 = _t1637 } - _t1633 = _t1634 + _t1635 = _t1636 } - _t1632 = _t1633 + _t1634 = _t1635 } - _t1631 = _t1632 + _t1633 = _t1634 } - _t1630 = _t1631 - } - prediction873 := _t1630 - var _t1644 *pb.Term - if prediction873 == 1 { - _t1645 := p.parse_value() - value875 := _t1645 - _t1646 := &pb.Term{} - _t1646.TermType = &pb.Term_Constant{Constant: value875} - _t1644 = _t1646 + _t1632 = _t1633 + } + prediction874 := _t1632 + var _t1646 *pb.Term + if prediction874 == 1 { + _t1647 := p.parse_value() + value876 := _t1647 + _t1648 := &pb.Term{} + _t1648.TermType = &pb.Term_Constant{Constant: value876} + _t1646 = _t1648 } else { - var _t1647 *pb.Term - if prediction873 == 0 { - _t1648 := p.parse_var() - var874 := _t1648 - _t1649 := &pb.Term{} - _t1649.TermType = &pb.Term_Var{Var: var874} - _t1647 = _t1649 + var _t1649 *pb.Term + if prediction874 == 0 { + _t1650 := p.parse_var() + var875 := _t1650 + _t1651 := &pb.Term{} + _t1651.TermType = &pb.Term_Var{Var: var875} + _t1649 = _t1651 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in term", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1644 = _t1647 + _t1646 = _t1649 } - result877 := _t1644 - p.recordSpan(int(span_start876), "Term") - return result877 + result878 := _t1646 + p.recordSpan(int(span_start877), "Term") + return result878 } func (p *Parser) parse_var() *pb.Var { - span_start879 := int64(p.spanStart()) - symbol878 := p.consumeTerminal("SYMBOL").Value.str - _t1650 := &pb.Var{Name: symbol878} - result880 := _t1650 - p.recordSpan(int(span_start879), "Var") - return result880 + span_start880 := int64(p.spanStart()) + symbol879 := p.consumeTerminal("SYMBOL").Value.str + _t1652 := &pb.Var{Name: symbol879} + result881 := _t1652 + p.recordSpan(int(span_start880), "Var") + return result881 } func (p *Parser) parse_value() *pb.Value { - span_start894 := int64(p.spanStart()) - var _t1651 int64 + span_start895 := int64(p.spanStart()) + var _t1653 int64 if p.matchLookaheadLiteral("true", 0) { - _t1651 = 12 + _t1653 = 12 } else { - var _t1652 int64 + var _t1654 int64 if p.matchLookaheadLiteral("missing", 0) { - _t1652 = 11 + _t1654 = 11 } else { - var _t1653 int64 + var _t1655 int64 if p.matchLookaheadLiteral("false", 0) { - _t1653 = 12 + _t1655 = 12 } else { - var _t1654 int64 + var _t1656 int64 if p.matchLookaheadLiteral("(", 0) { - var _t1655 int64 + var _t1657 int64 if p.matchLookaheadLiteral("datetime", 1) { - _t1655 = 1 + _t1657 = 1 } else { - var _t1656 int64 + var _t1658 int64 if p.matchLookaheadLiteral("date", 1) { - _t1656 = 0 + _t1658 = 0 } else { - _t1656 = -1 + _t1658 = -1 } - _t1655 = _t1656 + _t1657 = _t1658 } - _t1654 = _t1655 + _t1656 = _t1657 } else { - var _t1657 int64 + var _t1659 int64 if p.matchLookaheadTerminal("UINT32", 0) { - _t1657 = 7 + _t1659 = 7 } else { - var _t1658 int64 + var _t1660 int64 if p.matchLookaheadTerminal("UINT128", 0) { - _t1658 = 8 + _t1660 = 8 } else { - var _t1659 int64 + var _t1661 int64 if p.matchLookaheadTerminal("STRING", 0) { - _t1659 = 2 + _t1661 = 2 } else { - var _t1660 int64 + var _t1662 int64 if p.matchLookaheadTerminal("INT32", 0) { - _t1660 = 3 + _t1662 = 3 } else { - var _t1661 int64 + var _t1663 int64 if p.matchLookaheadTerminal("INT128", 0) { - _t1661 = 9 + _t1663 = 9 } else { - var _t1662 int64 + var _t1664 int64 if p.matchLookaheadTerminal("INT", 0) { - _t1662 = 4 + _t1664 = 4 } else { - var _t1663 int64 + var _t1665 int64 if p.matchLookaheadTerminal("FLOAT32", 0) { - _t1663 = 5 + _t1665 = 5 } else { - var _t1664 int64 + var _t1666 int64 if p.matchLookaheadTerminal("FLOAT", 0) { - _t1664 = 6 + _t1666 = 6 } else { - var _t1665 int64 + var _t1667 int64 if p.matchLookaheadTerminal("DECIMAL", 0) { - _t1665 = 10 + _t1667 = 10 } else { - _t1665 = -1 + _t1667 = -1 } - _t1664 = _t1665 + _t1666 = _t1667 } - _t1663 = _t1664 + _t1665 = _t1666 } - _t1662 = _t1663 + _t1664 = _t1665 } - _t1661 = _t1662 + _t1663 = _t1664 } - _t1660 = _t1661 + _t1662 = _t1663 } - _t1659 = _t1660 + _t1661 = _t1662 } - _t1658 = _t1659 + _t1660 = _t1661 } - _t1657 = _t1658 + _t1659 = _t1660 } - _t1654 = _t1657 + _t1656 = _t1659 } - _t1653 = _t1654 + _t1655 = _t1656 } - _t1652 = _t1653 + _t1654 = _t1655 } - _t1651 = _t1652 - } - prediction881 := _t1651 - var _t1666 *pb.Value - if prediction881 == 12 { - _t1667 := p.parse_boolean_value() - boolean_value893 := _t1667 - _t1668 := &pb.Value{} - _t1668.Value = &pb.Value_BooleanValue{BooleanValue: boolean_value893} - _t1666 = _t1668 + _t1653 = _t1654 + } + prediction882 := _t1653 + var _t1668 *pb.Value + if prediction882 == 12 { + _t1669 := p.parse_boolean_value() + boolean_value894 := _t1669 + _t1670 := &pb.Value{} + _t1670.Value = &pb.Value_BooleanValue{BooleanValue: boolean_value894} + _t1668 = _t1670 } else { - var _t1669 *pb.Value - if prediction881 == 11 { + var _t1671 *pb.Value + if prediction882 == 11 { p.consumeLiteral("missing") - _t1670 := &pb.MissingValue{} - _t1671 := &pb.Value{} - _t1671.Value = &pb.Value_MissingValue{MissingValue: _t1670} - _t1669 = _t1671 + _t1672 := &pb.MissingValue{} + _t1673 := &pb.Value{} + _t1673.Value = &pb.Value_MissingValue{MissingValue: _t1672} + _t1671 = _t1673 } else { - var _t1672 *pb.Value - if prediction881 == 10 { - formatted_decimal892 := p.consumeTerminal("DECIMAL").Value.decimal - _t1673 := &pb.Value{} - _t1673.Value = &pb.Value_DecimalValue{DecimalValue: formatted_decimal892} - _t1672 = _t1673 + var _t1674 *pb.Value + if prediction882 == 10 { + formatted_decimal893 := p.consumeTerminal("DECIMAL").Value.decimal + _t1675 := &pb.Value{} + _t1675.Value = &pb.Value_DecimalValue{DecimalValue: formatted_decimal893} + _t1674 = _t1675 } else { - var _t1674 *pb.Value - if prediction881 == 9 { - formatted_int128891 := p.consumeTerminal("INT128").Value.int128 - _t1675 := &pb.Value{} - _t1675.Value = &pb.Value_Int128Value{Int128Value: formatted_int128891} - _t1674 = _t1675 + var _t1676 *pb.Value + if prediction882 == 9 { + formatted_int128892 := p.consumeTerminal("INT128").Value.int128 + _t1677 := &pb.Value{} + _t1677.Value = &pb.Value_Int128Value{Int128Value: formatted_int128892} + _t1676 = _t1677 } else { - var _t1676 *pb.Value - if prediction881 == 8 { - formatted_uint128890 := p.consumeTerminal("UINT128").Value.uint128 - _t1677 := &pb.Value{} - _t1677.Value = &pb.Value_Uint128Value{Uint128Value: formatted_uint128890} - _t1676 = _t1677 + var _t1678 *pb.Value + if prediction882 == 8 { + formatted_uint128891 := p.consumeTerminal("UINT128").Value.uint128 + _t1679 := &pb.Value{} + _t1679.Value = &pb.Value_Uint128Value{Uint128Value: formatted_uint128891} + _t1678 = _t1679 } else { - var _t1678 *pb.Value - if prediction881 == 7 { - formatted_uint32889 := p.consumeTerminal("UINT32").Value.u32 - _t1679 := &pb.Value{} - _t1679.Value = &pb.Value_Uint32Value{Uint32Value: formatted_uint32889} - _t1678 = _t1679 + var _t1680 *pb.Value + if prediction882 == 7 { + formatted_uint32890 := p.consumeTerminal("UINT32").Value.u32 + _t1681 := &pb.Value{} + _t1681.Value = &pb.Value_Uint32Value{Uint32Value: formatted_uint32890} + _t1680 = _t1681 } else { - var _t1680 *pb.Value - if prediction881 == 6 { - formatted_float888 := p.consumeTerminal("FLOAT").Value.f64 - _t1681 := &pb.Value{} - _t1681.Value = &pb.Value_FloatValue{FloatValue: formatted_float888} - _t1680 = _t1681 + var _t1682 *pb.Value + if prediction882 == 6 { + formatted_float889 := p.consumeTerminal("FLOAT").Value.f64 + _t1683 := &pb.Value{} + _t1683.Value = &pb.Value_FloatValue{FloatValue: formatted_float889} + _t1682 = _t1683 } else { - var _t1682 *pb.Value - if prediction881 == 5 { - formatted_float32887 := p.consumeTerminal("FLOAT32").Value.f32 - _t1683 := &pb.Value{} - _t1683.Value = &pb.Value_Float32Value{Float32Value: formatted_float32887} - _t1682 = _t1683 + var _t1684 *pb.Value + if prediction882 == 5 { + formatted_float32888 := p.consumeTerminal("FLOAT32").Value.f32 + _t1685 := &pb.Value{} + _t1685.Value = &pb.Value_Float32Value{Float32Value: formatted_float32888} + _t1684 = _t1685 } else { - var _t1684 *pb.Value - if prediction881 == 4 { - formatted_int886 := p.consumeTerminal("INT").Value.i64 - _t1685 := &pb.Value{} - _t1685.Value = &pb.Value_IntValue{IntValue: formatted_int886} - _t1684 = _t1685 + var _t1686 *pb.Value + if prediction882 == 4 { + formatted_int887 := p.consumeTerminal("INT").Value.i64 + _t1687 := &pb.Value{} + _t1687.Value = &pb.Value_IntValue{IntValue: formatted_int887} + _t1686 = _t1687 } else { - var _t1686 *pb.Value - if prediction881 == 3 { - formatted_int32885 := p.consumeTerminal("INT32").Value.i32 - _t1687 := &pb.Value{} - _t1687.Value = &pb.Value_Int32Value{Int32Value: formatted_int32885} - _t1686 = _t1687 + var _t1688 *pb.Value + if prediction882 == 3 { + formatted_int32886 := p.consumeTerminal("INT32").Value.i32 + _t1689 := &pb.Value{} + _t1689.Value = &pb.Value_Int32Value{Int32Value: formatted_int32886} + _t1688 = _t1689 } else { - var _t1688 *pb.Value - if prediction881 == 2 { - formatted_string884 := p.consumeTerminal("STRING").Value.str - _t1689 := &pb.Value{} - _t1689.Value = &pb.Value_StringValue{StringValue: formatted_string884} - _t1688 = _t1689 + var _t1690 *pb.Value + if prediction882 == 2 { + formatted_string885 := p.consumeTerminal("STRING").Value.str + _t1691 := &pb.Value{} + _t1691.Value = &pb.Value_StringValue{StringValue: formatted_string885} + _t1690 = _t1691 } else { - var _t1690 *pb.Value - if prediction881 == 1 { - _t1691 := p.parse_datetime() - datetime883 := _t1691 - _t1692 := &pb.Value{} - _t1692.Value = &pb.Value_DatetimeValue{DatetimeValue: datetime883} - _t1690 = _t1692 + var _t1692 *pb.Value + if prediction882 == 1 { + _t1693 := p.parse_datetime() + datetime884 := _t1693 + _t1694 := &pb.Value{} + _t1694.Value = &pb.Value_DatetimeValue{DatetimeValue: datetime884} + _t1692 = _t1694 } else { - var _t1693 *pb.Value - if prediction881 == 0 { - _t1694 := p.parse_date() - date882 := _t1694 - _t1695 := &pb.Value{} - _t1695.Value = &pb.Value_DateValue{DateValue: date882} - _t1693 = _t1695 + var _t1695 *pb.Value + if prediction882 == 0 { + _t1696 := p.parse_date() + date883 := _t1696 + _t1697 := &pb.Value{} + _t1697.Value = &pb.Value_DateValue{DateValue: date883} + _t1695 = _t1697 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in value", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1690 = _t1693 + _t1692 = _t1695 } - _t1688 = _t1690 + _t1690 = _t1692 } - _t1686 = _t1688 + _t1688 = _t1690 } - _t1684 = _t1686 + _t1686 = _t1688 } - _t1682 = _t1684 + _t1684 = _t1686 } - _t1680 = _t1682 + _t1682 = _t1684 } - _t1678 = _t1680 + _t1680 = _t1682 } - _t1676 = _t1678 + _t1678 = _t1680 } - _t1674 = _t1676 + _t1676 = _t1678 } - _t1672 = _t1674 + _t1674 = _t1676 } - _t1669 = _t1672 + _t1671 = _t1674 } - _t1666 = _t1669 + _t1668 = _t1671 } - result895 := _t1666 - p.recordSpan(int(span_start894), "Value") - return result895 + result896 := _t1668 + p.recordSpan(int(span_start895), "Value") + return result896 } func (p *Parser) parse_date() *pb.DateValue { - span_start899 := int64(p.spanStart()) + span_start900 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("date") - formatted_int896 := p.consumeTerminal("INT").Value.i64 - formatted_int_3897 := p.consumeTerminal("INT").Value.i64 - formatted_int_4898 := p.consumeTerminal("INT").Value.i64 + formatted_int897 := p.consumeTerminal("INT").Value.i64 + formatted_int_3898 := p.consumeTerminal("INT").Value.i64 + formatted_int_4899 := p.consumeTerminal("INT").Value.i64 p.consumeLiteral(")") - _t1696 := &pb.DateValue{Year: int32(formatted_int896), Month: int32(formatted_int_3897), Day: int32(formatted_int_4898)} - result900 := _t1696 - p.recordSpan(int(span_start899), "DateValue") - return result900 + _t1698 := &pb.DateValue{Year: int32(formatted_int897), Month: int32(formatted_int_3898), Day: int32(formatted_int_4899)} + result901 := _t1698 + p.recordSpan(int(span_start900), "DateValue") + return result901 } func (p *Parser) parse_datetime() *pb.DateTimeValue { - span_start908 := int64(p.spanStart()) + span_start909 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("datetime") - formatted_int901 := p.consumeTerminal("INT").Value.i64 - formatted_int_3902 := p.consumeTerminal("INT").Value.i64 - formatted_int_4903 := p.consumeTerminal("INT").Value.i64 - formatted_int_5904 := p.consumeTerminal("INT").Value.i64 - formatted_int_6905 := p.consumeTerminal("INT").Value.i64 - formatted_int_7906 := p.consumeTerminal("INT").Value.i64 - var _t1697 *int64 + formatted_int902 := p.consumeTerminal("INT").Value.i64 + formatted_int_3903 := p.consumeTerminal("INT").Value.i64 + formatted_int_4904 := p.consumeTerminal("INT").Value.i64 + formatted_int_5905 := p.consumeTerminal("INT").Value.i64 + formatted_int_6906 := p.consumeTerminal("INT").Value.i64 + formatted_int_7907 := p.consumeTerminal("INT").Value.i64 + var _t1699 *int64 if p.matchLookaheadTerminal("INT", 0) { - _t1697 = ptr(p.consumeTerminal("INT").Value.i64) + _t1699 = ptr(p.consumeTerminal("INT").Value.i64) } - formatted_int_8907 := _t1697 + formatted_int_8908 := _t1699 p.consumeLiteral(")") - _t1698 := &pb.DateTimeValue{Year: int32(formatted_int901), Month: int32(formatted_int_3902), Day: int32(formatted_int_4903), Hour: int32(formatted_int_5904), Minute: int32(formatted_int_6905), Second: int32(formatted_int_7906), Microsecond: int32(deref(formatted_int_8907, 0))} - result909 := _t1698 - p.recordSpan(int(span_start908), "DateTimeValue") - return result909 + _t1700 := &pb.DateTimeValue{Year: int32(formatted_int902), Month: int32(formatted_int_3903), Day: int32(formatted_int_4904), Hour: int32(formatted_int_5905), Minute: int32(formatted_int_6906), Second: int32(formatted_int_7907), Microsecond: int32(deref(formatted_int_8908, 0))} + result910 := _t1700 + p.recordSpan(int(span_start909), "DateTimeValue") + return result910 } func (p *Parser) parse_conjunction() *pb.Conjunction { - span_start914 := int64(p.spanStart()) + span_start915 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("and") - xs910 := []*pb.Formula{} - cond911 := p.matchLookaheadLiteral("(", 0) - for cond911 { - _t1699 := p.parse_formula() - item912 := _t1699 - xs910 = append(xs910, item912) - cond911 = p.matchLookaheadLiteral("(", 0) - } - formulas913 := xs910 + xs911 := []*pb.Formula{} + cond912 := p.matchLookaheadLiteral("(", 0) + for cond912 { + _t1701 := p.parse_formula() + item913 := _t1701 + xs911 = append(xs911, item913) + cond912 = p.matchLookaheadLiteral("(", 0) + } + formulas914 := xs911 p.consumeLiteral(")") - _t1700 := &pb.Conjunction{Args: formulas913} - result915 := _t1700 - p.recordSpan(int(span_start914), "Conjunction") - return result915 + _t1702 := &pb.Conjunction{Args: formulas914} + result916 := _t1702 + p.recordSpan(int(span_start915), "Conjunction") + return result916 } func (p *Parser) parse_disjunction() *pb.Disjunction { - span_start920 := int64(p.spanStart()) + span_start921 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("or") - xs916 := []*pb.Formula{} - cond917 := p.matchLookaheadLiteral("(", 0) - for cond917 { - _t1701 := p.parse_formula() - item918 := _t1701 - xs916 = append(xs916, item918) - cond917 = p.matchLookaheadLiteral("(", 0) - } - formulas919 := xs916 + xs917 := []*pb.Formula{} + cond918 := p.matchLookaheadLiteral("(", 0) + for cond918 { + _t1703 := p.parse_formula() + item919 := _t1703 + xs917 = append(xs917, item919) + cond918 = p.matchLookaheadLiteral("(", 0) + } + formulas920 := xs917 p.consumeLiteral(")") - _t1702 := &pb.Disjunction{Args: formulas919} - result921 := _t1702 - p.recordSpan(int(span_start920), "Disjunction") - return result921 + _t1704 := &pb.Disjunction{Args: formulas920} + result922 := _t1704 + p.recordSpan(int(span_start921), "Disjunction") + return result922 } func (p *Parser) parse_not() *pb.Not { - span_start923 := int64(p.spanStart()) + span_start924 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("not") - _t1703 := p.parse_formula() - formula922 := _t1703 + _t1705 := p.parse_formula() + formula923 := _t1705 p.consumeLiteral(")") - _t1704 := &pb.Not{Arg: formula922} - result924 := _t1704 - p.recordSpan(int(span_start923), "Not") - return result924 + _t1706 := &pb.Not{Arg: formula923} + result925 := _t1706 + p.recordSpan(int(span_start924), "Not") + return result925 } func (p *Parser) parse_ffi() *pb.FFI { - span_start928 := int64(p.spanStart()) + span_start929 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("ffi") - _t1705 := p.parse_name() - name925 := _t1705 - _t1706 := p.parse_ffi_args() - ffi_args926 := _t1706 - _t1707 := p.parse_terms() - terms927 := _t1707 + _t1707 := p.parse_name() + name926 := _t1707 + _t1708 := p.parse_ffi_args() + ffi_args927 := _t1708 + _t1709 := p.parse_terms() + terms928 := _t1709 p.consumeLiteral(")") - _t1708 := &pb.FFI{Name: name925, Args: ffi_args926, Terms: terms927} - result929 := _t1708 - p.recordSpan(int(span_start928), "FFI") - return result929 + _t1710 := &pb.FFI{Name: name926, Args: ffi_args927, Terms: terms928} + result930 := _t1710 + p.recordSpan(int(span_start929), "FFI") + return result930 } func (p *Parser) parse_name() string { p.consumeLiteral(":") - symbol930 := p.consumeTerminal("SYMBOL").Value.str - return symbol930 + symbol931 := p.consumeTerminal("SYMBOL").Value.str + return symbol931 } func (p *Parser) parse_ffi_args() []*pb.Abstraction { p.consumeLiteral("(") p.consumeLiteral("args") - xs931 := []*pb.Abstraction{} - cond932 := p.matchLookaheadLiteral("(", 0) - for cond932 { - _t1709 := p.parse_abstraction() - item933 := _t1709 - xs931 = append(xs931, item933) - cond932 = p.matchLookaheadLiteral("(", 0) - } - abstractions934 := xs931 + xs932 := []*pb.Abstraction{} + cond933 := p.matchLookaheadLiteral("(", 0) + for cond933 { + _t1711 := p.parse_abstraction() + item934 := _t1711 + xs932 = append(xs932, item934) + cond933 = p.matchLookaheadLiteral("(", 0) + } + abstractions935 := xs932 p.consumeLiteral(")") - return abstractions934 + return abstractions935 } func (p *Parser) parse_atom() *pb.Atom { - span_start940 := int64(p.spanStart()) + span_start941 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("atom") - _t1710 := p.parse_relation_id() - relation_id935 := _t1710 - xs936 := []*pb.Term{} - cond937 := (((((((((((((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 cond937 { - _t1711 := p.parse_term() - item938 := _t1711 - xs936 = append(xs936, item938) - cond937 = (((((((((((((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)) - } - terms939 := xs936 + _t1712 := p.parse_relation_id() + relation_id936 := _t1712 + xs937 := []*pb.Term{} + cond938 := (((((((((((((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 cond938 { + _t1713 := p.parse_term() + item939 := _t1713 + xs937 = append(xs937, item939) + cond938 = (((((((((((((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)) + } + terms940 := xs937 p.consumeLiteral(")") - _t1712 := &pb.Atom{Name: relation_id935, Terms: terms939} - result941 := _t1712 - p.recordSpan(int(span_start940), "Atom") - return result941 + _t1714 := &pb.Atom{Name: relation_id936, Terms: terms940} + result942 := _t1714 + p.recordSpan(int(span_start941), "Atom") + return result942 } func (p *Parser) parse_pragma() *pb.Pragma { - span_start947 := int64(p.spanStart()) + span_start948 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("pragma") - _t1713 := p.parse_name() - name942 := _t1713 - xs943 := []*pb.Term{} - cond944 := (((((((((((((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 cond944 { - _t1714 := p.parse_term() - item945 := _t1714 - xs943 = append(xs943, item945) - cond944 = (((((((((((((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)) - } - terms946 := xs943 + _t1715 := p.parse_name() + name943 := _t1715 + xs944 := []*pb.Term{} + cond945 := (((((((((((((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 cond945 { + _t1716 := p.parse_term() + item946 := _t1716 + xs944 = append(xs944, item946) + cond945 = (((((((((((((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)) + } + terms947 := xs944 p.consumeLiteral(")") - _t1715 := &pb.Pragma{Name: name942, Terms: terms946} - result948 := _t1715 - p.recordSpan(int(span_start947), "Pragma") - return result948 + _t1717 := &pb.Pragma{Name: name943, Terms: terms947} + result949 := _t1717 + p.recordSpan(int(span_start948), "Pragma") + return result949 } func (p *Parser) parse_primitive() *pb.Primitive { - span_start964 := int64(p.spanStart()) - var _t1716 int64 + span_start965 := int64(p.spanStart()) + var _t1718 int64 if p.matchLookaheadLiteral("(", 0) { - var _t1717 int64 + var _t1719 int64 if p.matchLookaheadLiteral("primitive", 1) { - _t1717 = 9 + _t1719 = 9 } else { - var _t1718 int64 + var _t1720 int64 if p.matchLookaheadLiteral(">=", 1) { - _t1718 = 4 + _t1720 = 4 } else { - var _t1719 int64 + var _t1721 int64 if p.matchLookaheadLiteral(">", 1) { - _t1719 = 3 + _t1721 = 3 } else { - var _t1720 int64 + var _t1722 int64 if p.matchLookaheadLiteral("=", 1) { - _t1720 = 0 + _t1722 = 0 } else { - var _t1721 int64 + var _t1723 int64 if p.matchLookaheadLiteral("<=", 1) { - _t1721 = 2 + _t1723 = 2 } else { - var _t1722 int64 + var _t1724 int64 if p.matchLookaheadLiteral("<", 1) { - _t1722 = 1 + _t1724 = 1 } else { - var _t1723 int64 + var _t1725 int64 if p.matchLookaheadLiteral("/", 1) { - _t1723 = 8 + _t1725 = 8 } else { - var _t1724 int64 + var _t1726 int64 if p.matchLookaheadLiteral("-", 1) { - _t1724 = 6 + _t1726 = 6 } else { - var _t1725 int64 + var _t1727 int64 if p.matchLookaheadLiteral("+", 1) { - _t1725 = 5 + _t1727 = 5 } else { - var _t1726 int64 + var _t1728 int64 if p.matchLookaheadLiteral("*", 1) { - _t1726 = 7 + _t1728 = 7 } else { - _t1726 = -1 + _t1728 = -1 } - _t1725 = _t1726 + _t1727 = _t1728 } - _t1724 = _t1725 + _t1726 = _t1727 } - _t1723 = _t1724 + _t1725 = _t1726 } - _t1722 = _t1723 + _t1724 = _t1725 } - _t1721 = _t1722 + _t1723 = _t1724 } - _t1720 = _t1721 + _t1722 = _t1723 } - _t1719 = _t1720 + _t1721 = _t1722 } - _t1718 = _t1719 + _t1720 = _t1721 } - _t1717 = _t1718 + _t1719 = _t1720 } - _t1716 = _t1717 + _t1718 = _t1719 } else { - _t1716 = -1 + _t1718 = -1 } - prediction949 := _t1716 - var _t1727 *pb.Primitive - if prediction949 == 9 { + prediction950 := _t1718 + var _t1729 *pb.Primitive + if prediction950 == 9 { p.consumeLiteral("(") p.consumeLiteral("primitive") - _t1728 := p.parse_name() - name959 := _t1728 - xs960 := []*pb.RelTerm{} - cond961 := ((((((((((((((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 cond961 { - _t1729 := p.parse_rel_term() - item962 := _t1729 - xs960 = append(xs960, item962) - cond961 = ((((((((((((((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)) + _t1730 := p.parse_name() + name960 := _t1730 + xs961 := []*pb.RelTerm{} + cond962 := ((((((((((((((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 cond962 { + _t1731 := p.parse_rel_term() + item963 := _t1731 + xs961 = append(xs961, item963) + cond962 = ((((((((((((((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_terms963 := xs960 + rel_terms964 := xs961 p.consumeLiteral(")") - _t1730 := &pb.Primitive{Name: name959, Terms: rel_terms963} - _t1727 = _t1730 + _t1732 := &pb.Primitive{Name: name960, Terms: rel_terms964} + _t1729 = _t1732 } else { - var _t1731 *pb.Primitive - if prediction949 == 8 { - _t1732 := p.parse_divide() - divide958 := _t1732 - _t1731 = divide958 + var _t1733 *pb.Primitive + if prediction950 == 8 { + _t1734 := p.parse_divide() + divide959 := _t1734 + _t1733 = divide959 } else { - var _t1733 *pb.Primitive - if prediction949 == 7 { - _t1734 := p.parse_multiply() - multiply957 := _t1734 - _t1733 = multiply957 + var _t1735 *pb.Primitive + if prediction950 == 7 { + _t1736 := p.parse_multiply() + multiply958 := _t1736 + _t1735 = multiply958 } else { - var _t1735 *pb.Primitive - if prediction949 == 6 { - _t1736 := p.parse_minus() - minus956 := _t1736 - _t1735 = minus956 + var _t1737 *pb.Primitive + if prediction950 == 6 { + _t1738 := p.parse_minus() + minus957 := _t1738 + _t1737 = minus957 } else { - var _t1737 *pb.Primitive - if prediction949 == 5 { - _t1738 := p.parse_add() - add955 := _t1738 - _t1737 = add955 + var _t1739 *pb.Primitive + if prediction950 == 5 { + _t1740 := p.parse_add() + add956 := _t1740 + _t1739 = add956 } else { - var _t1739 *pb.Primitive - if prediction949 == 4 { - _t1740 := p.parse_gt_eq() - gt_eq954 := _t1740 - _t1739 = gt_eq954 + var _t1741 *pb.Primitive + if prediction950 == 4 { + _t1742 := p.parse_gt_eq() + gt_eq955 := _t1742 + _t1741 = gt_eq955 } else { - var _t1741 *pb.Primitive - if prediction949 == 3 { - _t1742 := p.parse_gt() - gt953 := _t1742 - _t1741 = gt953 + var _t1743 *pb.Primitive + if prediction950 == 3 { + _t1744 := p.parse_gt() + gt954 := _t1744 + _t1743 = gt954 } else { - var _t1743 *pb.Primitive - if prediction949 == 2 { - _t1744 := p.parse_lt_eq() - lt_eq952 := _t1744 - _t1743 = lt_eq952 + var _t1745 *pb.Primitive + if prediction950 == 2 { + _t1746 := p.parse_lt_eq() + lt_eq953 := _t1746 + _t1745 = lt_eq953 } else { - var _t1745 *pb.Primitive - if prediction949 == 1 { - _t1746 := p.parse_lt() - lt951 := _t1746 - _t1745 = lt951 + var _t1747 *pb.Primitive + if prediction950 == 1 { + _t1748 := p.parse_lt() + lt952 := _t1748 + _t1747 = lt952 } else { - var _t1747 *pb.Primitive - if prediction949 == 0 { - _t1748 := p.parse_eq() - eq950 := _t1748 - _t1747 = eq950 + var _t1749 *pb.Primitive + if prediction950 == 0 { + _t1750 := p.parse_eq() + eq951 := _t1750 + _t1749 = eq951 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in primitive", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1745 = _t1747 + _t1747 = _t1749 } - _t1743 = _t1745 + _t1745 = _t1747 } - _t1741 = _t1743 + _t1743 = _t1745 } - _t1739 = _t1741 + _t1741 = _t1743 } - _t1737 = _t1739 + _t1739 = _t1741 } - _t1735 = _t1737 + _t1737 = _t1739 } - _t1733 = _t1735 + _t1735 = _t1737 } - _t1731 = _t1733 + _t1733 = _t1735 } - _t1727 = _t1731 + _t1729 = _t1733 } - result965 := _t1727 - p.recordSpan(int(span_start964), "Primitive") - return result965 + result966 := _t1729 + p.recordSpan(int(span_start965), "Primitive") + return result966 } func (p *Parser) parse_eq() *pb.Primitive { - span_start968 := int64(p.spanStart()) + span_start969 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("=") - _t1749 := p.parse_term() - term966 := _t1749 - _t1750 := p.parse_term() - term_3967 := _t1750 + _t1751 := p.parse_term() + term967 := _t1751 + _t1752 := p.parse_term() + term_3968 := _t1752 p.consumeLiteral(")") - _t1751 := &pb.RelTerm{} - _t1751.RelTermType = &pb.RelTerm_Term{Term: term966} - _t1752 := &pb.RelTerm{} - _t1752.RelTermType = &pb.RelTerm_Term{Term: term_3967} - _t1753 := &pb.Primitive{Name: "rel_primitive_eq", Terms: []*pb.RelTerm{_t1751, _t1752}} - result969 := _t1753 - p.recordSpan(int(span_start968), "Primitive") - return result969 + _t1753 := &pb.RelTerm{} + _t1753.RelTermType = &pb.RelTerm_Term{Term: term967} + _t1754 := &pb.RelTerm{} + _t1754.RelTermType = &pb.RelTerm_Term{Term: term_3968} + _t1755 := &pb.Primitive{Name: "rel_primitive_eq", Terms: []*pb.RelTerm{_t1753, _t1754}} + result970 := _t1755 + p.recordSpan(int(span_start969), "Primitive") + return result970 } func (p *Parser) parse_lt() *pb.Primitive { - span_start972 := int64(p.spanStart()) + span_start973 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("<") - _t1754 := p.parse_term() - term970 := _t1754 - _t1755 := p.parse_term() - term_3971 := _t1755 + _t1756 := p.parse_term() + term971 := _t1756 + _t1757 := p.parse_term() + term_3972 := _t1757 p.consumeLiteral(")") - _t1756 := &pb.RelTerm{} - _t1756.RelTermType = &pb.RelTerm_Term{Term: term970} - _t1757 := &pb.RelTerm{} - _t1757.RelTermType = &pb.RelTerm_Term{Term: term_3971} - _t1758 := &pb.Primitive{Name: "rel_primitive_lt_monotype", Terms: []*pb.RelTerm{_t1756, _t1757}} - result973 := _t1758 - p.recordSpan(int(span_start972), "Primitive") - return result973 + _t1758 := &pb.RelTerm{} + _t1758.RelTermType = &pb.RelTerm_Term{Term: term971} + _t1759 := &pb.RelTerm{} + _t1759.RelTermType = &pb.RelTerm_Term{Term: term_3972} + _t1760 := &pb.Primitive{Name: "rel_primitive_lt_monotype", Terms: []*pb.RelTerm{_t1758, _t1759}} + result974 := _t1760 + p.recordSpan(int(span_start973), "Primitive") + return result974 } func (p *Parser) parse_lt_eq() *pb.Primitive { - span_start976 := int64(p.spanStart()) + span_start977 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("<=") - _t1759 := p.parse_term() - term974 := _t1759 - _t1760 := p.parse_term() - term_3975 := _t1760 + _t1761 := p.parse_term() + term975 := _t1761 + _t1762 := p.parse_term() + term_3976 := _t1762 p.consumeLiteral(")") - _t1761 := &pb.RelTerm{} - _t1761.RelTermType = &pb.RelTerm_Term{Term: term974} - _t1762 := &pb.RelTerm{} - _t1762.RelTermType = &pb.RelTerm_Term{Term: term_3975} - _t1763 := &pb.Primitive{Name: "rel_primitive_lt_eq_monotype", Terms: []*pb.RelTerm{_t1761, _t1762}} - result977 := _t1763 - p.recordSpan(int(span_start976), "Primitive") - return result977 + _t1763 := &pb.RelTerm{} + _t1763.RelTermType = &pb.RelTerm_Term{Term: term975} + _t1764 := &pb.RelTerm{} + _t1764.RelTermType = &pb.RelTerm_Term{Term: term_3976} + _t1765 := &pb.Primitive{Name: "rel_primitive_lt_eq_monotype", Terms: []*pb.RelTerm{_t1763, _t1764}} + result978 := _t1765 + p.recordSpan(int(span_start977), "Primitive") + return result978 } func (p *Parser) parse_gt() *pb.Primitive { - span_start980 := int64(p.spanStart()) + span_start981 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral(">") - _t1764 := p.parse_term() - term978 := _t1764 - _t1765 := p.parse_term() - term_3979 := _t1765 + _t1766 := p.parse_term() + term979 := _t1766 + _t1767 := p.parse_term() + term_3980 := _t1767 p.consumeLiteral(")") - _t1766 := &pb.RelTerm{} - _t1766.RelTermType = &pb.RelTerm_Term{Term: term978} - _t1767 := &pb.RelTerm{} - _t1767.RelTermType = &pb.RelTerm_Term{Term: term_3979} - _t1768 := &pb.Primitive{Name: "rel_primitive_gt_monotype", Terms: []*pb.RelTerm{_t1766, _t1767}} - result981 := _t1768 - p.recordSpan(int(span_start980), "Primitive") - return result981 + _t1768 := &pb.RelTerm{} + _t1768.RelTermType = &pb.RelTerm_Term{Term: term979} + _t1769 := &pb.RelTerm{} + _t1769.RelTermType = &pb.RelTerm_Term{Term: term_3980} + _t1770 := &pb.Primitive{Name: "rel_primitive_gt_monotype", Terms: []*pb.RelTerm{_t1768, _t1769}} + result982 := _t1770 + p.recordSpan(int(span_start981), "Primitive") + return result982 } func (p *Parser) parse_gt_eq() *pb.Primitive { - span_start984 := int64(p.spanStart()) + span_start985 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral(">=") - _t1769 := p.parse_term() - term982 := _t1769 - _t1770 := p.parse_term() - term_3983 := _t1770 + _t1771 := p.parse_term() + term983 := _t1771 + _t1772 := p.parse_term() + term_3984 := _t1772 p.consumeLiteral(")") - _t1771 := &pb.RelTerm{} - _t1771.RelTermType = &pb.RelTerm_Term{Term: term982} - _t1772 := &pb.RelTerm{} - _t1772.RelTermType = &pb.RelTerm_Term{Term: term_3983} - _t1773 := &pb.Primitive{Name: "rel_primitive_gt_eq_monotype", Terms: []*pb.RelTerm{_t1771, _t1772}} - result985 := _t1773 - p.recordSpan(int(span_start984), "Primitive") - return result985 + _t1773 := &pb.RelTerm{} + _t1773.RelTermType = &pb.RelTerm_Term{Term: term983} + _t1774 := &pb.RelTerm{} + _t1774.RelTermType = &pb.RelTerm_Term{Term: term_3984} + _t1775 := &pb.Primitive{Name: "rel_primitive_gt_eq_monotype", Terms: []*pb.RelTerm{_t1773, _t1774}} + result986 := _t1775 + p.recordSpan(int(span_start985), "Primitive") + return result986 } func (p *Parser) parse_add() *pb.Primitive { - span_start989 := int64(p.spanStart()) + span_start990 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("+") - _t1774 := p.parse_term() - term986 := _t1774 - _t1775 := p.parse_term() - term_3987 := _t1775 _t1776 := p.parse_term() - term_4988 := _t1776 + term987 := _t1776 + _t1777 := p.parse_term() + term_3988 := _t1777 + _t1778 := p.parse_term() + term_4989 := _t1778 p.consumeLiteral(")") - _t1777 := &pb.RelTerm{} - _t1777.RelTermType = &pb.RelTerm_Term{Term: term986} - _t1778 := &pb.RelTerm{} - _t1778.RelTermType = &pb.RelTerm_Term{Term: term_3987} _t1779 := &pb.RelTerm{} - _t1779.RelTermType = &pb.RelTerm_Term{Term: term_4988} - _t1780 := &pb.Primitive{Name: "rel_primitive_add_monotype", Terms: []*pb.RelTerm{_t1777, _t1778, _t1779}} - result990 := _t1780 - p.recordSpan(int(span_start989), "Primitive") - return result990 + _t1779.RelTermType = &pb.RelTerm_Term{Term: term987} + _t1780 := &pb.RelTerm{} + _t1780.RelTermType = &pb.RelTerm_Term{Term: term_3988} + _t1781 := &pb.RelTerm{} + _t1781.RelTermType = &pb.RelTerm_Term{Term: term_4989} + _t1782 := &pb.Primitive{Name: "rel_primitive_add_monotype", Terms: []*pb.RelTerm{_t1779, _t1780, _t1781}} + result991 := _t1782 + p.recordSpan(int(span_start990), "Primitive") + return result991 } func (p *Parser) parse_minus() *pb.Primitive { - span_start994 := int64(p.spanStart()) + span_start995 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("-") - _t1781 := p.parse_term() - term991 := _t1781 - _t1782 := p.parse_term() - term_3992 := _t1782 _t1783 := p.parse_term() - term_4993 := _t1783 + term992 := _t1783 + _t1784 := p.parse_term() + term_3993 := _t1784 + _t1785 := p.parse_term() + term_4994 := _t1785 p.consumeLiteral(")") - _t1784 := &pb.RelTerm{} - _t1784.RelTermType = &pb.RelTerm_Term{Term: term991} - _t1785 := &pb.RelTerm{} - _t1785.RelTermType = &pb.RelTerm_Term{Term: term_3992} _t1786 := &pb.RelTerm{} - _t1786.RelTermType = &pb.RelTerm_Term{Term: term_4993} - _t1787 := &pb.Primitive{Name: "rel_primitive_subtract_monotype", Terms: []*pb.RelTerm{_t1784, _t1785, _t1786}} - result995 := _t1787 - p.recordSpan(int(span_start994), "Primitive") - return result995 + _t1786.RelTermType = &pb.RelTerm_Term{Term: term992} + _t1787 := &pb.RelTerm{} + _t1787.RelTermType = &pb.RelTerm_Term{Term: term_3993} + _t1788 := &pb.RelTerm{} + _t1788.RelTermType = &pb.RelTerm_Term{Term: term_4994} + _t1789 := &pb.Primitive{Name: "rel_primitive_subtract_monotype", Terms: []*pb.RelTerm{_t1786, _t1787, _t1788}} + result996 := _t1789 + p.recordSpan(int(span_start995), "Primitive") + return result996 } func (p *Parser) parse_multiply() *pb.Primitive { - span_start999 := int64(p.spanStart()) + span_start1000 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("*") - _t1788 := p.parse_term() - term996 := _t1788 - _t1789 := p.parse_term() - term_3997 := _t1789 _t1790 := p.parse_term() - term_4998 := _t1790 + term997 := _t1790 + _t1791 := p.parse_term() + term_3998 := _t1791 + _t1792 := p.parse_term() + term_4999 := _t1792 p.consumeLiteral(")") - _t1791 := &pb.RelTerm{} - _t1791.RelTermType = &pb.RelTerm_Term{Term: term996} - _t1792 := &pb.RelTerm{} - _t1792.RelTermType = &pb.RelTerm_Term{Term: term_3997} _t1793 := &pb.RelTerm{} - _t1793.RelTermType = &pb.RelTerm_Term{Term: term_4998} - _t1794 := &pb.Primitive{Name: "rel_primitive_multiply_monotype", Terms: []*pb.RelTerm{_t1791, _t1792, _t1793}} - result1000 := _t1794 - p.recordSpan(int(span_start999), "Primitive") - return result1000 + _t1793.RelTermType = &pb.RelTerm_Term{Term: term997} + _t1794 := &pb.RelTerm{} + _t1794.RelTermType = &pb.RelTerm_Term{Term: term_3998} + _t1795 := &pb.RelTerm{} + _t1795.RelTermType = &pb.RelTerm_Term{Term: term_4999} + _t1796 := &pb.Primitive{Name: "rel_primitive_multiply_monotype", Terms: []*pb.RelTerm{_t1793, _t1794, _t1795}} + result1001 := _t1796 + p.recordSpan(int(span_start1000), "Primitive") + return result1001 } func (p *Parser) parse_divide() *pb.Primitive { - span_start1004 := int64(p.spanStart()) + span_start1005 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("/") - _t1795 := p.parse_term() - term1001 := _t1795 - _t1796 := p.parse_term() - term_31002 := _t1796 _t1797 := p.parse_term() - term_41003 := _t1797 + term1002 := _t1797 + _t1798 := p.parse_term() + term_31003 := _t1798 + _t1799 := p.parse_term() + term_41004 := _t1799 p.consumeLiteral(")") - _t1798 := &pb.RelTerm{} - _t1798.RelTermType = &pb.RelTerm_Term{Term: term1001} - _t1799 := &pb.RelTerm{} - _t1799.RelTermType = &pb.RelTerm_Term{Term: term_31002} _t1800 := &pb.RelTerm{} - _t1800.RelTermType = &pb.RelTerm_Term{Term: term_41003} - _t1801 := &pb.Primitive{Name: "rel_primitive_divide_monotype", Terms: []*pb.RelTerm{_t1798, _t1799, _t1800}} - result1005 := _t1801 - p.recordSpan(int(span_start1004), "Primitive") - return result1005 + _t1800.RelTermType = &pb.RelTerm_Term{Term: term1002} + _t1801 := &pb.RelTerm{} + _t1801.RelTermType = &pb.RelTerm_Term{Term: term_31003} + _t1802 := &pb.RelTerm{} + _t1802.RelTermType = &pb.RelTerm_Term{Term: term_41004} + _t1803 := &pb.Primitive{Name: "rel_primitive_divide_monotype", Terms: []*pb.RelTerm{_t1800, _t1801, _t1802}} + result1006 := _t1803 + p.recordSpan(int(span_start1005), "Primitive") + return result1006 } func (p *Parser) parse_rel_term() *pb.RelTerm { - span_start1009 := int64(p.spanStart()) - var _t1802 int64 + span_start1010 := int64(p.spanStart()) + var _t1804 int64 if p.matchLookaheadLiteral("true", 0) { - _t1802 = 1 + _t1804 = 1 } else { - var _t1803 int64 + var _t1805 int64 if p.matchLookaheadLiteral("missing", 0) { - _t1803 = 1 + _t1805 = 1 } else { - var _t1804 int64 + var _t1806 int64 if p.matchLookaheadLiteral("false", 0) { - _t1804 = 1 + _t1806 = 1 } else { - var _t1805 int64 + var _t1807 int64 if p.matchLookaheadLiteral("(", 0) { - _t1805 = 1 + _t1807 = 1 } else { - var _t1806 int64 + var _t1808 int64 if p.matchLookaheadLiteral("#", 0) { - _t1806 = 0 + _t1808 = 0 } else { - var _t1807 int64 + var _t1809 int64 if p.matchLookaheadTerminal("SYMBOL", 0) { - _t1807 = 1 + _t1809 = 1 } else { - var _t1808 int64 + var _t1810 int64 if p.matchLookaheadTerminal("UINT32", 0) { - _t1808 = 1 + _t1810 = 1 } else { - var _t1809 int64 + var _t1811 int64 if p.matchLookaheadTerminal("UINT128", 0) { - _t1809 = 1 + _t1811 = 1 } else { - var _t1810 int64 + var _t1812 int64 if p.matchLookaheadTerminal("STRING", 0) { - _t1810 = 1 + _t1812 = 1 } else { - var _t1811 int64 + var _t1813 int64 if p.matchLookaheadTerminal("INT32", 0) { - _t1811 = 1 + _t1813 = 1 } else { - var _t1812 int64 + var _t1814 int64 if p.matchLookaheadTerminal("INT128", 0) { - _t1812 = 1 + _t1814 = 1 } else { - var _t1813 int64 + var _t1815 int64 if p.matchLookaheadTerminal("INT", 0) { - _t1813 = 1 + _t1815 = 1 } else { - var _t1814 int64 + var _t1816 int64 if p.matchLookaheadTerminal("FLOAT32", 0) { - _t1814 = 1 + _t1816 = 1 } else { - var _t1815 int64 + var _t1817 int64 if p.matchLookaheadTerminal("FLOAT", 0) { - _t1815 = 1 + _t1817 = 1 } else { - var _t1816 int64 + var _t1818 int64 if p.matchLookaheadTerminal("DECIMAL", 0) { - _t1816 = 1 + _t1818 = 1 } else { - _t1816 = -1 + _t1818 = -1 } - _t1815 = _t1816 + _t1817 = _t1818 } - _t1814 = _t1815 + _t1816 = _t1817 } - _t1813 = _t1814 + _t1815 = _t1816 } - _t1812 = _t1813 + _t1814 = _t1815 } - _t1811 = _t1812 + _t1813 = _t1814 } - _t1810 = _t1811 + _t1812 = _t1813 } - _t1809 = _t1810 + _t1811 = _t1812 } - _t1808 = _t1809 + _t1810 = _t1811 } - _t1807 = _t1808 + _t1809 = _t1810 } - _t1806 = _t1807 + _t1808 = _t1809 } - _t1805 = _t1806 + _t1807 = _t1808 } - _t1804 = _t1805 + _t1806 = _t1807 } - _t1803 = _t1804 + _t1805 = _t1806 } - _t1802 = _t1803 - } - prediction1006 := _t1802 - var _t1817 *pb.RelTerm - if prediction1006 == 1 { - _t1818 := p.parse_term() - term1008 := _t1818 - _t1819 := &pb.RelTerm{} - _t1819.RelTermType = &pb.RelTerm_Term{Term: term1008} - _t1817 = _t1819 + _t1804 = _t1805 + } + prediction1007 := _t1804 + var _t1819 *pb.RelTerm + if prediction1007 == 1 { + _t1820 := p.parse_term() + term1009 := _t1820 + _t1821 := &pb.RelTerm{} + _t1821.RelTermType = &pb.RelTerm_Term{Term: term1009} + _t1819 = _t1821 } else { - var _t1820 *pb.RelTerm - if prediction1006 == 0 { - _t1821 := p.parse_specialized_value() - specialized_value1007 := _t1821 - _t1822 := &pb.RelTerm{} - _t1822.RelTermType = &pb.RelTerm_SpecializedValue{SpecializedValue: specialized_value1007} - _t1820 = _t1822 + var _t1822 *pb.RelTerm + if prediction1007 == 0 { + _t1823 := p.parse_specialized_value() + specialized_value1008 := _t1823 + _t1824 := &pb.RelTerm{} + _t1824.RelTermType = &pb.RelTerm_SpecializedValue{SpecializedValue: specialized_value1008} + _t1822 = _t1824 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in rel_term", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1817 = _t1820 + _t1819 = _t1822 } - result1010 := _t1817 - p.recordSpan(int(span_start1009), "RelTerm") - return result1010 + result1011 := _t1819 + p.recordSpan(int(span_start1010), "RelTerm") + return result1011 } func (p *Parser) parse_specialized_value() *pb.Value { - span_start1012 := int64(p.spanStart()) + span_start1013 := int64(p.spanStart()) p.consumeLiteral("#") - _t1823 := p.parse_raw_value() - raw_value1011 := _t1823 - result1013 := raw_value1011 - p.recordSpan(int(span_start1012), "Value") - return result1013 + _t1825 := p.parse_raw_value() + raw_value1012 := _t1825 + result1014 := raw_value1012 + p.recordSpan(int(span_start1013), "Value") + return result1014 } func (p *Parser) parse_rel_atom() *pb.RelAtom { - span_start1019 := int64(p.spanStart()) + span_start1020 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("relatom") - _t1824 := p.parse_name() - name1014 := _t1824 - xs1015 := []*pb.RelTerm{} - cond1016 := ((((((((((((((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 cond1016 { - _t1825 := p.parse_rel_term() - item1017 := _t1825 - xs1015 = append(xs1015, item1017) - cond1016 = ((((((((((((((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_terms1018 := xs1015 + _t1826 := p.parse_name() + name1015 := _t1826 + xs1016 := []*pb.RelTerm{} + cond1017 := ((((((((((((((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 cond1017 { + _t1827 := p.parse_rel_term() + item1018 := _t1827 + xs1016 = append(xs1016, item1018) + cond1017 = ((((((((((((((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_terms1019 := xs1016 p.consumeLiteral(")") - _t1826 := &pb.RelAtom{Name: name1014, Terms: rel_terms1018} - result1020 := _t1826 - p.recordSpan(int(span_start1019), "RelAtom") - return result1020 + _t1828 := &pb.RelAtom{Name: name1015, Terms: rel_terms1019} + result1021 := _t1828 + p.recordSpan(int(span_start1020), "RelAtom") + return result1021 } func (p *Parser) parse_cast() *pb.Cast { - span_start1023 := int64(p.spanStart()) + span_start1024 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("cast") - _t1827 := p.parse_term() - term1021 := _t1827 - _t1828 := p.parse_term() - term_31022 := _t1828 + _t1829 := p.parse_term() + term1022 := _t1829 + _t1830 := p.parse_term() + term_31023 := _t1830 p.consumeLiteral(")") - _t1829 := &pb.Cast{Input: term1021, Result: term_31022} - result1024 := _t1829 - p.recordSpan(int(span_start1023), "Cast") - return result1024 + _t1831 := &pb.Cast{Input: term1022, Result: term_31023} + result1025 := _t1831 + p.recordSpan(int(span_start1024), "Cast") + return result1025 } func (p *Parser) parse_attrs() []*pb.Attribute { p.consumeLiteral("(") p.consumeLiteral("attrs") - xs1025 := []*pb.Attribute{} - cond1026 := p.matchLookaheadLiteral("(", 0) - for cond1026 { - _t1830 := p.parse_attribute() - item1027 := _t1830 - xs1025 = append(xs1025, item1027) - cond1026 = p.matchLookaheadLiteral("(", 0) - } - attributes1028 := xs1025 + xs1026 := []*pb.Attribute{} + cond1027 := p.matchLookaheadLiteral("(", 0) + for cond1027 { + _t1832 := p.parse_attribute() + item1028 := _t1832 + xs1026 = append(xs1026, item1028) + cond1027 = p.matchLookaheadLiteral("(", 0) + } + attributes1029 := xs1026 p.consumeLiteral(")") - return attributes1028 + return attributes1029 } func (p *Parser) parse_attribute() *pb.Attribute { - span_start1034 := int64(p.spanStart()) + span_start1035 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("attribute") - _t1831 := p.parse_name() - name1029 := _t1831 - xs1030 := []*pb.Value{} - cond1031 := ((((((((((((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 cond1031 { - _t1832 := p.parse_raw_value() - item1032 := _t1832 - xs1030 = append(xs1030, item1032) - cond1031 = ((((((((((((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_values1033 := xs1030 + _t1833 := p.parse_name() + name1030 := _t1833 + xs1031 := []*pb.Value{} + cond1032 := ((((((((((((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 cond1032 { + _t1834 := p.parse_raw_value() + item1033 := _t1834 + xs1031 = append(xs1031, item1033) + cond1032 = ((((((((((((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_values1034 := xs1031 p.consumeLiteral(")") - _t1833 := &pb.Attribute{Name: name1029, Args: raw_values1033} - result1035 := _t1833 - p.recordSpan(int(span_start1034), "Attribute") - return result1035 + _t1835 := &pb.Attribute{Name: name1030, Args: raw_values1034} + result1036 := _t1835 + p.recordSpan(int(span_start1035), "Attribute") + return result1036 } func (p *Parser) parse_algorithm() *pb.Algorithm { - span_start1042 := int64(p.spanStart()) + span_start1043 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("algorithm") - xs1036 := []*pb.RelationId{} - cond1037 := (p.matchLookaheadLiteral(":", 0) || p.matchLookaheadTerminal("UINT128", 0)) - for cond1037 { - _t1834 := p.parse_relation_id() - item1038 := _t1834 - xs1036 = append(xs1036, item1038) - cond1037 = (p.matchLookaheadLiteral(":", 0) || p.matchLookaheadTerminal("UINT128", 0)) - } - relation_ids1039 := xs1036 - _t1835 := p.parse_script() - script1040 := _t1835 - var _t1836 []*pb.Attribute + xs1037 := []*pb.RelationId{} + cond1038 := (p.matchLookaheadLiteral(":", 0) || p.matchLookaheadTerminal("UINT128", 0)) + for cond1038 { + _t1836 := p.parse_relation_id() + item1039 := _t1836 + xs1037 = append(xs1037, item1039) + cond1038 = (p.matchLookaheadLiteral(":", 0) || p.matchLookaheadTerminal("UINT128", 0)) + } + relation_ids1040 := xs1037 + _t1837 := p.parse_script() + script1041 := _t1837 + var _t1838 []*pb.Attribute if p.matchLookaheadLiteral("(", 0) { - _t1837 := p.parse_attrs() - _t1836 = _t1837 + _t1839 := p.parse_attrs() + _t1838 = _t1839 } - attrs1041 := _t1836 + attrs1042 := _t1838 p.consumeLiteral(")") - _t1838 := attrs1041 - if attrs1041 == nil { - _t1838 = []*pb.Attribute{} + _t1840 := attrs1042 + if attrs1042 == nil { + _t1840 = []*pb.Attribute{} } - _t1839 := &pb.Algorithm{Global: relation_ids1039, Body: script1040, Attrs: _t1838} - result1043 := _t1839 - p.recordSpan(int(span_start1042), "Algorithm") - return result1043 + _t1841 := &pb.Algorithm{Global: relation_ids1040, Body: script1041, Attrs: _t1840} + result1044 := _t1841 + p.recordSpan(int(span_start1043), "Algorithm") + return result1044 } func (p *Parser) parse_script() *pb.Script { - span_start1048 := int64(p.spanStart()) + span_start1049 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("script") - xs1044 := []*pb.Construct{} - cond1045 := p.matchLookaheadLiteral("(", 0) - for cond1045 { - _t1840 := p.parse_construct() - item1046 := _t1840 - xs1044 = append(xs1044, item1046) - cond1045 = p.matchLookaheadLiteral("(", 0) - } - constructs1047 := xs1044 + xs1045 := []*pb.Construct{} + cond1046 := p.matchLookaheadLiteral("(", 0) + for cond1046 { + _t1842 := p.parse_construct() + item1047 := _t1842 + xs1045 = append(xs1045, item1047) + cond1046 = p.matchLookaheadLiteral("(", 0) + } + constructs1048 := xs1045 p.consumeLiteral(")") - _t1841 := &pb.Script{Constructs: constructs1047} - result1049 := _t1841 - p.recordSpan(int(span_start1048), "Script") - return result1049 + _t1843 := &pb.Script{Constructs: constructs1048} + result1050 := _t1843 + p.recordSpan(int(span_start1049), "Script") + return result1050 } func (p *Parser) parse_construct() *pb.Construct { - span_start1053 := int64(p.spanStart()) - var _t1842 int64 + span_start1054 := int64(p.spanStart()) + var _t1844 int64 if p.matchLookaheadLiteral("(", 0) { - var _t1843 int64 + var _t1845 int64 if p.matchLookaheadLiteral("upsert", 1) { - _t1843 = 1 + _t1845 = 1 } else { - var _t1844 int64 + var _t1846 int64 if p.matchLookaheadLiteral("monus", 1) { - _t1844 = 1 + _t1846 = 1 } else { - var _t1845 int64 + var _t1847 int64 if p.matchLookaheadLiteral("monoid", 1) { - _t1845 = 1 + _t1847 = 1 } else { - var _t1846 int64 + var _t1848 int64 if p.matchLookaheadLiteral("loop", 1) { - _t1846 = 0 + _t1848 = 0 } else { - var _t1847 int64 + var _t1849 int64 if p.matchLookaheadLiteral("break", 1) { - _t1847 = 1 + _t1849 = 1 } else { - var _t1848 int64 + var _t1850 int64 if p.matchLookaheadLiteral("assign", 1) { - _t1848 = 1 + _t1850 = 1 } else { - _t1848 = -1 + _t1850 = -1 } - _t1847 = _t1848 + _t1849 = _t1850 } - _t1846 = _t1847 + _t1848 = _t1849 } - _t1845 = _t1846 + _t1847 = _t1848 } - _t1844 = _t1845 + _t1846 = _t1847 } - _t1843 = _t1844 + _t1845 = _t1846 } - _t1842 = _t1843 + _t1844 = _t1845 } else { - _t1842 = -1 - } - prediction1050 := _t1842 - var _t1849 *pb.Construct - if prediction1050 == 1 { - _t1850 := p.parse_instruction() - instruction1052 := _t1850 - _t1851 := &pb.Construct{} - _t1851.ConstructType = &pb.Construct_Instruction{Instruction: instruction1052} - _t1849 = _t1851 + _t1844 = -1 + } + prediction1051 := _t1844 + var _t1851 *pb.Construct + if prediction1051 == 1 { + _t1852 := p.parse_instruction() + instruction1053 := _t1852 + _t1853 := &pb.Construct{} + _t1853.ConstructType = &pb.Construct_Instruction{Instruction: instruction1053} + _t1851 = _t1853 } else { - var _t1852 *pb.Construct - if prediction1050 == 0 { - _t1853 := p.parse_loop() - loop1051 := _t1853 - _t1854 := &pb.Construct{} - _t1854.ConstructType = &pb.Construct_Loop{Loop: loop1051} - _t1852 = _t1854 + var _t1854 *pb.Construct + if prediction1051 == 0 { + _t1855 := p.parse_loop() + loop1052 := _t1855 + _t1856 := &pb.Construct{} + _t1856.ConstructType = &pb.Construct_Loop{Loop: loop1052} + _t1854 = _t1856 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in construct", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1849 = _t1852 + _t1851 = _t1854 } - result1054 := _t1849 - p.recordSpan(int(span_start1053), "Construct") - return result1054 + result1055 := _t1851 + p.recordSpan(int(span_start1054), "Construct") + return result1055 } func (p *Parser) parse_loop() *pb.Loop { - span_start1058 := int64(p.spanStart()) + span_start1059 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("loop") - _t1855 := p.parse_init() - init1055 := _t1855 - _t1856 := p.parse_script() - script1056 := _t1856 - var _t1857 []*pb.Attribute + _t1857 := p.parse_init() + init1056 := _t1857 + _t1858 := p.parse_script() + script1057 := _t1858 + var _t1859 []*pb.Attribute if p.matchLookaheadLiteral("(", 0) { - _t1858 := p.parse_attrs() - _t1857 = _t1858 + _t1860 := p.parse_attrs() + _t1859 = _t1860 } - attrs1057 := _t1857 + attrs1058 := _t1859 p.consumeLiteral(")") - _t1859 := attrs1057 - if attrs1057 == nil { - _t1859 = []*pb.Attribute{} + _t1861 := attrs1058 + if attrs1058 == nil { + _t1861 = []*pb.Attribute{} } - _t1860 := &pb.Loop{Init: init1055, Body: script1056, Attrs: _t1859} - result1059 := _t1860 - p.recordSpan(int(span_start1058), "Loop") - return result1059 + _t1862 := &pb.Loop{Init: init1056, Body: script1057, Attrs: _t1861} + result1060 := _t1862 + p.recordSpan(int(span_start1059), "Loop") + return result1060 } func (p *Parser) parse_init() []*pb.Instruction { p.consumeLiteral("(") p.consumeLiteral("init") - xs1060 := []*pb.Instruction{} - cond1061 := p.matchLookaheadLiteral("(", 0) - for cond1061 { - _t1861 := p.parse_instruction() - item1062 := _t1861 - xs1060 = append(xs1060, item1062) - cond1061 = p.matchLookaheadLiteral("(", 0) - } - instructions1063 := xs1060 + xs1061 := []*pb.Instruction{} + cond1062 := p.matchLookaheadLiteral("(", 0) + for cond1062 { + _t1863 := p.parse_instruction() + item1063 := _t1863 + xs1061 = append(xs1061, item1063) + cond1062 = p.matchLookaheadLiteral("(", 0) + } + instructions1064 := xs1061 p.consumeLiteral(")") - return instructions1063 + return instructions1064 } func (p *Parser) parse_instruction() *pb.Instruction { - span_start1070 := int64(p.spanStart()) - var _t1862 int64 + span_start1071 := int64(p.spanStart()) + var _t1864 int64 if p.matchLookaheadLiteral("(", 0) { - var _t1863 int64 + var _t1865 int64 if p.matchLookaheadLiteral("upsert", 1) { - _t1863 = 1 + _t1865 = 1 } else { - var _t1864 int64 + var _t1866 int64 if p.matchLookaheadLiteral("monus", 1) { - _t1864 = 4 + _t1866 = 4 } else { - var _t1865 int64 + var _t1867 int64 if p.matchLookaheadLiteral("monoid", 1) { - _t1865 = 3 + _t1867 = 3 } else { - var _t1866 int64 + var _t1868 int64 if p.matchLookaheadLiteral("break", 1) { - _t1866 = 2 + _t1868 = 2 } else { - var _t1867 int64 + var _t1869 int64 if p.matchLookaheadLiteral("assign", 1) { - _t1867 = 0 + _t1869 = 0 } else { - _t1867 = -1 + _t1869 = -1 } - _t1866 = _t1867 + _t1868 = _t1869 } - _t1865 = _t1866 + _t1867 = _t1868 } - _t1864 = _t1865 + _t1866 = _t1867 } - _t1863 = _t1864 + _t1865 = _t1866 } - _t1862 = _t1863 + _t1864 = _t1865 } else { - _t1862 = -1 - } - prediction1064 := _t1862 - var _t1868 *pb.Instruction - if prediction1064 == 4 { - _t1869 := p.parse_monus_def() - monus_def1069 := _t1869 - _t1870 := &pb.Instruction{} - _t1870.InstrType = &pb.Instruction_MonusDef{MonusDef: monus_def1069} - _t1868 = _t1870 + _t1864 = -1 + } + prediction1065 := _t1864 + var _t1870 *pb.Instruction + if prediction1065 == 4 { + _t1871 := p.parse_monus_def() + monus_def1070 := _t1871 + _t1872 := &pb.Instruction{} + _t1872.InstrType = &pb.Instruction_MonusDef{MonusDef: monus_def1070} + _t1870 = _t1872 } else { - var _t1871 *pb.Instruction - if prediction1064 == 3 { - _t1872 := p.parse_monoid_def() - monoid_def1068 := _t1872 - _t1873 := &pb.Instruction{} - _t1873.InstrType = &pb.Instruction_MonoidDef{MonoidDef: monoid_def1068} - _t1871 = _t1873 + var _t1873 *pb.Instruction + if prediction1065 == 3 { + _t1874 := p.parse_monoid_def() + monoid_def1069 := _t1874 + _t1875 := &pb.Instruction{} + _t1875.InstrType = &pb.Instruction_MonoidDef{MonoidDef: monoid_def1069} + _t1873 = _t1875 } else { - var _t1874 *pb.Instruction - if prediction1064 == 2 { - _t1875 := p.parse_break() - break1067 := _t1875 - _t1876 := &pb.Instruction{} - _t1876.InstrType = &pb.Instruction_Break{Break: break1067} - _t1874 = _t1876 + var _t1876 *pb.Instruction + if prediction1065 == 2 { + _t1877 := p.parse_break() + break1068 := _t1877 + _t1878 := &pb.Instruction{} + _t1878.InstrType = &pb.Instruction_Break{Break: break1068} + _t1876 = _t1878 } else { - var _t1877 *pb.Instruction - if prediction1064 == 1 { - _t1878 := p.parse_upsert() - upsert1066 := _t1878 - _t1879 := &pb.Instruction{} - _t1879.InstrType = &pb.Instruction_Upsert{Upsert: upsert1066} - _t1877 = _t1879 + var _t1879 *pb.Instruction + if prediction1065 == 1 { + _t1880 := p.parse_upsert() + upsert1067 := _t1880 + _t1881 := &pb.Instruction{} + _t1881.InstrType = &pb.Instruction_Upsert{Upsert: upsert1067} + _t1879 = _t1881 } else { - var _t1880 *pb.Instruction - if prediction1064 == 0 { - _t1881 := p.parse_assign() - assign1065 := _t1881 - _t1882 := &pb.Instruction{} - _t1882.InstrType = &pb.Instruction_Assign{Assign: assign1065} - _t1880 = _t1882 + var _t1882 *pb.Instruction + if prediction1065 == 0 { + _t1883 := p.parse_assign() + assign1066 := _t1883 + _t1884 := &pb.Instruction{} + _t1884.InstrType = &pb.Instruction_Assign{Assign: assign1066} + _t1882 = _t1884 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in instruction", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1877 = _t1880 + _t1879 = _t1882 } - _t1874 = _t1877 + _t1876 = _t1879 } - _t1871 = _t1874 + _t1873 = _t1876 } - _t1868 = _t1871 + _t1870 = _t1873 } - result1071 := _t1868 - p.recordSpan(int(span_start1070), "Instruction") - return result1071 + result1072 := _t1870 + p.recordSpan(int(span_start1071), "Instruction") + return result1072 } func (p *Parser) parse_assign() *pb.Assign { - span_start1075 := int64(p.spanStart()) + span_start1076 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("assign") - _t1883 := p.parse_relation_id() - relation_id1072 := _t1883 - _t1884 := p.parse_abstraction() - abstraction1073 := _t1884 - var _t1885 []*pb.Attribute + _t1885 := p.parse_relation_id() + relation_id1073 := _t1885 + _t1886 := p.parse_abstraction() + abstraction1074 := _t1886 + var _t1887 []*pb.Attribute if p.matchLookaheadLiteral("(", 0) { - _t1886 := p.parse_attrs() - _t1885 = _t1886 + _t1888 := p.parse_attrs() + _t1887 = _t1888 } - attrs1074 := _t1885 + attrs1075 := _t1887 p.consumeLiteral(")") - _t1887 := attrs1074 - if attrs1074 == nil { - _t1887 = []*pb.Attribute{} + _t1889 := attrs1075 + if attrs1075 == nil { + _t1889 = []*pb.Attribute{} } - _t1888 := &pb.Assign{Name: relation_id1072, Body: abstraction1073, Attrs: _t1887} - result1076 := _t1888 - p.recordSpan(int(span_start1075), "Assign") - return result1076 + _t1890 := &pb.Assign{Name: relation_id1073, Body: abstraction1074, Attrs: _t1889} + result1077 := _t1890 + p.recordSpan(int(span_start1076), "Assign") + return result1077 } func (p *Parser) parse_upsert() *pb.Upsert { - span_start1080 := int64(p.spanStart()) + span_start1081 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("upsert") - _t1889 := p.parse_relation_id() - relation_id1077 := _t1889 - _t1890 := p.parse_abstraction_with_arity() - abstraction_with_arity1078 := _t1890 - var _t1891 []*pb.Attribute + _t1891 := p.parse_relation_id() + relation_id1078 := _t1891 + _t1892 := p.parse_abstraction_with_arity() + abstraction_with_arity1079 := _t1892 + var _t1893 []*pb.Attribute if p.matchLookaheadLiteral("(", 0) { - _t1892 := p.parse_attrs() - _t1891 = _t1892 + _t1894 := p.parse_attrs() + _t1893 = _t1894 } - attrs1079 := _t1891 + attrs1080 := _t1893 p.consumeLiteral(")") - _t1893 := attrs1079 - if attrs1079 == nil { - _t1893 = []*pb.Attribute{} + _t1895 := attrs1080 + if attrs1080 == nil { + _t1895 = []*pb.Attribute{} } - _t1894 := &pb.Upsert{Name: relation_id1077, Body: abstraction_with_arity1078[0].(*pb.Abstraction), Attrs: _t1893, ValueArity: abstraction_with_arity1078[1].(int64)} - result1081 := _t1894 - p.recordSpan(int(span_start1080), "Upsert") - return result1081 + _t1896 := &pb.Upsert{Name: relation_id1078, Body: abstraction_with_arity1079[0].(*pb.Abstraction), Attrs: _t1895, ValueArity: abstraction_with_arity1079[1].(int64)} + result1082 := _t1896 + p.recordSpan(int(span_start1081), "Upsert") + return result1082 } func (p *Parser) parse_abstraction_with_arity() []interface{} { p.consumeLiteral("(") - _t1895 := p.parse_bindings() - bindings1082 := _t1895 - _t1896 := p.parse_formula() - formula1083 := _t1896 + _t1897 := p.parse_bindings() + bindings1083 := _t1897 + _t1898 := p.parse_formula() + formula1084 := _t1898 p.consumeLiteral(")") - _t1897 := &pb.Abstraction{Vars: listConcat(bindings1082[0].([]*pb.Binding), bindings1082[1].([]*pb.Binding)), Value: formula1083} - return []interface{}{_t1897, int64(len(bindings1082[1].([]*pb.Binding)))} + _t1899 := &pb.Abstraction{Vars: listConcat(bindings1083[0].([]*pb.Binding), bindings1083[1].([]*pb.Binding)), Value: formula1084} + return []interface{}{_t1899, int64(len(bindings1083[1].([]*pb.Binding)))} } func (p *Parser) parse_break() *pb.Break { - span_start1087 := int64(p.spanStart()) + span_start1088 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("break") - _t1898 := p.parse_relation_id() - relation_id1084 := _t1898 - _t1899 := p.parse_abstraction() - abstraction1085 := _t1899 - var _t1900 []*pb.Attribute + _t1900 := p.parse_relation_id() + relation_id1085 := _t1900 + _t1901 := p.parse_abstraction() + abstraction1086 := _t1901 + var _t1902 []*pb.Attribute if p.matchLookaheadLiteral("(", 0) { - _t1901 := p.parse_attrs() - _t1900 = _t1901 + _t1903 := p.parse_attrs() + _t1902 = _t1903 } - attrs1086 := _t1900 + attrs1087 := _t1902 p.consumeLiteral(")") - _t1902 := attrs1086 - if attrs1086 == nil { - _t1902 = []*pb.Attribute{} + _t1904 := attrs1087 + if attrs1087 == nil { + _t1904 = []*pb.Attribute{} } - _t1903 := &pb.Break{Name: relation_id1084, Body: abstraction1085, Attrs: _t1902} - result1088 := _t1903 - p.recordSpan(int(span_start1087), "Break") - return result1088 + _t1905 := &pb.Break{Name: relation_id1085, Body: abstraction1086, Attrs: _t1904} + result1089 := _t1905 + p.recordSpan(int(span_start1088), "Break") + return result1089 } func (p *Parser) parse_monoid_def() *pb.MonoidDef { - span_start1093 := int64(p.spanStart()) + span_start1094 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("monoid") - _t1904 := p.parse_monoid() - monoid1089 := _t1904 - _t1905 := p.parse_relation_id() - relation_id1090 := _t1905 - _t1906 := p.parse_abstraction_with_arity() - abstraction_with_arity1091 := _t1906 - var _t1907 []*pb.Attribute + _t1906 := p.parse_monoid() + monoid1090 := _t1906 + _t1907 := p.parse_relation_id() + relation_id1091 := _t1907 + _t1908 := p.parse_abstraction_with_arity() + abstraction_with_arity1092 := _t1908 + var _t1909 []*pb.Attribute if p.matchLookaheadLiteral("(", 0) { - _t1908 := p.parse_attrs() - _t1907 = _t1908 + _t1910 := p.parse_attrs() + _t1909 = _t1910 } - attrs1092 := _t1907 + attrs1093 := _t1909 p.consumeLiteral(")") - _t1909 := attrs1092 - if attrs1092 == nil { - _t1909 = []*pb.Attribute{} + _t1911 := attrs1093 + if attrs1093 == nil { + _t1911 = []*pb.Attribute{} } - _t1910 := &pb.MonoidDef{Monoid: monoid1089, Name: relation_id1090, Body: abstraction_with_arity1091[0].(*pb.Abstraction), Attrs: _t1909, ValueArity: abstraction_with_arity1091[1].(int64)} - result1094 := _t1910 - p.recordSpan(int(span_start1093), "MonoidDef") - return result1094 + _t1912 := &pb.MonoidDef{Monoid: monoid1090, Name: relation_id1091, Body: abstraction_with_arity1092[0].(*pb.Abstraction), Attrs: _t1911, ValueArity: abstraction_with_arity1092[1].(int64)} + result1095 := _t1912 + p.recordSpan(int(span_start1094), "MonoidDef") + return result1095 } func (p *Parser) parse_monoid() *pb.Monoid { - span_start1100 := int64(p.spanStart()) - var _t1911 int64 + span_start1101 := int64(p.spanStart()) + var _t1913 int64 if p.matchLookaheadLiteral("(", 0) { - var _t1912 int64 + var _t1914 int64 if p.matchLookaheadLiteral("sum", 1) { - _t1912 = 3 + _t1914 = 3 } else { - var _t1913 int64 + var _t1915 int64 if p.matchLookaheadLiteral("or", 1) { - _t1913 = 0 + _t1915 = 0 } else { - var _t1914 int64 + var _t1916 int64 if p.matchLookaheadLiteral("min", 1) { - _t1914 = 1 + _t1916 = 1 } else { - var _t1915 int64 + var _t1917 int64 if p.matchLookaheadLiteral("max", 1) { - _t1915 = 2 + _t1917 = 2 } else { - _t1915 = -1 + _t1917 = -1 } - _t1914 = _t1915 + _t1916 = _t1917 } - _t1913 = _t1914 + _t1915 = _t1916 } - _t1912 = _t1913 + _t1914 = _t1915 } - _t1911 = _t1912 + _t1913 = _t1914 } else { - _t1911 = -1 - } - prediction1095 := _t1911 - var _t1916 *pb.Monoid - if prediction1095 == 3 { - _t1917 := p.parse_sum_monoid() - sum_monoid1099 := _t1917 - _t1918 := &pb.Monoid{} - _t1918.Value = &pb.Monoid_SumMonoid{SumMonoid: sum_monoid1099} - _t1916 = _t1918 + _t1913 = -1 + } + prediction1096 := _t1913 + var _t1918 *pb.Monoid + if prediction1096 == 3 { + _t1919 := p.parse_sum_monoid() + sum_monoid1100 := _t1919 + _t1920 := &pb.Monoid{} + _t1920.Value = &pb.Monoid_SumMonoid{SumMonoid: sum_monoid1100} + _t1918 = _t1920 } else { - var _t1919 *pb.Monoid - if prediction1095 == 2 { - _t1920 := p.parse_max_monoid() - max_monoid1098 := _t1920 - _t1921 := &pb.Monoid{} - _t1921.Value = &pb.Monoid_MaxMonoid{MaxMonoid: max_monoid1098} - _t1919 = _t1921 + var _t1921 *pb.Monoid + if prediction1096 == 2 { + _t1922 := p.parse_max_monoid() + max_monoid1099 := _t1922 + _t1923 := &pb.Monoid{} + _t1923.Value = &pb.Monoid_MaxMonoid{MaxMonoid: max_monoid1099} + _t1921 = _t1923 } else { - var _t1922 *pb.Monoid - if prediction1095 == 1 { - _t1923 := p.parse_min_monoid() - min_monoid1097 := _t1923 - _t1924 := &pb.Monoid{} - _t1924.Value = &pb.Monoid_MinMonoid{MinMonoid: min_monoid1097} - _t1922 = _t1924 + var _t1924 *pb.Monoid + if prediction1096 == 1 { + _t1925 := p.parse_min_monoid() + min_monoid1098 := _t1925 + _t1926 := &pb.Monoid{} + _t1926.Value = &pb.Monoid_MinMonoid{MinMonoid: min_monoid1098} + _t1924 = _t1926 } else { - var _t1925 *pb.Monoid - if prediction1095 == 0 { - _t1926 := p.parse_or_monoid() - or_monoid1096 := _t1926 - _t1927 := &pb.Monoid{} - _t1927.Value = &pb.Monoid_OrMonoid{OrMonoid: or_monoid1096} - _t1925 = _t1927 + var _t1927 *pb.Monoid + if prediction1096 == 0 { + _t1928 := p.parse_or_monoid() + or_monoid1097 := _t1928 + _t1929 := &pb.Monoid{} + _t1929.Value = &pb.Monoid_OrMonoid{OrMonoid: or_monoid1097} + _t1927 = _t1929 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in monoid", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1922 = _t1925 + _t1924 = _t1927 } - _t1919 = _t1922 + _t1921 = _t1924 } - _t1916 = _t1919 + _t1918 = _t1921 } - result1101 := _t1916 - p.recordSpan(int(span_start1100), "Monoid") - return result1101 + result1102 := _t1918 + p.recordSpan(int(span_start1101), "Monoid") + return result1102 } func (p *Parser) parse_or_monoid() *pb.OrMonoid { - span_start1102 := int64(p.spanStart()) + span_start1103 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("or") p.consumeLiteral(")") - _t1928 := &pb.OrMonoid{} - result1103 := _t1928 - p.recordSpan(int(span_start1102), "OrMonoid") - return result1103 + _t1930 := &pb.OrMonoid{} + result1104 := _t1930 + p.recordSpan(int(span_start1103), "OrMonoid") + return result1104 } func (p *Parser) parse_min_monoid() *pb.MinMonoid { - span_start1105 := int64(p.spanStart()) + span_start1106 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("min") - _t1929 := p.parse_type() - type1104 := _t1929 + _t1931 := p.parse_type() + type1105 := _t1931 p.consumeLiteral(")") - _t1930 := &pb.MinMonoid{Type: type1104} - result1106 := _t1930 - p.recordSpan(int(span_start1105), "MinMonoid") - return result1106 + _t1932 := &pb.MinMonoid{Type: type1105} + result1107 := _t1932 + p.recordSpan(int(span_start1106), "MinMonoid") + return result1107 } func (p *Parser) parse_max_monoid() *pb.MaxMonoid { - span_start1108 := int64(p.spanStart()) + span_start1109 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("max") - _t1931 := p.parse_type() - type1107 := _t1931 + _t1933 := p.parse_type() + type1108 := _t1933 p.consumeLiteral(")") - _t1932 := &pb.MaxMonoid{Type: type1107} - result1109 := _t1932 - p.recordSpan(int(span_start1108), "MaxMonoid") - return result1109 + _t1934 := &pb.MaxMonoid{Type: type1108} + result1110 := _t1934 + p.recordSpan(int(span_start1109), "MaxMonoid") + return result1110 } func (p *Parser) parse_sum_monoid() *pb.SumMonoid { - span_start1111 := int64(p.spanStart()) + span_start1112 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("sum") - _t1933 := p.parse_type() - type1110 := _t1933 + _t1935 := p.parse_type() + type1111 := _t1935 p.consumeLiteral(")") - _t1934 := &pb.SumMonoid{Type: type1110} - result1112 := _t1934 - p.recordSpan(int(span_start1111), "SumMonoid") - return result1112 + _t1936 := &pb.SumMonoid{Type: type1111} + result1113 := _t1936 + p.recordSpan(int(span_start1112), "SumMonoid") + return result1113 } func (p *Parser) parse_monus_def() *pb.MonusDef { - span_start1117 := int64(p.spanStart()) + span_start1118 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("monus") - _t1935 := p.parse_monoid() - monoid1113 := _t1935 - _t1936 := p.parse_relation_id() - relation_id1114 := _t1936 - _t1937 := p.parse_abstraction_with_arity() - abstraction_with_arity1115 := _t1937 - var _t1938 []*pb.Attribute + _t1937 := p.parse_monoid() + monoid1114 := _t1937 + _t1938 := p.parse_relation_id() + relation_id1115 := _t1938 + _t1939 := p.parse_abstraction_with_arity() + abstraction_with_arity1116 := _t1939 + var _t1940 []*pb.Attribute if p.matchLookaheadLiteral("(", 0) { - _t1939 := p.parse_attrs() - _t1938 = _t1939 + _t1941 := p.parse_attrs() + _t1940 = _t1941 } - attrs1116 := _t1938 + attrs1117 := _t1940 p.consumeLiteral(")") - _t1940 := attrs1116 - if attrs1116 == nil { - _t1940 = []*pb.Attribute{} + _t1942 := attrs1117 + if attrs1117 == nil { + _t1942 = []*pb.Attribute{} } - _t1941 := &pb.MonusDef{Monoid: monoid1113, Name: relation_id1114, Body: abstraction_with_arity1115[0].(*pb.Abstraction), Attrs: _t1940, ValueArity: abstraction_with_arity1115[1].(int64)} - result1118 := _t1941 - p.recordSpan(int(span_start1117), "MonusDef") - return result1118 + _t1943 := &pb.MonusDef{Monoid: monoid1114, Name: relation_id1115, Body: abstraction_with_arity1116[0].(*pb.Abstraction), Attrs: _t1942, ValueArity: abstraction_with_arity1116[1].(int64)} + result1119 := _t1943 + p.recordSpan(int(span_start1118), "MonusDef") + return result1119 } func (p *Parser) parse_constraint() *pb.Constraint { - span_start1123 := int64(p.spanStart()) + span_start1124 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("functional_dependency") - _t1942 := p.parse_relation_id() - relation_id1119 := _t1942 - _t1943 := p.parse_abstraction() - abstraction1120 := _t1943 - _t1944 := p.parse_functional_dependency_keys() - functional_dependency_keys1121 := _t1944 - _t1945 := p.parse_functional_dependency_values() - functional_dependency_values1122 := _t1945 + _t1944 := p.parse_relation_id() + relation_id1120 := _t1944 + _t1945 := p.parse_abstraction() + abstraction1121 := _t1945 + _t1946 := p.parse_functional_dependency_keys() + functional_dependency_keys1122 := _t1946 + _t1947 := p.parse_functional_dependency_values() + functional_dependency_values1123 := _t1947 p.consumeLiteral(")") - _t1946 := &pb.FunctionalDependency{Guard: abstraction1120, Keys: functional_dependency_keys1121, Values: functional_dependency_values1122} - _t1947 := &pb.Constraint{Name: relation_id1119} - _t1947.ConstraintType = &pb.Constraint_FunctionalDependency{FunctionalDependency: _t1946} - result1124 := _t1947 - p.recordSpan(int(span_start1123), "Constraint") - return result1124 + _t1948 := &pb.FunctionalDependency{Guard: abstraction1121, Keys: functional_dependency_keys1122, Values: functional_dependency_values1123} + _t1949 := &pb.Constraint{Name: relation_id1120} + _t1949.ConstraintType = &pb.Constraint_FunctionalDependency{FunctionalDependency: _t1948} + result1125 := _t1949 + p.recordSpan(int(span_start1124), "Constraint") + return result1125 } func (p *Parser) parse_functional_dependency_keys() []*pb.Var { p.consumeLiteral("(") p.consumeLiteral("keys") - xs1125 := []*pb.Var{} - cond1126 := p.matchLookaheadTerminal("SYMBOL", 0) - for cond1126 { - _t1948 := p.parse_var() - item1127 := _t1948 - xs1125 = append(xs1125, item1127) - cond1126 = p.matchLookaheadTerminal("SYMBOL", 0) - } - vars1128 := xs1125 + xs1126 := []*pb.Var{} + cond1127 := p.matchLookaheadTerminal("SYMBOL", 0) + for cond1127 { + _t1950 := p.parse_var() + item1128 := _t1950 + xs1126 = append(xs1126, item1128) + cond1127 = p.matchLookaheadTerminal("SYMBOL", 0) + } + vars1129 := xs1126 p.consumeLiteral(")") - return vars1128 + return vars1129 } func (p *Parser) parse_functional_dependency_values() []*pb.Var { p.consumeLiteral("(") p.consumeLiteral("values") - xs1129 := []*pb.Var{} - cond1130 := p.matchLookaheadTerminal("SYMBOL", 0) - for cond1130 { - _t1949 := p.parse_var() - item1131 := _t1949 - xs1129 = append(xs1129, item1131) - cond1130 = p.matchLookaheadTerminal("SYMBOL", 0) - } - vars1132 := xs1129 + xs1130 := []*pb.Var{} + cond1131 := p.matchLookaheadTerminal("SYMBOL", 0) + for cond1131 { + _t1951 := p.parse_var() + item1132 := _t1951 + xs1130 = append(xs1130, item1132) + cond1131 = p.matchLookaheadTerminal("SYMBOL", 0) + } + vars1133 := xs1130 p.consumeLiteral(")") - return vars1132 + return vars1133 } func (p *Parser) parse_data() *pb.Data { - span_start1138 := int64(p.spanStart()) - var _t1950 int64 + span_start1139 := int64(p.spanStart()) + var _t1952 int64 if p.matchLookaheadLiteral("(", 0) { - var _t1951 int64 + var _t1953 int64 if p.matchLookaheadLiteral("iceberg_data", 1) { - _t1951 = 3 + _t1953 = 3 } else { - var _t1952 int64 + var _t1954 int64 if p.matchLookaheadLiteral("edb", 1) { - _t1952 = 0 + _t1954 = 0 } else { - var _t1953 int64 + var _t1955 int64 if p.matchLookaheadLiteral("csv_data", 1) { - _t1953 = 2 + _t1955 = 2 } else { - var _t1954 int64 + var _t1956 int64 if p.matchLookaheadLiteral("betree_relation", 1) { - _t1954 = 1 + _t1956 = 1 } else { - _t1954 = -1 + _t1956 = -1 } - _t1953 = _t1954 + _t1955 = _t1956 } - _t1952 = _t1953 + _t1954 = _t1955 } - _t1951 = _t1952 + _t1953 = _t1954 } - _t1950 = _t1951 + _t1952 = _t1953 } else { - _t1950 = -1 - } - prediction1133 := _t1950 - var _t1955 *pb.Data - if prediction1133 == 3 { - _t1956 := p.parse_iceberg_data() - iceberg_data1137 := _t1956 - _t1957 := &pb.Data{} - _t1957.DataType = &pb.Data_IcebergData{IcebergData: iceberg_data1137} - _t1955 = _t1957 + _t1952 = -1 + } + prediction1134 := _t1952 + var _t1957 *pb.Data + if prediction1134 == 3 { + _t1958 := p.parse_iceberg_data() + iceberg_data1138 := _t1958 + _t1959 := &pb.Data{} + _t1959.DataType = &pb.Data_IcebergData{IcebergData: iceberg_data1138} + _t1957 = _t1959 } else { - var _t1958 *pb.Data - if prediction1133 == 2 { - _t1959 := p.parse_csv_data() - csv_data1136 := _t1959 - _t1960 := &pb.Data{} - _t1960.DataType = &pb.Data_CsvData{CsvData: csv_data1136} - _t1958 = _t1960 + var _t1960 *pb.Data + if prediction1134 == 2 { + _t1961 := p.parse_csv_data() + csv_data1137 := _t1961 + _t1962 := &pb.Data{} + _t1962.DataType = &pb.Data_CsvData{CsvData: csv_data1137} + _t1960 = _t1962 } else { - var _t1961 *pb.Data - if prediction1133 == 1 { - _t1962 := p.parse_betree_relation() - betree_relation1135 := _t1962 - _t1963 := &pb.Data{} - _t1963.DataType = &pb.Data_BetreeRelation{BetreeRelation: betree_relation1135} - _t1961 = _t1963 + var _t1963 *pb.Data + if prediction1134 == 1 { + _t1964 := p.parse_betree_relation() + betree_relation1136 := _t1964 + _t1965 := &pb.Data{} + _t1965.DataType = &pb.Data_BetreeRelation{BetreeRelation: betree_relation1136} + _t1963 = _t1965 } else { - var _t1964 *pb.Data - if prediction1133 == 0 { - _t1965 := p.parse_edb() - edb1134 := _t1965 - _t1966 := &pb.Data{} - _t1966.DataType = &pb.Data_Edb{Edb: edb1134} - _t1964 = _t1966 + var _t1966 *pb.Data + if prediction1134 == 0 { + _t1967 := p.parse_edb() + edb1135 := _t1967 + _t1968 := &pb.Data{} + _t1968.DataType = &pb.Data_Edb{Edb: edb1135} + _t1966 = _t1968 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in data", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1961 = _t1964 + _t1963 = _t1966 } - _t1958 = _t1961 + _t1960 = _t1963 } - _t1955 = _t1958 + _t1957 = _t1960 } - result1139 := _t1955 - p.recordSpan(int(span_start1138), "Data") - return result1139 + result1140 := _t1957 + p.recordSpan(int(span_start1139), "Data") + return result1140 } func (p *Parser) parse_edb() *pb.EDB { - span_start1143 := int64(p.spanStart()) + span_start1144 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("edb") - _t1967 := p.parse_relation_id() - relation_id1140 := _t1967 - _t1968 := p.parse_edb_path() - edb_path1141 := _t1968 - _t1969 := p.parse_edb_types() - edb_types1142 := _t1969 + _t1969 := p.parse_relation_id() + relation_id1141 := _t1969 + _t1970 := p.parse_edb_path() + edb_path1142 := _t1970 + _t1971 := p.parse_edb_types() + edb_types1143 := _t1971 p.consumeLiteral(")") - _t1970 := &pb.EDB{TargetId: relation_id1140, Path: edb_path1141, Types: edb_types1142} - result1144 := _t1970 - p.recordSpan(int(span_start1143), "EDB") - return result1144 + _t1972 := &pb.EDB{TargetId: relation_id1141, Path: edb_path1142, Types: edb_types1143} + result1145 := _t1972 + p.recordSpan(int(span_start1144), "EDB") + return result1145 } func (p *Parser) parse_edb_path() []string { p.consumeLiteral("[") - xs1145 := []string{} - cond1146 := p.matchLookaheadTerminal("STRING", 0) - for cond1146 { - item1147 := p.consumeTerminal("STRING").Value.str - xs1145 = append(xs1145, item1147) - cond1146 = p.matchLookaheadTerminal("STRING", 0) - } - strings1148 := xs1145 + xs1146 := []string{} + cond1147 := p.matchLookaheadTerminal("STRING", 0) + for cond1147 { + item1148 := p.consumeTerminal("STRING").Value.str + xs1146 = append(xs1146, item1148) + cond1147 = p.matchLookaheadTerminal("STRING", 0) + } + strings1149 := xs1146 p.consumeLiteral("]") - return strings1148 + return strings1149 } func (p *Parser) parse_edb_types() []*pb.Type { p.consumeLiteral("[") - xs1149 := []*pb.Type{} - cond1150 := (((((((((((((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 cond1150 { - _t1971 := p.parse_type() - item1151 := _t1971 - xs1149 = append(xs1149, item1151) - cond1150 = (((((((((((((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)) - } - types1152 := xs1149 + xs1150 := []*pb.Type{} + cond1151 := (((((((((((((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 cond1151 { + _t1973 := p.parse_type() + item1152 := _t1973 + xs1150 = append(xs1150, item1152) + cond1151 = (((((((((((((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)) + } + types1153 := xs1150 p.consumeLiteral("]") - return types1152 + return types1153 } func (p *Parser) parse_betree_relation() *pb.BeTreeRelation { - span_start1155 := int64(p.spanStart()) + span_start1156 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("betree_relation") - _t1972 := p.parse_relation_id() - relation_id1153 := _t1972 - _t1973 := p.parse_betree_info() - betree_info1154 := _t1973 + _t1974 := p.parse_relation_id() + relation_id1154 := _t1974 + _t1975 := p.parse_betree_info() + betree_info1155 := _t1975 p.consumeLiteral(")") - _t1974 := &pb.BeTreeRelation{Name: relation_id1153, RelationInfo: betree_info1154} - result1156 := _t1974 - p.recordSpan(int(span_start1155), "BeTreeRelation") - return result1156 + _t1976 := &pb.BeTreeRelation{Name: relation_id1154, RelationInfo: betree_info1155} + result1157 := _t1976 + p.recordSpan(int(span_start1156), "BeTreeRelation") + return result1157 } func (p *Parser) parse_betree_info() *pb.BeTreeInfo { - span_start1160 := int64(p.spanStart()) + span_start1161 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("betree_info") - _t1975 := p.parse_betree_info_key_types() - betree_info_key_types1157 := _t1975 - _t1976 := p.parse_betree_info_value_types() - betree_info_value_types1158 := _t1976 - _t1977 := p.parse_config_dict() - config_dict1159 := _t1977 + _t1977 := p.parse_betree_info_key_types() + betree_info_key_types1158 := _t1977 + _t1978 := p.parse_betree_info_value_types() + betree_info_value_types1159 := _t1978 + _t1979 := p.parse_config_dict() + config_dict1160 := _t1979 p.consumeLiteral(")") - _t1978 := p.construct_betree_info(betree_info_key_types1157, betree_info_value_types1158, config_dict1159) - result1161 := _t1978 - p.recordSpan(int(span_start1160), "BeTreeInfo") - return result1161 + _t1980 := p.construct_betree_info(betree_info_key_types1158, betree_info_value_types1159, config_dict1160) + result1162 := _t1980 + p.recordSpan(int(span_start1161), "BeTreeInfo") + return result1162 } func (p *Parser) parse_betree_info_key_types() []*pb.Type { p.consumeLiteral("(") p.consumeLiteral("key_types") - xs1162 := []*pb.Type{} - cond1163 := (((((((((((((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 cond1163 { - _t1979 := p.parse_type() - item1164 := _t1979 - xs1162 = append(xs1162, item1164) - cond1163 = (((((((((((((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)) - } - types1165 := xs1162 + xs1163 := []*pb.Type{} + cond1164 := (((((((((((((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 cond1164 { + _t1981 := p.parse_type() + item1165 := _t1981 + xs1163 = append(xs1163, item1165) + cond1164 = (((((((((((((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)) + } + types1166 := xs1163 p.consumeLiteral(")") - return types1165 + return types1166 } func (p *Parser) parse_betree_info_value_types() []*pb.Type { p.consumeLiteral("(") p.consumeLiteral("value_types") - xs1166 := []*pb.Type{} - cond1167 := (((((((((((((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 cond1167 { - _t1980 := p.parse_type() - item1168 := _t1980 - xs1166 = append(xs1166, item1168) - cond1167 = (((((((((((((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)) - } - types1169 := xs1166 + xs1167 := []*pb.Type{} + cond1168 := (((((((((((((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 cond1168 { + _t1982 := p.parse_type() + item1169 := _t1982 + xs1167 = append(xs1167, item1169) + cond1168 = (((((((((((((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)) + } + types1170 := xs1167 p.consumeLiteral(")") - return types1169 + return types1170 } func (p *Parser) parse_csv_data() *pb.CSVData { - span_start1174 := int64(p.spanStart()) + span_start1175 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("csv_data") - _t1981 := p.parse_csvlocator() - csvlocator1170 := _t1981 - _t1982 := p.parse_csv_config() - csv_config1171 := _t1982 - _t1983 := p.parse_gnf_columns() - gnf_columns1172 := _t1983 - _t1984 := p.parse_csv_asof() - csv_asof1173 := _t1984 + _t1983 := p.parse_csvlocator() + csvlocator1171 := _t1983 + _t1984 := p.parse_csv_config() + csv_config1172 := _t1984 + _t1985 := p.parse_gnf_columns() + gnf_columns1173 := _t1985 + _t1986 := p.parse_csv_asof() + csv_asof1174 := _t1986 p.consumeLiteral(")") - _t1985 := &pb.CSVData{Locator: csvlocator1170, Config: csv_config1171, Columns: gnf_columns1172, Asof: csv_asof1173} - result1175 := _t1985 - p.recordSpan(int(span_start1174), "CSVData") - return result1175 + _t1987 := &pb.CSVData{Locator: csvlocator1171, Config: csv_config1172, Columns: gnf_columns1173, Asof: csv_asof1174} + result1176 := _t1987 + p.recordSpan(int(span_start1175), "CSVData") + return result1176 } func (p *Parser) parse_csvlocator() *pb.CSVLocator { - span_start1178 := int64(p.spanStart()) + span_start1179 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("csv_locator") - var _t1986 []string + var _t1988 []string if (p.matchLookaheadLiteral("(", 0) && p.matchLookaheadLiteral("paths", 1)) { - _t1987 := p.parse_csv_locator_paths() - _t1986 = _t1987 + _t1989 := p.parse_csv_locator_paths() + _t1988 = _t1989 } - csv_locator_paths1176 := _t1986 - var _t1988 *string + csv_locator_paths1177 := _t1988 + var _t1990 *string if p.matchLookaheadLiteral("(", 0) { - _t1989 := p.parse_csv_locator_inline_data() - _t1988 = ptr(_t1989) + _t1991 := p.parse_csv_locator_inline_data() + _t1990 = ptr(_t1991) } - csv_locator_inline_data1177 := _t1988 + csv_locator_inline_data1178 := _t1990 p.consumeLiteral(")") - _t1990 := csv_locator_paths1176 - if csv_locator_paths1176 == nil { - _t1990 = []string{} + _t1992 := csv_locator_paths1177 + if csv_locator_paths1177 == nil { + _t1992 = []string{} } - _t1991 := &pb.CSVLocator{Paths: _t1990, InlineData: []byte(deref(csv_locator_inline_data1177, ""))} - result1179 := _t1991 - p.recordSpan(int(span_start1178), "CSVLocator") - return result1179 + _t1993 := &pb.CSVLocator{Paths: _t1992, InlineData: []byte(deref(csv_locator_inline_data1178, ""))} + result1180 := _t1993 + p.recordSpan(int(span_start1179), "CSVLocator") + return result1180 } func (p *Parser) parse_csv_locator_paths() []string { p.consumeLiteral("(") p.consumeLiteral("paths") - xs1180 := []string{} - cond1181 := p.matchLookaheadTerminal("STRING", 0) - for cond1181 { - item1182 := p.consumeTerminal("STRING").Value.str - xs1180 = append(xs1180, item1182) - cond1181 = p.matchLookaheadTerminal("STRING", 0) - } - strings1183 := xs1180 + xs1181 := []string{} + cond1182 := p.matchLookaheadTerminal("STRING", 0) + for cond1182 { + item1183 := p.consumeTerminal("STRING").Value.str + xs1181 = append(xs1181, item1183) + cond1182 = p.matchLookaheadTerminal("STRING", 0) + } + strings1184 := xs1181 p.consumeLiteral(")") - return strings1183 + return strings1184 } func (p *Parser) parse_csv_locator_inline_data() string { p.consumeLiteral("(") p.consumeLiteral("inline_data") - formatted_string1184 := p.consumeTerminal("STRING").Value.str + formatted_string1185 := p.consumeTerminal("STRING").Value.str p.consumeLiteral(")") - return formatted_string1184 + return formatted_string1185 } func (p *Parser) parse_csv_config() *pb.CSVConfig { - span_start1187 := int64(p.spanStart()) + span_start1188 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("csv_config") - _t1992 := p.parse_config_dict() - config_dict1185 := _t1992 - var _t1993 [][]interface{} + _t1994 := p.parse_config_dict() + config_dict1186 := _t1994 + var _t1995 [][]interface{} if p.matchLookaheadLiteral("(", 0) { - _t1994 := p.parse__storage_integration() - _t1993 = _t1994 + _t1996 := p.parse__storage_integration() + _t1995 = _t1996 } - _storage_integration1186 := _t1993 + _storage_integration1187 := _t1995 p.consumeLiteral(")") - _t1995 := p.construct_csv_config(config_dict1185, _storage_integration1186) - result1188 := _t1995 - p.recordSpan(int(span_start1187), "CSVConfig") - return result1188 + _t1997 := p.construct_csv_config(config_dict1186, _storage_integration1187) + result1189 := _t1997 + p.recordSpan(int(span_start1188), "CSVConfig") + return result1189 } func (p *Parser) parse__storage_integration() [][]interface{} { p.consumeLiteral("(") p.consumeLiteral("storage_integration") - _t1996 := p.parse_config_dict() - config_dict1189 := _t1996 + _t1998 := p.parse_config_dict() + config_dict1190 := _t1998 p.consumeLiteral(")") - return config_dict1189 + return config_dict1190 } func (p *Parser) parse_gnf_columns() []*pb.GNFColumn { p.consumeLiteral("(") p.consumeLiteral("columns") - xs1190 := []*pb.GNFColumn{} - cond1191 := p.matchLookaheadLiteral("(", 0) - for cond1191 { - _t1997 := p.parse_gnf_column() - item1192 := _t1997 - xs1190 = append(xs1190, item1192) - cond1191 = p.matchLookaheadLiteral("(", 0) - } - gnf_columns1193 := xs1190 + xs1191 := []*pb.GNFColumn{} + cond1192 := p.matchLookaheadLiteral("(", 0) + for cond1192 { + _t1999 := p.parse_gnf_column() + item1193 := _t1999 + xs1191 = append(xs1191, item1193) + cond1192 = p.matchLookaheadLiteral("(", 0) + } + gnf_columns1194 := xs1191 p.consumeLiteral(")") - return gnf_columns1193 + return gnf_columns1194 } func (p *Parser) parse_gnf_column() *pb.GNFColumn { - span_start1200 := int64(p.spanStart()) + span_start1201 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("column") - _t1998 := p.parse_gnf_column_path() - gnf_column_path1194 := _t1998 - var _t1999 *pb.RelationId + _t2000 := p.parse_gnf_column_path() + gnf_column_path1195 := _t2000 + var _t2001 *pb.RelationId if (p.matchLookaheadLiteral(":", 0) || p.matchLookaheadTerminal("UINT128", 0)) { - _t2000 := p.parse_relation_id() - _t1999 = _t2000 + _t2002 := p.parse_relation_id() + _t2001 = _t2002 } - relation_id1195 := _t1999 + relation_id1196 := _t2001 p.consumeLiteral("[") - xs1196 := []*pb.Type{} - cond1197 := (((((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("BOOLEAN", 0)) || p.matchLookaheadLiteral("DATE", 0)) || p.matchLookaheadLiteral("DATETIME", 0)) || p.matchLookaheadLiteral("FLOAT", 0)) || p.matchLookaheadLiteral("FLOAT32", 0)) || p.matchLookaheadLiteral("INT", 0)) || p.matchLookaheadLiteral("INT128", 0)) || p.matchLookaheadLiteral("INT32", 0)) || p.matchLookaheadLiteral("MISSING", 0)) || p.matchLookaheadLiteral("STRING", 0)) || p.matchLookaheadLiteral("UINT128", 0)) || p.matchLookaheadLiteral("UINT32", 0)) || p.matchLookaheadLiteral("UNKNOWN", 0)) - for cond1197 { - _t2001 := p.parse_type() - item1198 := _t2001 - xs1196 = append(xs1196, item1198) - cond1197 = (((((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("BOOLEAN", 0)) || p.matchLookaheadLiteral("DATE", 0)) || p.matchLookaheadLiteral("DATETIME", 0)) || p.matchLookaheadLiteral("FLOAT", 0)) || p.matchLookaheadLiteral("FLOAT32", 0)) || p.matchLookaheadLiteral("INT", 0)) || p.matchLookaheadLiteral("INT128", 0)) || p.matchLookaheadLiteral("INT32", 0)) || p.matchLookaheadLiteral("MISSING", 0)) || p.matchLookaheadLiteral("STRING", 0)) || p.matchLookaheadLiteral("UINT128", 0)) || p.matchLookaheadLiteral("UINT32", 0)) || p.matchLookaheadLiteral("UNKNOWN", 0)) - } - types1199 := xs1196 + xs1197 := []*pb.Type{} + cond1198 := (((((((((((((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 cond1198 { + _t2003 := p.parse_type() + item1199 := _t2003 + xs1197 = append(xs1197, item1199) + cond1198 = (((((((((((((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)) + } + types1200 := xs1197 p.consumeLiteral("]") p.consumeLiteral(")") - _t2002 := &pb.GNFColumn{ColumnPath: gnf_column_path1194, TargetId: relation_id1195, Types: types1199} - result1201 := _t2002 - p.recordSpan(int(span_start1200), "GNFColumn") - return result1201 + _t2004 := &pb.GNFColumn{ColumnPath: gnf_column_path1195, TargetId: relation_id1196, Types: types1200} + result1202 := _t2004 + p.recordSpan(int(span_start1201), "GNFColumn") + return result1202 } func (p *Parser) parse_gnf_column_path() []string { - var _t2003 int64 + var _t2005 int64 if p.matchLookaheadLiteral("[", 0) { - _t2003 = 1 + _t2005 = 1 } else { - var _t2004 int64 + var _t2006 int64 if p.matchLookaheadTerminal("STRING", 0) { - _t2004 = 0 + _t2006 = 0 } else { - _t2004 = -1 + _t2006 = -1 } - _t2003 = _t2004 + _t2005 = _t2006 } - prediction1202 := _t2003 - var _t2005 []string - if prediction1202 == 1 { + prediction1203 := _t2005 + var _t2007 []string + if prediction1203 == 1 { p.consumeLiteral("[") - xs1204 := []string{} - cond1205 := p.matchLookaheadTerminal("STRING", 0) - for cond1205 { - item1206 := p.consumeTerminal("STRING").Value.str - xs1204 = append(xs1204, item1206) - cond1205 = p.matchLookaheadTerminal("STRING", 0) + xs1205 := []string{} + cond1206 := p.matchLookaheadTerminal("STRING", 0) + for cond1206 { + item1207 := p.consumeTerminal("STRING").Value.str + xs1205 = append(xs1205, item1207) + cond1206 = p.matchLookaheadTerminal("STRING", 0) } - strings1207 := xs1204 + strings1208 := xs1205 p.consumeLiteral("]") - _t2005 = strings1207 + _t2007 = strings1208 } else { - var _t2006 []string - if prediction1202 == 0 { - string1203 := p.consumeTerminal("STRING").Value.str - _ = string1203 - _t2006 = []string{string1203} + var _t2008 []string + if prediction1203 == 0 { + string1204 := p.consumeTerminal("STRING").Value.str + _ = string1204 + _t2008 = []string{string1204} } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in gnf_column_path", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t2005 = _t2006 + _t2007 = _t2008 } - return _t2005 + return _t2007 } func (p *Parser) parse_csv_asof() string { p.consumeLiteral("(") p.consumeLiteral("asof") - string1208 := p.consumeTerminal("STRING").Value.str + string1209 := p.consumeTerminal("STRING").Value.str p.consumeLiteral(")") - return string1208 + return string1209 } func (p *Parser) parse_iceberg_data() *pb.IcebergData { - span_start1215 := int64(p.spanStart()) + span_start1216 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("iceberg_data") - _t2007 := p.parse_iceberg_locator() - iceberg_locator1209 := _t2007 - _t2008 := p.parse_iceberg_catalog_config() - iceberg_catalog_config1210 := _t2008 - _t2009 := p.parse_gnf_columns() - gnf_columns1211 := _t2009 - var _t2010 *string + _t2009 := p.parse_iceberg_locator() + iceberg_locator1210 := _t2009 + _t2010 := p.parse_iceberg_catalog_config() + iceberg_catalog_config1211 := _t2010 + _t2011 := p.parse_gnf_columns() + gnf_columns1212 := _t2011 + var _t2012 *string if (p.matchLookaheadLiteral("(", 0) && p.matchLookaheadLiteral("from_snapshot", 1)) { - _t2011 := p.parse_iceberg_from_snapshot() - _t2010 = ptr(_t2011) + _t2013 := p.parse_iceberg_from_snapshot() + _t2012 = ptr(_t2013) } - iceberg_from_snapshot1212 := _t2010 - var _t2012 *string + iceberg_from_snapshot1213 := _t2012 + var _t2014 *string if p.matchLookaheadLiteral("(", 0) { - _t2013 := p.parse_iceberg_to_snapshot() - _t2012 = ptr(_t2013) + _t2015 := p.parse_iceberg_to_snapshot() + _t2014 = ptr(_t2015) } - iceberg_to_snapshot1213 := _t2012 - _t2014 := p.parse_boolean_value() - boolean_value1214 := _t2014 + iceberg_to_snapshot1214 := _t2014 + _t2016 := p.parse_boolean_value() + boolean_value1215 := _t2016 p.consumeLiteral(")") - _t2015 := p.construct_iceberg_data(iceberg_locator1209, iceberg_catalog_config1210, gnf_columns1211, iceberg_from_snapshot1212, iceberg_to_snapshot1213, boolean_value1214) - result1216 := _t2015 - p.recordSpan(int(span_start1215), "IcebergData") - return result1216 + _t2017 := p.construct_iceberg_data(iceberg_locator1210, iceberg_catalog_config1211, gnf_columns1212, iceberg_from_snapshot1213, iceberg_to_snapshot1214, boolean_value1215) + result1217 := _t2017 + p.recordSpan(int(span_start1216), "IcebergData") + return result1217 } func (p *Parser) parse_iceberg_locator() *pb.IcebergLocator { - span_start1220 := int64(p.spanStart()) + span_start1221 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("iceberg_locator") - _t2016 := p.parse_iceberg_locator_table_name() - iceberg_locator_table_name1217 := _t2016 - _t2017 := p.parse_iceberg_locator_namespace() - iceberg_locator_namespace1218 := _t2017 - _t2018 := p.parse_iceberg_locator_warehouse() - iceberg_locator_warehouse1219 := _t2018 + _t2018 := p.parse_iceberg_locator_table_name() + iceberg_locator_table_name1218 := _t2018 + _t2019 := p.parse_iceberg_locator_namespace() + iceberg_locator_namespace1219 := _t2019 + _t2020 := p.parse_iceberg_locator_warehouse() + iceberg_locator_warehouse1220 := _t2020 p.consumeLiteral(")") - _t2019 := &pb.IcebergLocator{TableName: iceberg_locator_table_name1217, Namespace: iceberg_locator_namespace1218, Warehouse: iceberg_locator_warehouse1219} - result1221 := _t2019 - p.recordSpan(int(span_start1220), "IcebergLocator") - return result1221 + _t2021 := &pb.IcebergLocator{TableName: iceberg_locator_table_name1218, Namespace: iceberg_locator_namespace1219, Warehouse: iceberg_locator_warehouse1220} + result1222 := _t2021 + p.recordSpan(int(span_start1221), "IcebergLocator") + return result1222 } func (p *Parser) parse_iceberg_locator_table_name() string { p.consumeLiteral("(") p.consumeLiteral("table_name") - string1222 := p.consumeTerminal("STRING").Value.str + string1223 := p.consumeTerminal("STRING").Value.str p.consumeLiteral(")") - return string1222 + return string1223 } func (p *Parser) parse_iceberg_locator_namespace() []string { p.consumeLiteral("(") p.consumeLiteral("namespace") - xs1223 := []string{} - cond1224 := p.matchLookaheadTerminal("STRING", 0) - for cond1224 { - item1225 := p.consumeTerminal("STRING").Value.str - xs1223 = append(xs1223, item1225) - cond1224 = p.matchLookaheadTerminal("STRING", 0) - } - strings1226 := xs1223 + xs1224 := []string{} + cond1225 := p.matchLookaheadTerminal("STRING", 0) + for cond1225 { + item1226 := p.consumeTerminal("STRING").Value.str + xs1224 = append(xs1224, item1226) + cond1225 = p.matchLookaheadTerminal("STRING", 0) + } + strings1227 := xs1224 p.consumeLiteral(")") - return strings1226 + return strings1227 } func (p *Parser) parse_iceberg_locator_warehouse() string { p.consumeLiteral("(") p.consumeLiteral("warehouse") - string1227 := p.consumeTerminal("STRING").Value.str + string1228 := p.consumeTerminal("STRING").Value.str p.consumeLiteral(")") - return string1227 + return string1228 } func (p *Parser) parse_iceberg_catalog_config() *pb.IcebergCatalogConfig { - span_start1232 := int64(p.spanStart()) + span_start1233 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("iceberg_catalog_config") - _t2020 := p.parse_iceberg_catalog_uri() - iceberg_catalog_uri1228 := _t2020 - var _t2021 *string + _t2022 := p.parse_iceberg_catalog_uri() + iceberg_catalog_uri1229 := _t2022 + var _t2023 *string if (p.matchLookaheadLiteral("(", 0) && p.matchLookaheadLiteral("scope", 1)) { - _t2022 := p.parse_iceberg_catalog_config_scope() - _t2021 = ptr(_t2022) - } - iceberg_catalog_config_scope1229 := _t2021 - _t2023 := p.parse_iceberg_properties() - iceberg_properties1230 := _t2023 - _t2024 := p.parse_iceberg_auth_properties() - iceberg_auth_properties1231 := _t2024 + _t2024 := p.parse_iceberg_catalog_config_scope() + _t2023 = ptr(_t2024) + } + iceberg_catalog_config_scope1230 := _t2023 + _t2025 := p.parse_iceberg_properties() + iceberg_properties1231 := _t2025 + _t2026 := p.parse_iceberg_auth_properties() + iceberg_auth_properties1232 := _t2026 p.consumeLiteral(")") - _t2025 := p.construct_iceberg_catalog_config(iceberg_catalog_uri1228, iceberg_catalog_config_scope1229, iceberg_properties1230, iceberg_auth_properties1231) - result1233 := _t2025 - p.recordSpan(int(span_start1232), "IcebergCatalogConfig") - return result1233 + _t2027 := p.construct_iceberg_catalog_config(iceberg_catalog_uri1229, iceberg_catalog_config_scope1230, iceberg_properties1231, iceberg_auth_properties1232) + result1234 := _t2027 + p.recordSpan(int(span_start1233), "IcebergCatalogConfig") + return result1234 } func (p *Parser) parse_iceberg_catalog_uri() string { p.consumeLiteral("(") p.consumeLiteral("catalog_uri") - string1234 := p.consumeTerminal("STRING").Value.str + string1235 := p.consumeTerminal("STRING").Value.str p.consumeLiteral(")") - return string1234 + return string1235 } func (p *Parser) parse_iceberg_catalog_config_scope() string { p.consumeLiteral("(") p.consumeLiteral("scope") - string1235 := p.consumeTerminal("STRING").Value.str + string1236 := p.consumeTerminal("STRING").Value.str p.consumeLiteral(")") - return string1235 + return string1236 } func (p *Parser) parse_iceberg_properties() [][]interface{} { p.consumeLiteral("(") p.consumeLiteral("properties") - xs1236 := [][]interface{}{} - cond1237 := p.matchLookaheadLiteral("(", 0) - for cond1237 { - _t2026 := p.parse_iceberg_property_entry() - item1238 := _t2026 - xs1236 = append(xs1236, item1238) - cond1237 = p.matchLookaheadLiteral("(", 0) - } - iceberg_property_entrys1239 := xs1236 + xs1237 := [][]interface{}{} + cond1238 := p.matchLookaheadLiteral("(", 0) + for cond1238 { + _t2028 := p.parse_iceberg_property_entry() + item1239 := _t2028 + xs1237 = append(xs1237, item1239) + cond1238 = p.matchLookaheadLiteral("(", 0) + } + iceberg_property_entrys1240 := xs1237 p.consumeLiteral(")") - return iceberg_property_entrys1239 + return iceberg_property_entrys1240 } func (p *Parser) parse_iceberg_property_entry() []interface{} { p.consumeLiteral("(") p.consumeLiteral("prop") - string1240 := p.consumeTerminal("STRING").Value.str - string_31241 := p.consumeTerminal("STRING").Value.str + string1241 := p.consumeTerminal("STRING").Value.str + string_31242 := p.consumeTerminal("STRING").Value.str p.consumeLiteral(")") - return []interface{}{string1240, string_31241} + return []interface{}{string1241, string_31242} } func (p *Parser) parse_iceberg_auth_properties() [][]interface{} { p.consumeLiteral("(") p.consumeLiteral("auth_properties") - xs1242 := [][]interface{}{} - cond1243 := p.matchLookaheadLiteral("(", 0) - for cond1243 { - _t2027 := p.parse_iceberg_masked_property_entry() - item1244 := _t2027 - xs1242 = append(xs1242, item1244) - cond1243 = p.matchLookaheadLiteral("(", 0) - } - iceberg_masked_property_entrys1245 := xs1242 + xs1243 := [][]interface{}{} + cond1244 := p.matchLookaheadLiteral("(", 0) + for cond1244 { + _t2029 := p.parse_iceberg_masked_property_entry() + item1245 := _t2029 + xs1243 = append(xs1243, item1245) + cond1244 = p.matchLookaheadLiteral("(", 0) + } + iceberg_masked_property_entrys1246 := xs1243 p.consumeLiteral(")") - return iceberg_masked_property_entrys1245 + return iceberg_masked_property_entrys1246 } func (p *Parser) parse_iceberg_masked_property_entry() []interface{} { p.consumeLiteral("(") p.consumeLiteral("prop") - string1246 := p.consumeTerminal("STRING").Value.str - string_31247 := p.consumeTerminal("STRING").Value.str + string1247 := p.consumeTerminal("STRING").Value.str + string_31248 := p.consumeTerminal("STRING").Value.str p.consumeLiteral(")") - return []interface{}{string1246, string_31247} + return []interface{}{string1247, string_31248} } func (p *Parser) parse_iceberg_from_snapshot() string { p.consumeLiteral("(") p.consumeLiteral("from_snapshot") - string1248 := p.consumeTerminal("STRING").Value.str + string1249 := p.consumeTerminal("STRING").Value.str p.consumeLiteral(")") - return string1248 + return string1249 } func (p *Parser) parse_iceberg_to_snapshot() string { p.consumeLiteral("(") p.consumeLiteral("to_snapshot") - string1249 := p.consumeTerminal("STRING").Value.str + string1250 := p.consumeTerminal("STRING").Value.str p.consumeLiteral(")") - return string1249 + return string1250 } func (p *Parser) parse_undefine() *pb.Undefine { - span_start1251 := int64(p.spanStart()) + span_start1252 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("undefine") - _t2028 := p.parse_fragment_id() - fragment_id1250 := _t2028 + _t2030 := p.parse_fragment_id() + fragment_id1251 := _t2030 p.consumeLiteral(")") - _t2029 := &pb.Undefine{FragmentId: fragment_id1250} - result1252 := _t2029 - p.recordSpan(int(span_start1251), "Undefine") - return result1252 + _t2031 := &pb.Undefine{FragmentId: fragment_id1251} + result1253 := _t2031 + p.recordSpan(int(span_start1252), "Undefine") + return result1253 } func (p *Parser) parse_context() *pb.Context { - span_start1257 := int64(p.spanStart()) + span_start1258 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("context") - xs1253 := []*pb.RelationId{} - cond1254 := (p.matchLookaheadLiteral(":", 0) || p.matchLookaheadTerminal("UINT128", 0)) - for cond1254 { - _t2030 := p.parse_relation_id() - item1255 := _t2030 - xs1253 = append(xs1253, item1255) - cond1254 = (p.matchLookaheadLiteral(":", 0) || p.matchLookaheadTerminal("UINT128", 0)) - } - relation_ids1256 := xs1253 + xs1254 := []*pb.RelationId{} + cond1255 := (p.matchLookaheadLiteral(":", 0) || p.matchLookaheadTerminal("UINT128", 0)) + for cond1255 { + _t2032 := p.parse_relation_id() + item1256 := _t2032 + xs1254 = append(xs1254, item1256) + cond1255 = (p.matchLookaheadLiteral(":", 0) || p.matchLookaheadTerminal("UINT128", 0)) + } + relation_ids1257 := xs1254 p.consumeLiteral(")") - _t2031 := &pb.Context{Relations: relation_ids1256} - result1258 := _t2031 - p.recordSpan(int(span_start1257), "Context") - return result1258 + _t2033 := &pb.Context{Relations: relation_ids1257} + result1259 := _t2033 + p.recordSpan(int(span_start1258), "Context") + return result1259 } func (p *Parser) parse_snapshot() *pb.Snapshot { - span_start1264 := int64(p.spanStart()) + span_start1265 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("snapshot") - _t2032 := p.parse_edb_path() - edb_path1259 := _t2032 - xs1260 := []*pb.SnapshotMapping{} - cond1261 := p.matchLookaheadLiteral("[", 0) - for cond1261 { - _t2033 := p.parse_snapshot_mapping() - item1262 := _t2033 - xs1260 = append(xs1260, item1262) - cond1261 = p.matchLookaheadLiteral("[", 0) - } - snapshot_mappings1263 := xs1260 + _t2034 := p.parse_edb_path() + edb_path1260 := _t2034 + xs1261 := []*pb.SnapshotMapping{} + cond1262 := p.matchLookaheadLiteral("[", 0) + for cond1262 { + _t2035 := p.parse_snapshot_mapping() + item1263 := _t2035 + xs1261 = append(xs1261, item1263) + cond1262 = p.matchLookaheadLiteral("[", 0) + } + snapshot_mappings1264 := xs1261 p.consumeLiteral(")") - _t2034 := &pb.Snapshot{Prefix: edb_path1259, Mappings: snapshot_mappings1263} - result1265 := _t2034 - p.recordSpan(int(span_start1264), "Snapshot") - return result1265 + _t2036 := &pb.Snapshot{Prefix: edb_path1260, Mappings: snapshot_mappings1264} + result1266 := _t2036 + p.recordSpan(int(span_start1265), "Snapshot") + return result1266 } func (p *Parser) parse_snapshot_mapping() *pb.SnapshotMapping { - span_start1268 := int64(p.spanStart()) - _t2035 := p.parse_edb_path() - edb_path1266 := _t2035 - _t2036 := p.parse_relation_id() - relation_id1267 := _t2036 - _t2037 := &pb.SnapshotMapping{DestinationPath: edb_path1266, SourceRelation: relation_id1267} - result1269 := _t2037 - p.recordSpan(int(span_start1268), "SnapshotMapping") - return result1269 + span_start1269 := int64(p.spanStart()) + _t2037 := p.parse_edb_path() + edb_path1267 := _t2037 + _t2038 := p.parse_relation_id() + relation_id1268 := _t2038 + _t2039 := &pb.SnapshotMapping{DestinationPath: edb_path1267, SourceRelation: relation_id1268} + result1270 := _t2039 + p.recordSpan(int(span_start1269), "SnapshotMapping") + return result1270 } func (p *Parser) parse_epoch_reads() []*pb.Read { p.consumeLiteral("(") p.consumeLiteral("reads") - xs1270 := []*pb.Read{} - cond1271 := p.matchLookaheadLiteral("(", 0) - for cond1271 { - _t2038 := p.parse_read() - item1272 := _t2038 - xs1270 = append(xs1270, item1272) - cond1271 = p.matchLookaheadLiteral("(", 0) - } - reads1273 := xs1270 + xs1271 := []*pb.Read{} + cond1272 := p.matchLookaheadLiteral("(", 0) + for cond1272 { + _t2040 := p.parse_read() + item1273 := _t2040 + xs1271 = append(xs1271, item1273) + cond1272 = p.matchLookaheadLiteral("(", 0) + } + reads1274 := xs1271 p.consumeLiteral(")") - return reads1273 + return reads1274 } func (p *Parser) parse_read() *pb.Read { - span_start1281 := int64(p.spanStart()) - var _t2039 int64 + span_start1282 := int64(p.spanStart()) + var _t2041 int64 if p.matchLookaheadLiteral("(", 0) { - var _t2040 int64 + var _t2042 int64 if p.matchLookaheadLiteral("what_if", 1) { - _t2040 = 2 + _t2042 = 2 } else { - var _t2041 int64 + var _t2043 int64 if p.matchLookaheadLiteral("output", 1) { - _t2041 = 1 + _t2043 = 1 } else { - var _t2042 int64 + var _t2044 int64 if p.matchLookaheadLiteral("export_output", 1) { - _t2042 = 5 + _t2044 = 5 } else { - var _t2043 int64 + var _t2045 int64 if p.matchLookaheadLiteral("export_iceberg", 1) { - _t2043 = 4 + _t2045 = 4 } else { - var _t2044 int64 + var _t2046 int64 if p.matchLookaheadLiteral("export", 1) { - _t2044 = 4 + _t2046 = 4 } else { - var _t2045 int64 + var _t2047 int64 if p.matchLookaheadLiteral("demand", 1) { - _t2045 = 0 + _t2047 = 0 } else { - var _t2046 int64 + var _t2048 int64 if p.matchLookaheadLiteral("abort", 1) { - _t2046 = 3 + _t2048 = 3 } else { - _t2046 = -1 + _t2048 = -1 } - _t2045 = _t2046 + _t2047 = _t2048 } - _t2044 = _t2045 + _t2046 = _t2047 } - _t2043 = _t2044 + _t2045 = _t2046 } - _t2042 = _t2043 + _t2044 = _t2045 } - _t2041 = _t2042 + _t2043 = _t2044 } - _t2040 = _t2041 + _t2042 = _t2043 } - _t2039 = _t2040 + _t2041 = _t2042 } else { - _t2039 = -1 - } - prediction1274 := _t2039 - var _t2047 *pb.Read - if prediction1274 == 5 { - _t2048 := p.parse_export_output() - export_output1280 := _t2048 - _t2049 := &pb.Read{} - _t2049.ReadType = &pb.Read_ExportOutput{ExportOutput: export_output1280} - _t2047 = _t2049 + _t2041 = -1 + } + prediction1275 := _t2041 + var _t2049 *pb.Read + if prediction1275 == 5 { + _t2050 := p.parse_export_output() + export_output1281 := _t2050 + _t2051 := &pb.Read{} + _t2051.ReadType = &pb.Read_ExportOutput{ExportOutput: export_output1281} + _t2049 = _t2051 } else { - var _t2050 *pb.Read - if prediction1274 == 4 { - _t2051 := p.parse_export() - export1279 := _t2051 - _t2052 := &pb.Read{} - _t2052.ReadType = &pb.Read_Export{Export: export1279} - _t2050 = _t2052 + var _t2052 *pb.Read + if prediction1275 == 4 { + _t2053 := p.parse_export() + export1280 := _t2053 + _t2054 := &pb.Read{} + _t2054.ReadType = &pb.Read_Export{Export: export1280} + _t2052 = _t2054 } else { - var _t2053 *pb.Read - if prediction1274 == 3 { - _t2054 := p.parse_abort() - abort1278 := _t2054 - _t2055 := &pb.Read{} - _t2055.ReadType = &pb.Read_Abort{Abort: abort1278} - _t2053 = _t2055 + var _t2055 *pb.Read + if prediction1275 == 3 { + _t2056 := p.parse_abort() + abort1279 := _t2056 + _t2057 := &pb.Read{} + _t2057.ReadType = &pb.Read_Abort{Abort: abort1279} + _t2055 = _t2057 } else { - var _t2056 *pb.Read - if prediction1274 == 2 { - _t2057 := p.parse_what_if() - what_if1277 := _t2057 - _t2058 := &pb.Read{} - _t2058.ReadType = &pb.Read_WhatIf{WhatIf: what_if1277} - _t2056 = _t2058 + var _t2058 *pb.Read + if prediction1275 == 2 { + _t2059 := p.parse_what_if() + what_if1278 := _t2059 + _t2060 := &pb.Read{} + _t2060.ReadType = &pb.Read_WhatIf{WhatIf: what_if1278} + _t2058 = _t2060 } else { - var _t2059 *pb.Read - if prediction1274 == 1 { - _t2060 := p.parse_output() - output1276 := _t2060 - _t2061 := &pb.Read{} - _t2061.ReadType = &pb.Read_Output{Output: output1276} - _t2059 = _t2061 + var _t2061 *pb.Read + if prediction1275 == 1 { + _t2062 := p.parse_output() + output1277 := _t2062 + _t2063 := &pb.Read{} + _t2063.ReadType = &pb.Read_Output{Output: output1277} + _t2061 = _t2063 } else { - var _t2062 *pb.Read - if prediction1274 == 0 { - _t2063 := p.parse_demand() - demand1275 := _t2063 - _t2064 := &pb.Read{} - _t2064.ReadType = &pb.Read_Demand{Demand: demand1275} - _t2062 = _t2064 + var _t2064 *pb.Read + if prediction1275 == 0 { + _t2065 := p.parse_demand() + demand1276 := _t2065 + _t2066 := &pb.Read{} + _t2066.ReadType = &pb.Read_Demand{Demand: demand1276} + _t2064 = _t2066 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in read", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t2059 = _t2062 + _t2061 = _t2064 } - _t2056 = _t2059 + _t2058 = _t2061 } - _t2053 = _t2056 + _t2055 = _t2058 } - _t2050 = _t2053 + _t2052 = _t2055 } - _t2047 = _t2050 + _t2049 = _t2052 } - result1282 := _t2047 - p.recordSpan(int(span_start1281), "Read") - return result1282 + result1283 := _t2049 + p.recordSpan(int(span_start1282), "Read") + return result1283 } func (p *Parser) parse_demand() *pb.Demand { - span_start1284 := int64(p.spanStart()) + span_start1285 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("demand") - _t2065 := p.parse_relation_id() - relation_id1283 := _t2065 + _t2067 := p.parse_relation_id() + relation_id1284 := _t2067 p.consumeLiteral(")") - _t2066 := &pb.Demand{RelationId: relation_id1283} - result1285 := _t2066 - p.recordSpan(int(span_start1284), "Demand") - return result1285 + _t2068 := &pb.Demand{RelationId: relation_id1284} + result1286 := _t2068 + p.recordSpan(int(span_start1285), "Demand") + return result1286 } func (p *Parser) parse_output() *pb.Output { - span_start1288 := int64(p.spanStart()) + span_start1289 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("output") - _t2067 := p.parse_name() - name1286 := _t2067 - _t2068 := p.parse_relation_id() - relation_id1287 := _t2068 + _t2069 := p.parse_name() + name1287 := _t2069 + _t2070 := p.parse_relation_id() + relation_id1288 := _t2070 p.consumeLiteral(")") - _t2069 := &pb.Output{Name: name1286, RelationId: relation_id1287} - result1289 := _t2069 - p.recordSpan(int(span_start1288), "Output") - return result1289 + _t2071 := &pb.Output{Name: name1287, RelationId: relation_id1288} + result1290 := _t2071 + p.recordSpan(int(span_start1289), "Output") + return result1290 } func (p *Parser) parse_what_if() *pb.WhatIf { - span_start1292 := int64(p.spanStart()) + span_start1293 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("what_if") - _t2070 := p.parse_name() - name1290 := _t2070 - _t2071 := p.parse_epoch() - epoch1291 := _t2071 + _t2072 := p.parse_name() + name1291 := _t2072 + _t2073 := p.parse_epoch() + epoch1292 := _t2073 p.consumeLiteral(")") - _t2072 := &pb.WhatIf{Branch: name1290, Epoch: epoch1291} - result1293 := _t2072 - p.recordSpan(int(span_start1292), "WhatIf") - return result1293 + _t2074 := &pb.WhatIf{Branch: name1291, Epoch: epoch1292} + result1294 := _t2074 + p.recordSpan(int(span_start1293), "WhatIf") + return result1294 } func (p *Parser) parse_abort() *pb.Abort { - span_start1296 := int64(p.spanStart()) + span_start1297 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("abort") - var _t2073 *string + var _t2075 *string if (p.matchLookaheadLiteral(":", 0) && p.matchLookaheadTerminal("SYMBOL", 1)) { - _t2074 := p.parse_name() - _t2073 = ptr(_t2074) + _t2076 := p.parse_name() + _t2075 = ptr(_t2076) } - name1294 := _t2073 - _t2075 := p.parse_relation_id() - relation_id1295 := _t2075 + name1295 := _t2075 + _t2077 := p.parse_relation_id() + relation_id1296 := _t2077 p.consumeLiteral(")") - _t2076 := &pb.Abort{Name: deref(name1294, "abort"), RelationId: relation_id1295} - result1297 := _t2076 - p.recordSpan(int(span_start1296), "Abort") - return result1297 + _t2078 := &pb.Abort{Name: deref(name1295, "abort"), RelationId: relation_id1296} + result1298 := _t2078 + p.recordSpan(int(span_start1297), "Abort") + return result1298 } func (p *Parser) parse_export() *pb.Export { - span_start1301 := int64(p.spanStart()) - var _t2077 int64 + span_start1302 := int64(p.spanStart()) + var _t2079 int64 if p.matchLookaheadLiteral("(", 0) { - var _t2078 int64 + var _t2080 int64 if p.matchLookaheadLiteral("export_iceberg", 1) { - _t2078 = 1 + _t2080 = 1 } else { - var _t2079 int64 + var _t2081 int64 if p.matchLookaheadLiteral("export", 1) { - _t2079 = 0 + _t2081 = 0 } else { - _t2079 = -1 + _t2081 = -1 } - _t2078 = _t2079 + _t2080 = _t2081 } - _t2077 = _t2078 + _t2079 = _t2080 } else { - _t2077 = -1 + _t2079 = -1 } - prediction1298 := _t2077 - var _t2080 *pb.Export - if prediction1298 == 1 { + prediction1299 := _t2079 + var _t2082 *pb.Export + if prediction1299 == 1 { p.consumeLiteral("(") p.consumeLiteral("export_iceberg") - _t2081 := p.parse_export_iceberg_config() - export_iceberg_config1300 := _t2081 + _t2083 := p.parse_export_iceberg_config() + export_iceberg_config1301 := _t2083 p.consumeLiteral(")") - _t2082 := &pb.Export{} - _t2082.ExportConfig = &pb.Export_IcebergConfig{IcebergConfig: export_iceberg_config1300} - _t2080 = _t2082 + _t2084 := &pb.Export{} + _t2084.ExportConfig = &pb.Export_IcebergConfig{IcebergConfig: export_iceberg_config1301} + _t2082 = _t2084 } else { - var _t2083 *pb.Export - if prediction1298 == 0 { + var _t2085 *pb.Export + if prediction1299 == 0 { p.consumeLiteral("(") p.consumeLiteral("export") - _t2084 := p.parse_export_csv_config() - export_csv_config1299 := _t2084 + _t2086 := p.parse_export_csv_config() + export_csv_config1300 := _t2086 p.consumeLiteral(")") - _t2085 := &pb.Export{} - _t2085.ExportConfig = &pb.Export_CsvConfig{CsvConfig: export_csv_config1299} - _t2083 = _t2085 + _t2087 := &pb.Export{} + _t2087.ExportConfig = &pb.Export_CsvConfig{CsvConfig: export_csv_config1300} + _t2085 = _t2087 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in export", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t2080 = _t2083 + _t2082 = _t2085 } - result1302 := _t2080 - p.recordSpan(int(span_start1301), "Export") - return result1302 + result1303 := _t2082 + p.recordSpan(int(span_start1302), "Export") + return result1303 } func (p *Parser) parse_export_csv_config() *pb.ExportCSVConfig { - span_start1310 := int64(p.spanStart()) - var _t2086 int64 + span_start1311 := int64(p.spanStart()) + var _t2088 int64 if p.matchLookaheadLiteral("(", 0) { - var _t2087 int64 + var _t2089 int64 if p.matchLookaheadLiteral("export_csv_config_v2", 1) { - _t2087 = 0 + _t2089 = 0 } else { - var _t2088 int64 + var _t2090 int64 if p.matchLookaheadLiteral("export_csv_config", 1) { - _t2088 = 1 + _t2090 = 1 } else { - _t2088 = -1 + _t2090 = -1 } - _t2087 = _t2088 + _t2089 = _t2090 } - _t2086 = _t2087 + _t2088 = _t2089 } else { - _t2086 = -1 + _t2088 = -1 } - prediction1303 := _t2086 - var _t2089 *pb.ExportCSVConfig - if prediction1303 == 1 { + prediction1304 := _t2088 + var _t2091 *pb.ExportCSVConfig + if prediction1304 == 1 { p.consumeLiteral("(") p.consumeLiteral("export_csv_config") - _t2090 := p.parse_export_csv_path() - export_csv_path1307 := _t2090 - _t2091 := p.parse_export_csv_columns_list() - export_csv_columns_list1308 := _t2091 - _t2092 := p.parse_config_dict() - config_dict1309 := _t2092 + _t2092 := p.parse_export_csv_path() + export_csv_path1308 := _t2092 + _t2093 := p.parse_export_csv_columns_list() + export_csv_columns_list1309 := _t2093 + _t2094 := p.parse_config_dict() + config_dict1310 := _t2094 p.consumeLiteral(")") - _t2093 := p.construct_export_csv_config(export_csv_path1307, export_csv_columns_list1308, config_dict1309) - _t2089 = _t2093 + _t2095 := p.construct_export_csv_config(export_csv_path1308, export_csv_columns_list1309, config_dict1310) + _t2091 = _t2095 } else { - var _t2094 *pb.ExportCSVConfig - if prediction1303 == 0 { + var _t2096 *pb.ExportCSVConfig + if prediction1304 == 0 { p.consumeLiteral("(") p.consumeLiteral("export_csv_config_v2") - _t2095 := p.parse_export_csv_path() - export_csv_path1304 := _t2095 - _t2096 := p.parse_export_csv_source() - export_csv_source1305 := _t2096 - _t2097 := p.parse_csv_config() - csv_config1306 := _t2097 + _t2097 := p.parse_export_csv_path() + export_csv_path1305 := _t2097 + _t2098 := p.parse_export_csv_source() + export_csv_source1306 := _t2098 + _t2099 := p.parse_csv_config() + csv_config1307 := _t2099 p.consumeLiteral(")") - _t2098 := p.construct_export_csv_config_with_source(export_csv_path1304, export_csv_source1305, csv_config1306) - _t2094 = _t2098 + _t2100 := p.construct_export_csv_config_with_source(export_csv_path1305, export_csv_source1306, csv_config1307) + _t2096 = _t2100 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in export_csv_config", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t2089 = _t2094 + _t2091 = _t2096 } - result1311 := _t2089 - p.recordSpan(int(span_start1310), "ExportCSVConfig") - return result1311 + result1312 := _t2091 + p.recordSpan(int(span_start1311), "ExportCSVConfig") + return result1312 } func (p *Parser) parse_export_csv_path() string { p.consumeLiteral("(") p.consumeLiteral("path") - string1312 := p.consumeTerminal("STRING").Value.str + string1313 := p.consumeTerminal("STRING").Value.str p.consumeLiteral(")") - return string1312 + return string1313 } func (p *Parser) parse_export_csv_source() *pb.ExportCSVSource { - span_start1319 := int64(p.spanStart()) - var _t2099 int64 + span_start1320 := int64(p.spanStart()) + var _t2101 int64 if p.matchLookaheadLiteral("(", 0) { - var _t2100 int64 + var _t2102 int64 if p.matchLookaheadLiteral("table_def", 1) { - _t2100 = 1 + _t2102 = 1 } else { - var _t2101 int64 + var _t2103 int64 if p.matchLookaheadLiteral("gnf_columns", 1) { - _t2101 = 0 + _t2103 = 0 } else { - _t2101 = -1 + _t2103 = -1 } - _t2100 = _t2101 + _t2102 = _t2103 } - _t2099 = _t2100 + _t2101 = _t2102 } else { - _t2099 = -1 + _t2101 = -1 } - prediction1313 := _t2099 - var _t2102 *pb.ExportCSVSource - if prediction1313 == 1 { + prediction1314 := _t2101 + var _t2104 *pb.ExportCSVSource + if prediction1314 == 1 { p.consumeLiteral("(") p.consumeLiteral("table_def") - _t2103 := p.parse_relation_id() - relation_id1318 := _t2103 + _t2105 := p.parse_relation_id() + relation_id1319 := _t2105 p.consumeLiteral(")") - _t2104 := &pb.ExportCSVSource{} - _t2104.CsvSource = &pb.ExportCSVSource_TableDef{TableDef: relation_id1318} - _t2102 = _t2104 + _t2106 := &pb.ExportCSVSource{} + _t2106.CsvSource = &pb.ExportCSVSource_TableDef{TableDef: relation_id1319} + _t2104 = _t2106 } else { - var _t2105 *pb.ExportCSVSource - if prediction1313 == 0 { + var _t2107 *pb.ExportCSVSource + if prediction1314 == 0 { p.consumeLiteral("(") p.consumeLiteral("gnf_columns") - xs1314 := []*pb.ExportCSVColumn{} - cond1315 := p.matchLookaheadLiteral("(", 0) - for cond1315 { - _t2106 := p.parse_export_csv_column() - item1316 := _t2106 - xs1314 = append(xs1314, item1316) - cond1315 = p.matchLookaheadLiteral("(", 0) + xs1315 := []*pb.ExportCSVColumn{} + cond1316 := p.matchLookaheadLiteral("(", 0) + for cond1316 { + _t2108 := p.parse_export_csv_column() + item1317 := _t2108 + xs1315 = append(xs1315, item1317) + cond1316 = p.matchLookaheadLiteral("(", 0) } - export_csv_columns1317 := xs1314 + export_csv_columns1318 := xs1315 p.consumeLiteral(")") - _t2107 := &pb.ExportCSVColumns{Columns: export_csv_columns1317} - _t2108 := &pb.ExportCSVSource{} - _t2108.CsvSource = &pb.ExportCSVSource_GnfColumns{GnfColumns: _t2107} - _t2105 = _t2108 + _t2109 := &pb.ExportCSVColumns{Columns: export_csv_columns1318} + _t2110 := &pb.ExportCSVSource{} + _t2110.CsvSource = &pb.ExportCSVSource_GnfColumns{GnfColumns: _t2109} + _t2107 = _t2110 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in export_csv_source", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t2102 = _t2105 + _t2104 = _t2107 } - result1320 := _t2102 - p.recordSpan(int(span_start1319), "ExportCSVSource") - return result1320 + result1321 := _t2104 + p.recordSpan(int(span_start1320), "ExportCSVSource") + return result1321 } func (p *Parser) parse_export_csv_column() *pb.ExportCSVColumn { - span_start1323 := int64(p.spanStart()) + span_start1324 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("column") - string1321 := p.consumeTerminal("STRING").Value.str - _t2109 := p.parse_relation_id() - relation_id1322 := _t2109 + string1322 := p.consumeTerminal("STRING").Value.str + _t2111 := p.parse_relation_id() + relation_id1323 := _t2111 p.consumeLiteral(")") - _t2110 := &pb.ExportCSVColumn{ColumnName: string1321, ColumnData: relation_id1322} - result1324 := _t2110 - p.recordSpan(int(span_start1323), "ExportCSVColumn") - return result1324 + _t2112 := &pb.ExportCSVColumn{ColumnName: string1322, ColumnData: relation_id1323} + result1325 := _t2112 + p.recordSpan(int(span_start1324), "ExportCSVColumn") + return result1325 } func (p *Parser) parse_export_csv_columns_list() []*pb.ExportCSVColumn { p.consumeLiteral("(") p.consumeLiteral("columns") - xs1325 := []*pb.ExportCSVColumn{} - cond1326 := p.matchLookaheadLiteral("(", 0) - for cond1326 { - _t2111 := p.parse_export_csv_column() - item1327 := _t2111 - xs1325 = append(xs1325, item1327) - cond1326 = p.matchLookaheadLiteral("(", 0) - } - export_csv_columns1328 := xs1325 + xs1326 := []*pb.ExportCSVColumn{} + cond1327 := p.matchLookaheadLiteral("(", 0) + for cond1327 { + _t2113 := p.parse_export_csv_column() + item1328 := _t2113 + xs1326 = append(xs1326, item1328) + cond1327 = p.matchLookaheadLiteral("(", 0) + } + export_csv_columns1329 := xs1326 p.consumeLiteral(")") - return export_csv_columns1328 + return export_csv_columns1329 } func (p *Parser) parse_export_iceberg_config() *pb.ExportIcebergConfig { - span_start1334 := int64(p.spanStart()) + span_start1335 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("export_iceberg_config") - _t2112 := p.parse_iceberg_locator() - iceberg_locator1329 := _t2112 - _t2113 := p.parse_iceberg_catalog_config() - iceberg_catalog_config1330 := _t2113 - _t2114 := p.parse_export_iceberg_table_def() - export_iceberg_table_def1331 := _t2114 - _t2115 := p.parse_iceberg_table_properties() - iceberg_table_properties1332 := _t2115 - var _t2116 [][]interface{} + _t2114 := p.parse_iceberg_locator() + iceberg_locator1330 := _t2114 + _t2115 := p.parse_iceberg_catalog_config() + iceberg_catalog_config1331 := _t2115 + _t2116 := p.parse_export_iceberg_table_def() + export_iceberg_table_def1332 := _t2116 + _t2117 := p.parse_iceberg_table_properties() + iceberg_table_properties1333 := _t2117 + var _t2118 [][]interface{} if p.matchLookaheadLiteral("{", 0) { - _t2117 := p.parse_config_dict() - _t2116 = _t2117 + _t2119 := p.parse_config_dict() + _t2118 = _t2119 } - config_dict1333 := _t2116 + config_dict1334 := _t2118 p.consumeLiteral(")") - _t2118 := p.construct_export_iceberg_config_full(iceberg_locator1329, iceberg_catalog_config1330, export_iceberg_table_def1331, iceberg_table_properties1332, config_dict1333) - result1335 := _t2118 - p.recordSpan(int(span_start1334), "ExportIcebergConfig") - return result1335 + _t2120 := p.construct_export_iceberg_config_full(iceberg_locator1330, iceberg_catalog_config1331, export_iceberg_table_def1332, iceberg_table_properties1333, config_dict1334) + result1336 := _t2120 + p.recordSpan(int(span_start1335), "ExportIcebergConfig") + return result1336 } func (p *Parser) parse_export_iceberg_table_def() *pb.RelationId { - span_start1337 := int64(p.spanStart()) + span_start1338 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("table_def") - _t2119 := p.parse_relation_id() - relation_id1336 := _t2119 + _t2121 := p.parse_relation_id() + relation_id1337 := _t2121 p.consumeLiteral(")") - result1338 := relation_id1336 - p.recordSpan(int(span_start1337), "RelationId") - return result1338 + result1339 := relation_id1337 + p.recordSpan(int(span_start1338), "RelationId") + return result1339 } func (p *Parser) parse_iceberg_table_properties() [][]interface{} { p.consumeLiteral("(") p.consumeLiteral("table_properties") - xs1339 := [][]interface{}{} - cond1340 := p.matchLookaheadLiteral("(", 0) - for cond1340 { - _t2120 := p.parse_iceberg_property_entry() - item1341 := _t2120 - xs1339 = append(xs1339, item1341) - cond1340 = p.matchLookaheadLiteral("(", 0) - } - iceberg_property_entrys1342 := xs1339 + xs1340 := [][]interface{}{} + cond1341 := p.matchLookaheadLiteral("(", 0) + for cond1341 { + _t2122 := p.parse_iceberg_property_entry() + item1342 := _t2122 + xs1340 = append(xs1340, item1342) + cond1341 = p.matchLookaheadLiteral("(", 0) + } + iceberg_property_entrys1343 := xs1340 p.consumeLiteral(")") - return iceberg_property_entrys1342 + return iceberg_property_entrys1343 } func (p *Parser) parse_export_output() *pb.ExportOutput { - span_start1344 := int64(p.spanStart()) + span_start1346 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("export_output") - _t2121 := p.parse_export_csv_output() - export_csv_output1343 := _t2121 + _t2123 := p.parse_name() + name1344 := _t2123 + _t2124 := p.parse_export_csv_output() + export_csv_output1345 := _t2124 p.consumeLiteral(")") - _t2122 := &pb.ExportOutput{} - _t2122.ExportOutput = &pb.ExportOutput_Csv{Csv: export_csv_output1343} - result1345 := _t2122 - p.recordSpan(int(span_start1344), "ExportOutput") - return result1345 + _t2125 := &pb.ExportOutput{Name: name1344} + _t2125.ExportOutput = &pb.ExportOutput_Csv{Csv: export_csv_output1345} + result1347 := _t2125 + p.recordSpan(int(span_start1346), "ExportOutput") + return result1347 } func (p *Parser) parse_export_csv_output() *pb.ExportCSVOutput { - span_start1348 := int64(p.spanStart()) + span_start1350 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("csv") - _t2123 := p.parse_export_csv_source() - export_csv_source1346 := _t2123 - _t2124 := p.parse_csv_config() - csv_config1347 := _t2124 + _t2126 := p.parse_export_csv_source() + export_csv_source1348 := _t2126 + _t2127 := p.parse_csv_config() + csv_config1349 := _t2127 p.consumeLiteral(")") - _t2125 := &pb.ExportCSVOutput{CsvSource: export_csv_source1346, CsvConfig: csv_config1347} - result1349 := _t2125 - p.recordSpan(int(span_start1348), "ExportCSVOutput") - return result1349 + _t2128 := &pb.ExportCSVOutput{CsvSource: export_csv_source1348, CsvConfig: csv_config1349} + result1351 := _t2128 + p.recordSpan(int(span_start1350), "ExportCSVOutput") + return result1351 } diff --git a/sdks/go/src/pretty.go b/sdks/go/src/pretty.go index b0e3cb3f..b49d3d61 100644 --- a/sdks/go/src/pretty.go +++ b/sdks/go/src/pretty.go @@ -343,188 +343,188 @@ func formatBool(b bool) string { // --- Helper functions --- func (p *PrettyPrinter) _make_value_int32(v int32) *pb.Value { - _t1764 := &pb.Value{} - _t1764.Value = &pb.Value_Int32Value{Int32Value: v} - return _t1764 + _t1768 := &pb.Value{} + _t1768.Value = &pb.Value_Int32Value{Int32Value: v} + return _t1768 } func (p *PrettyPrinter) _make_value_int64(v int64) *pb.Value { - _t1765 := &pb.Value{} - _t1765.Value = &pb.Value_IntValue{IntValue: v} - return _t1765 + _t1769 := &pb.Value{} + _t1769.Value = &pb.Value_IntValue{IntValue: v} + return _t1769 } func (p *PrettyPrinter) _make_value_float64(v float64) *pb.Value { - _t1766 := &pb.Value{} - _t1766.Value = &pb.Value_FloatValue{FloatValue: v} - return _t1766 + _t1770 := &pb.Value{} + _t1770.Value = &pb.Value_FloatValue{FloatValue: v} + return _t1770 } func (p *PrettyPrinter) _make_value_string(v string) *pb.Value { - _t1767 := &pb.Value{} - _t1767.Value = &pb.Value_StringValue{StringValue: v} - return _t1767 + _t1771 := &pb.Value{} + _t1771.Value = &pb.Value_StringValue{StringValue: v} + return _t1771 } func (p *PrettyPrinter) _make_value_boolean(v bool) *pb.Value { - _t1768 := &pb.Value{} - _t1768.Value = &pb.Value_BooleanValue{BooleanValue: v} - return _t1768 + _t1772 := &pb.Value{} + _t1772.Value = &pb.Value_BooleanValue{BooleanValue: v} + return _t1772 } func (p *PrettyPrinter) _make_value_uint128(v *pb.UInt128Value) *pb.Value { - _t1769 := &pb.Value{} - _t1769.Value = &pb.Value_Uint128Value{Uint128Value: v} - return _t1769 + _t1773 := &pb.Value{} + _t1773.Value = &pb.Value_Uint128Value{Uint128Value: v} + return _t1773 } func (p *PrettyPrinter) deconstruct_configure(msg *pb.Configure) [][]interface{} { result := [][]interface{}{} if msg.GetIvmConfig().GetLevel() == pb.MaintenanceLevel_MAINTENANCE_LEVEL_AUTO { - _t1770 := p._make_value_string("auto") - result = append(result, []interface{}{"ivm.maintenance_level", _t1770}) + _t1774 := p._make_value_string("auto") + result = append(result, []interface{}{"ivm.maintenance_level", _t1774}) } else { if msg.GetIvmConfig().GetLevel() == pb.MaintenanceLevel_MAINTENANCE_LEVEL_ALL { - _t1771 := p._make_value_string("all") - result = append(result, []interface{}{"ivm.maintenance_level", _t1771}) + _t1775 := p._make_value_string("all") + result = append(result, []interface{}{"ivm.maintenance_level", _t1775}) } else { if msg.GetIvmConfig().GetLevel() == pb.MaintenanceLevel_MAINTENANCE_LEVEL_OFF { - _t1772 := p._make_value_string("off") - result = append(result, []interface{}{"ivm.maintenance_level", _t1772}) + _t1776 := p._make_value_string("off") + result = append(result, []interface{}{"ivm.maintenance_level", _t1776}) } } } - _t1773 := p._make_value_int64(msg.GetSemanticsVersion()) - result = append(result, []interface{}{"semantics_version", _t1773}) + _t1777 := p._make_value_int64(msg.GetSemanticsVersion()) + result = append(result, []interface{}{"semantics_version", _t1777}) return listSort(result) } func (p *PrettyPrinter) deconstruct_csv_config(msg *pb.CSVConfig) [][]interface{} { result := [][]interface{}{} - _t1774 := p._make_value_int32(msg.GetHeaderRow()) - result = append(result, []interface{}{"csv_header_row", _t1774}) - _t1775 := p._make_value_int64(msg.GetSkip()) - result = append(result, []interface{}{"csv_skip", _t1775}) + _t1778 := p._make_value_int32(msg.GetHeaderRow()) + result = append(result, []interface{}{"csv_header_row", _t1778}) + _t1779 := p._make_value_int64(msg.GetSkip()) + result = append(result, []interface{}{"csv_skip", _t1779}) if msg.GetNewLine() != "" { - _t1776 := p._make_value_string(msg.GetNewLine()) - result = append(result, []interface{}{"csv_new_line", _t1776}) - } - _t1777 := p._make_value_string(msg.GetDelimiter()) - result = append(result, []interface{}{"csv_delimiter", _t1777}) - _t1778 := p._make_value_string(msg.GetQuotechar()) - result = append(result, []interface{}{"csv_quotechar", _t1778}) - _t1779 := p._make_value_string(msg.GetEscapechar()) - result = append(result, []interface{}{"csv_escapechar", _t1779}) + _t1780 := p._make_value_string(msg.GetNewLine()) + result = append(result, []interface{}{"csv_new_line", _t1780}) + } + _t1781 := p._make_value_string(msg.GetDelimiter()) + result = append(result, []interface{}{"csv_delimiter", _t1781}) + _t1782 := p._make_value_string(msg.GetQuotechar()) + result = append(result, []interface{}{"csv_quotechar", _t1782}) + _t1783 := p._make_value_string(msg.GetEscapechar()) + result = append(result, []interface{}{"csv_escapechar", _t1783}) if msg.GetComment() != "" { - _t1780 := p._make_value_string(msg.GetComment()) - result = append(result, []interface{}{"csv_comment", _t1780}) + _t1784 := p._make_value_string(msg.GetComment()) + result = append(result, []interface{}{"csv_comment", _t1784}) } for _, missing_string := range msg.GetMissingStrings() { - _t1781 := p._make_value_string(missing_string) - result = append(result, []interface{}{"csv_missing_strings", _t1781}) - } - _t1782 := p._make_value_string(msg.GetDecimalSeparator()) - result = append(result, []interface{}{"csv_decimal_separator", _t1782}) - _t1783 := p._make_value_string(msg.GetEncoding()) - result = append(result, []interface{}{"csv_encoding", _t1783}) - _t1784 := p._make_value_string(msg.GetCompression()) - result = append(result, []interface{}{"csv_compression", _t1784}) + _t1785 := p._make_value_string(missing_string) + result = append(result, []interface{}{"csv_missing_strings", _t1785}) + } + _t1786 := p._make_value_string(msg.GetDecimalSeparator()) + result = append(result, []interface{}{"csv_decimal_separator", _t1786}) + _t1787 := p._make_value_string(msg.GetEncoding()) + result = append(result, []interface{}{"csv_encoding", _t1787}) + _t1788 := p._make_value_string(msg.GetCompression()) + result = append(result, []interface{}{"csv_compression", _t1788}) if msg.GetPartitionSizeMb() != 0 { - _t1785 := p._make_value_int64(msg.GetPartitionSizeMb()) - result = append(result, []interface{}{"csv_partition_size_mb", _t1785}) + _t1789 := p._make_value_int64(msg.GetPartitionSizeMb()) + result = append(result, []interface{}{"csv_partition_size_mb", _t1789}) } return listSort(result) } func (p *PrettyPrinter) deconstruct_csv_storage_integration_optional(msg *pb.CSVConfig) [][]interface{} { - var _t1786 interface{} + var _t1790 interface{} if !(hasProtoField(msg, "storage_integration")) { return nil } - _ = _t1786 + _ = _t1790 si := msg.GetStorageIntegration() result := [][]interface{}{} if si.GetProvider() != "" { - _t1787 := p._make_value_string(si.GetProvider()) - result = append(result, []interface{}{"provider", _t1787}) + _t1791 := p._make_value_string(si.GetProvider()) + result = append(result, []interface{}{"provider", _t1791}) } if si.GetAzureSasToken() != "" { - _t1788 := p._make_value_string("***") - result = append(result, []interface{}{"azure_sas_token", _t1788}) + _t1792 := p._make_value_string("***") + result = append(result, []interface{}{"azure_sas_token", _t1792}) } if si.GetS3Region() != "" { - _t1789 := p._make_value_string(si.GetS3Region()) - result = append(result, []interface{}{"s3_region", _t1789}) + _t1793 := p._make_value_string(si.GetS3Region()) + result = append(result, []interface{}{"s3_region", _t1793}) } if si.GetS3AccessKeyId() != "" { - _t1790 := p._make_value_string("***") - result = append(result, []interface{}{"s3_access_key_id", _t1790}) + _t1794 := p._make_value_string("***") + result = append(result, []interface{}{"s3_access_key_id", _t1794}) } if si.GetS3SecretAccessKey() != "" { - _t1791 := p._make_value_string("***") - result = append(result, []interface{}{"s3_secret_access_key", _t1791}) + _t1795 := p._make_value_string("***") + result = append(result, []interface{}{"s3_secret_access_key", _t1795}) } return listSort(result) } func (p *PrettyPrinter) deconstruct_betree_info_config(msg *pb.BeTreeInfo) [][]interface{} { result := [][]interface{}{} - _t1792 := p._make_value_float64(msg.GetStorageConfig().GetEpsilon()) - result = append(result, []interface{}{"betree_config_epsilon", _t1792}) - _t1793 := p._make_value_int64(msg.GetStorageConfig().GetMaxPivots()) - result = append(result, []interface{}{"betree_config_max_pivots", _t1793}) - _t1794 := p._make_value_int64(msg.GetStorageConfig().GetMaxDeltas()) - result = append(result, []interface{}{"betree_config_max_deltas", _t1794}) - _t1795 := p._make_value_int64(msg.GetStorageConfig().GetMaxLeaf()) - result = append(result, []interface{}{"betree_config_max_leaf", _t1795}) + _t1796 := p._make_value_float64(msg.GetStorageConfig().GetEpsilon()) + result = append(result, []interface{}{"betree_config_epsilon", _t1796}) + _t1797 := p._make_value_int64(msg.GetStorageConfig().GetMaxPivots()) + result = append(result, []interface{}{"betree_config_max_pivots", _t1797}) + _t1798 := p._make_value_int64(msg.GetStorageConfig().GetMaxDeltas()) + result = append(result, []interface{}{"betree_config_max_deltas", _t1798}) + _t1799 := p._make_value_int64(msg.GetStorageConfig().GetMaxLeaf()) + result = append(result, []interface{}{"betree_config_max_leaf", _t1799}) if hasProtoField(msg.GetRelationLocator(), "root_pageid") { if msg.GetRelationLocator().GetRootPageid() != nil { - _t1796 := p._make_value_uint128(msg.GetRelationLocator().GetRootPageid()) - result = append(result, []interface{}{"betree_locator_root_pageid", _t1796}) + _t1800 := p._make_value_uint128(msg.GetRelationLocator().GetRootPageid()) + result = append(result, []interface{}{"betree_locator_root_pageid", _t1800}) } } if hasProtoField(msg.GetRelationLocator(), "inline_data") { if msg.GetRelationLocator().GetInlineData() != nil { - _t1797 := p._make_value_string(string(msg.GetRelationLocator().GetInlineData())) - result = append(result, []interface{}{"betree_locator_inline_data", _t1797}) + _t1801 := p._make_value_string(string(msg.GetRelationLocator().GetInlineData())) + result = append(result, []interface{}{"betree_locator_inline_data", _t1801}) } } - _t1798 := p._make_value_int64(msg.GetRelationLocator().GetElementCount()) - result = append(result, []interface{}{"betree_locator_element_count", _t1798}) - _t1799 := p._make_value_int64(msg.GetRelationLocator().GetTreeHeight()) - result = append(result, []interface{}{"betree_locator_tree_height", _t1799}) + _t1802 := p._make_value_int64(msg.GetRelationLocator().GetElementCount()) + result = append(result, []interface{}{"betree_locator_element_count", _t1802}) + _t1803 := p._make_value_int64(msg.GetRelationLocator().GetTreeHeight()) + result = append(result, []interface{}{"betree_locator_tree_height", _t1803}) return listSort(result) } func (p *PrettyPrinter) deconstruct_export_csv_config(msg *pb.ExportCSVConfig) [][]interface{} { result := [][]interface{}{} if msg.PartitionSize != nil { - _t1800 := p._make_value_int64(*msg.PartitionSize) - result = append(result, []interface{}{"partition_size", _t1800}) + _t1804 := p._make_value_int64(*msg.PartitionSize) + result = append(result, []interface{}{"partition_size", _t1804}) } if msg.Compression != nil { - _t1801 := p._make_value_string(*msg.Compression) - result = append(result, []interface{}{"compression", _t1801}) + _t1805 := p._make_value_string(*msg.Compression) + result = append(result, []interface{}{"compression", _t1805}) } if msg.SyntaxHeaderRow != nil { - _t1802 := p._make_value_boolean(*msg.SyntaxHeaderRow) - result = append(result, []interface{}{"syntax_header_row", _t1802}) + _t1806 := p._make_value_boolean(*msg.SyntaxHeaderRow) + result = append(result, []interface{}{"syntax_header_row", _t1806}) } if msg.SyntaxMissingString != nil { - _t1803 := p._make_value_string(*msg.SyntaxMissingString) - result = append(result, []interface{}{"syntax_missing_string", _t1803}) + _t1807 := p._make_value_string(*msg.SyntaxMissingString) + result = append(result, []interface{}{"syntax_missing_string", _t1807}) } if msg.SyntaxDelim != nil { - _t1804 := p._make_value_string(*msg.SyntaxDelim) - result = append(result, []interface{}{"syntax_delim", _t1804}) + _t1808 := p._make_value_string(*msg.SyntaxDelim) + result = append(result, []interface{}{"syntax_delim", _t1808}) } if msg.SyntaxQuotechar != nil { - _t1805 := p._make_value_string(*msg.SyntaxQuotechar) - result = append(result, []interface{}{"syntax_quotechar", _t1805}) + _t1809 := p._make_value_string(*msg.SyntaxQuotechar) + result = append(result, []interface{}{"syntax_quotechar", _t1809}) } if msg.SyntaxEscapechar != nil { - _t1806 := p._make_value_string(*msg.SyntaxEscapechar) - result = append(result, []interface{}{"syntax_escapechar", _t1806}) + _t1810 := p._make_value_string(*msg.SyntaxEscapechar) + result = append(result, []interface{}{"syntax_escapechar", _t1810}) } return listSort(result) } @@ -534,51 +534,51 @@ func (p *PrettyPrinter) mask_secret_value(pair []interface{}) string { } func (p *PrettyPrinter) deconstruct_iceberg_catalog_config_scope_optional(msg *pb.IcebergCatalogConfig) *string { - var _t1807 interface{} + var _t1811 interface{} if *msg.Scope != "" { return ptr(*msg.Scope) } - _ = _t1807 + _ = _t1811 return nil } func (p *PrettyPrinter) deconstruct_iceberg_data_from_snapshot_optional(msg *pb.IcebergData) *string { - var _t1808 interface{} + var _t1812 interface{} if *msg.FromSnapshot != "" { return ptr(*msg.FromSnapshot) } - _ = _t1808 + _ = _t1812 return nil } func (p *PrettyPrinter) deconstruct_iceberg_data_to_snapshot_optional(msg *pb.IcebergData) *string { - var _t1809 interface{} + var _t1813 interface{} if *msg.ToSnapshot != "" { return ptr(*msg.ToSnapshot) } - _ = _t1809 + _ = _t1813 return nil } func (p *PrettyPrinter) deconstruct_export_iceberg_config_optional(msg *pb.ExportIcebergConfig) [][]interface{} { result := [][]interface{}{} if *msg.Prefix != "" { - _t1810 := p._make_value_string(*msg.Prefix) - result = append(result, []interface{}{"prefix", _t1810}) + _t1814 := p._make_value_string(*msg.Prefix) + result = append(result, []interface{}{"prefix", _t1814}) } if *msg.TargetFileSizeBytes != 0 { - _t1811 := p._make_value_int64(*msg.TargetFileSizeBytes) - result = append(result, []interface{}{"target_file_size_bytes", _t1811}) + _t1815 := p._make_value_int64(*msg.TargetFileSizeBytes) + result = append(result, []interface{}{"target_file_size_bytes", _t1815}) } if msg.GetCompression() != "" { - _t1812 := p._make_value_string(msg.GetCompression()) - result = append(result, []interface{}{"compression", _t1812}) + _t1816 := p._make_value_string(msg.GetCompression()) + result = append(result, []interface{}{"compression", _t1816}) } - var _t1813 interface{} + var _t1817 interface{} if int64(len(result)) == 0 { return nil } - _ = _t1813 + _ = _t1817 return listSort(result) } @@ -589,11 +589,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 _t1814 interface{} + var _t1818 interface{} if name == nil { return p.relationIdToUint128(msg) } - _ = _t1814 + _ = _t1818 return nil } @@ -611,45 +611,45 @@ func (p *PrettyPrinter) deconstruct_bindings_with_arity(abs *pb.Abstraction, val // --- Pretty-print methods --- func (p *PrettyPrinter) pretty_transaction(msg *pb.Transaction) interface{} { - flat818 := p.tryFlat(msg, func() { p.pretty_transaction(msg) }) - if flat818 != nil { - p.write(*flat818) + flat820 := p.tryFlat(msg, func() { p.pretty_transaction(msg) }) + if flat820 != nil { + p.write(*flat820) return nil } else { _dollar_dollar := msg - var _t1618 *pb.Configure + var _t1622 *pb.Configure if hasProtoField(_dollar_dollar, "configure") { - _t1618 = _dollar_dollar.GetConfigure() + _t1622 = _dollar_dollar.GetConfigure() } - var _t1619 *pb.Sync + var _t1623 *pb.Sync if hasProtoField(_dollar_dollar, "sync") { - _t1619 = _dollar_dollar.GetSync() + _t1623 = _dollar_dollar.GetSync() } - fields809 := []interface{}{_t1618, _t1619, _dollar_dollar.GetEpochs()} - unwrapped_fields810 := fields809 + fields811 := []interface{}{_t1622, _t1623, _dollar_dollar.GetEpochs()} + unwrapped_fields812 := fields811 p.write("(") p.write("transaction") p.indentSexp() - field811 := unwrapped_fields810[0].(*pb.Configure) - if field811 != nil { - p.newline() - opt_val812 := field811 - p.pretty_configure(opt_val812) - } - field813 := unwrapped_fields810[1].(*pb.Sync) + field813 := unwrapped_fields812[0].(*pb.Configure) if field813 != nil { p.newline() opt_val814 := field813 - p.pretty_sync(opt_val814) + p.pretty_configure(opt_val814) } - field815 := unwrapped_fields810[2].([]*pb.Epoch) - if !(len(field815) == 0) { + field815 := unwrapped_fields812[1].(*pb.Sync) + if field815 != nil { p.newline() - for i817, elem816 := range field815 { - if (i817 > 0) { + opt_val816 := field815 + p.pretty_sync(opt_val816) + } + field817 := unwrapped_fields812[2].([]*pb.Epoch) + if !(len(field817) == 0) { + p.newline() + for i819, elem818 := range field817 { + if (i819 > 0) { p.newline() } - p.pretty_epoch(elem816) + p.pretty_epoch(elem818) } } p.dedent() @@ -659,20 +659,20 @@ func (p *PrettyPrinter) pretty_transaction(msg *pb.Transaction) interface{} { } func (p *PrettyPrinter) pretty_configure(msg *pb.Configure) interface{} { - flat821 := p.tryFlat(msg, func() { p.pretty_configure(msg) }) - if flat821 != nil { - p.write(*flat821) + flat823 := p.tryFlat(msg, func() { p.pretty_configure(msg) }) + if flat823 != nil { + p.write(*flat823) return nil } else { _dollar_dollar := msg - _t1620 := p.deconstruct_configure(_dollar_dollar) - fields819 := _t1620 - unwrapped_fields820 := fields819 + _t1624 := p.deconstruct_configure(_dollar_dollar) + fields821 := _t1624 + unwrapped_fields822 := fields821 p.write("(") p.write("configure") p.indentSexp() p.newline() - p.pretty_config_dict(unwrapped_fields820) + p.pretty_config_dict(unwrapped_fields822) p.dedent() p.write(")") } @@ -680,21 +680,21 @@ func (p *PrettyPrinter) pretty_configure(msg *pb.Configure) interface{} { } func (p *PrettyPrinter) pretty_config_dict(msg [][]interface{}) interface{} { - flat825 := p.tryFlat(msg, func() { p.pretty_config_dict(msg) }) - if flat825 != nil { - p.write(*flat825) + flat827 := p.tryFlat(msg, func() { p.pretty_config_dict(msg) }) + if flat827 != nil { + p.write(*flat827) return nil } else { - fields822 := msg + fields824 := msg p.write("{") p.indent() - if !(len(fields822) == 0) { + if !(len(fields824) == 0) { p.newline() - for i824, elem823 := range fields822 { - if (i824 > 0) { + for i826, elem825 := range fields824 { + if (i826 > 0) { p.newline() } - p.pretty_config_key_value(elem823) + p.pretty_config_key_value(elem825) } } p.dedent() @@ -704,152 +704,152 @@ func (p *PrettyPrinter) pretty_config_dict(msg [][]interface{}) interface{} { } func (p *PrettyPrinter) pretty_config_key_value(msg []interface{}) interface{} { - flat830 := p.tryFlat(msg, func() { p.pretty_config_key_value(msg) }) - if flat830 != nil { - p.write(*flat830) + flat832 := p.tryFlat(msg, func() { p.pretty_config_key_value(msg) }) + if flat832 != nil { + p.write(*flat832) return nil } else { _dollar_dollar := msg - fields826 := []interface{}{_dollar_dollar[0].(string), _dollar_dollar[1].(*pb.Value)} - unwrapped_fields827 := fields826 + fields828 := []interface{}{_dollar_dollar[0].(string), _dollar_dollar[1].(*pb.Value)} + unwrapped_fields829 := fields828 p.write(":") - field828 := unwrapped_fields827[0].(string) - p.write(field828) + field830 := unwrapped_fields829[0].(string) + p.write(field830) p.write(" ") - field829 := unwrapped_fields827[1].(*pb.Value) - p.pretty_raw_value(field829) + field831 := unwrapped_fields829[1].(*pb.Value) + p.pretty_raw_value(field831) } return nil } func (p *PrettyPrinter) pretty_raw_value(msg *pb.Value) interface{} { - flat856 := p.tryFlat(msg, func() { p.pretty_raw_value(msg) }) - if flat856 != nil { - p.write(*flat856) + flat858 := p.tryFlat(msg, func() { p.pretty_raw_value(msg) }) + if flat858 != nil { + p.write(*flat858) return nil } else { _dollar_dollar := msg - var _t1621 *pb.DateValue + var _t1625 *pb.DateValue if hasProtoField(_dollar_dollar, "date_value") { - _t1621 = _dollar_dollar.GetDateValue() + _t1625 = _dollar_dollar.GetDateValue() } - deconstruct_result854 := _t1621 - if deconstruct_result854 != nil { - unwrapped855 := deconstruct_result854 - p.pretty_raw_date(unwrapped855) + deconstruct_result856 := _t1625 + if deconstruct_result856 != nil { + unwrapped857 := deconstruct_result856 + p.pretty_raw_date(unwrapped857) } else { _dollar_dollar := msg - var _t1622 *pb.DateTimeValue + var _t1626 *pb.DateTimeValue if hasProtoField(_dollar_dollar, "datetime_value") { - _t1622 = _dollar_dollar.GetDatetimeValue() + _t1626 = _dollar_dollar.GetDatetimeValue() } - deconstruct_result852 := _t1622 - if deconstruct_result852 != nil { - unwrapped853 := deconstruct_result852 - p.pretty_raw_datetime(unwrapped853) + deconstruct_result854 := _t1626 + if deconstruct_result854 != nil { + unwrapped855 := deconstruct_result854 + p.pretty_raw_datetime(unwrapped855) } else { _dollar_dollar := msg - var _t1623 *string + var _t1627 *string if hasProtoField(_dollar_dollar, "string_value") { - _t1623 = ptr(_dollar_dollar.GetStringValue()) + _t1627 = ptr(_dollar_dollar.GetStringValue()) } - deconstruct_result850 := _t1623 - if deconstruct_result850 != nil { - unwrapped851 := *deconstruct_result850 - p.write(p.formatStringValue(unwrapped851)) + deconstruct_result852 := _t1627 + if deconstruct_result852 != nil { + unwrapped853 := *deconstruct_result852 + p.write(p.formatStringValue(unwrapped853)) } else { _dollar_dollar := msg - var _t1624 *int32 + var _t1628 *int32 if hasProtoField(_dollar_dollar, "int32_value") { - _t1624 = ptr(_dollar_dollar.GetInt32Value()) + _t1628 = ptr(_dollar_dollar.GetInt32Value()) } - deconstruct_result848 := _t1624 - if deconstruct_result848 != nil { - unwrapped849 := *deconstruct_result848 - p.write(fmt.Sprintf("%di32", unwrapped849)) + deconstruct_result850 := _t1628 + if deconstruct_result850 != nil { + unwrapped851 := *deconstruct_result850 + p.write(fmt.Sprintf("%di32", unwrapped851)) } else { _dollar_dollar := msg - var _t1625 *int64 + var _t1629 *int64 if hasProtoField(_dollar_dollar, "int_value") { - _t1625 = ptr(_dollar_dollar.GetIntValue()) + _t1629 = ptr(_dollar_dollar.GetIntValue()) } - deconstruct_result846 := _t1625 - if deconstruct_result846 != nil { - unwrapped847 := *deconstruct_result846 - p.write(fmt.Sprintf("%d", unwrapped847)) + deconstruct_result848 := _t1629 + if deconstruct_result848 != nil { + unwrapped849 := *deconstruct_result848 + p.write(fmt.Sprintf("%d", unwrapped849)) } else { _dollar_dollar := msg - var _t1626 *float32 + var _t1630 *float32 if hasProtoField(_dollar_dollar, "float32_value") { - _t1626 = ptr(_dollar_dollar.GetFloat32Value()) + _t1630 = ptr(_dollar_dollar.GetFloat32Value()) } - deconstruct_result844 := _t1626 - if deconstruct_result844 != nil { - unwrapped845 := *deconstruct_result844 - p.write(formatFloat32(unwrapped845)) + deconstruct_result846 := _t1630 + if deconstruct_result846 != nil { + unwrapped847 := *deconstruct_result846 + p.write(formatFloat32(unwrapped847)) } else { _dollar_dollar := msg - var _t1627 *float64 + var _t1631 *float64 if hasProtoField(_dollar_dollar, "float_value") { - _t1627 = ptr(_dollar_dollar.GetFloatValue()) + _t1631 = ptr(_dollar_dollar.GetFloatValue()) } - deconstruct_result842 := _t1627 - if deconstruct_result842 != nil { - unwrapped843 := *deconstruct_result842 - p.write(formatFloat64(unwrapped843)) + deconstruct_result844 := _t1631 + if deconstruct_result844 != nil { + unwrapped845 := *deconstruct_result844 + p.write(formatFloat64(unwrapped845)) } else { _dollar_dollar := msg - var _t1628 *uint32 + var _t1632 *uint32 if hasProtoField(_dollar_dollar, "uint32_value") { - _t1628 = ptr(_dollar_dollar.GetUint32Value()) + _t1632 = ptr(_dollar_dollar.GetUint32Value()) } - deconstruct_result840 := _t1628 - if deconstruct_result840 != nil { - unwrapped841 := *deconstruct_result840 - p.write(fmt.Sprintf("%du32", unwrapped841)) + deconstruct_result842 := _t1632 + if deconstruct_result842 != nil { + unwrapped843 := *deconstruct_result842 + p.write(fmt.Sprintf("%du32", unwrapped843)) } else { _dollar_dollar := msg - var _t1629 *pb.UInt128Value + var _t1633 *pb.UInt128Value if hasProtoField(_dollar_dollar, "uint128_value") { - _t1629 = _dollar_dollar.GetUint128Value() + _t1633 = _dollar_dollar.GetUint128Value() } - deconstruct_result838 := _t1629 - if deconstruct_result838 != nil { - unwrapped839 := deconstruct_result838 - p.write(p.formatUint128(unwrapped839)) + deconstruct_result840 := _t1633 + if deconstruct_result840 != nil { + unwrapped841 := deconstruct_result840 + p.write(p.formatUint128(unwrapped841)) } else { _dollar_dollar := msg - var _t1630 *pb.Int128Value + var _t1634 *pb.Int128Value if hasProtoField(_dollar_dollar, "int128_value") { - _t1630 = _dollar_dollar.GetInt128Value() + _t1634 = _dollar_dollar.GetInt128Value() } - deconstruct_result836 := _t1630 - if deconstruct_result836 != nil { - unwrapped837 := deconstruct_result836 - p.write(p.formatInt128(unwrapped837)) + deconstruct_result838 := _t1634 + if deconstruct_result838 != nil { + unwrapped839 := deconstruct_result838 + p.write(p.formatInt128(unwrapped839)) } else { _dollar_dollar := msg - var _t1631 *pb.DecimalValue + var _t1635 *pb.DecimalValue if hasProtoField(_dollar_dollar, "decimal_value") { - _t1631 = _dollar_dollar.GetDecimalValue() + _t1635 = _dollar_dollar.GetDecimalValue() } - deconstruct_result834 := _t1631 - if deconstruct_result834 != nil { - unwrapped835 := deconstruct_result834 - p.write(p.formatDecimal(unwrapped835)) + deconstruct_result836 := _t1635 + if deconstruct_result836 != nil { + unwrapped837 := deconstruct_result836 + p.write(p.formatDecimal(unwrapped837)) } else { _dollar_dollar := msg - var _t1632 *bool + var _t1636 *bool if hasProtoField(_dollar_dollar, "boolean_value") { - _t1632 = ptr(_dollar_dollar.GetBooleanValue()) + _t1636 = ptr(_dollar_dollar.GetBooleanValue()) } - deconstruct_result832 := _t1632 - if deconstruct_result832 != nil { - unwrapped833 := *deconstruct_result832 - p.pretty_boolean_value(unwrapped833) + deconstruct_result834 := _t1636 + if deconstruct_result834 != nil { + unwrapped835 := *deconstruct_result834 + p.pretty_boolean_value(unwrapped835) } else { - fields831 := msg - _ = fields831 + fields833 := msg + _ = fields833 p.write("missing") } } @@ -868,26 +868,26 @@ func (p *PrettyPrinter) pretty_raw_value(msg *pb.Value) interface{} { } func (p *PrettyPrinter) pretty_raw_date(msg *pb.DateValue) interface{} { - flat862 := p.tryFlat(msg, func() { p.pretty_raw_date(msg) }) - if flat862 != nil { - p.write(*flat862) + flat864 := p.tryFlat(msg, func() { p.pretty_raw_date(msg) }) + if flat864 != nil { + p.write(*flat864) return nil } else { _dollar_dollar := msg - fields857 := []interface{}{int64(_dollar_dollar.GetYear()), int64(_dollar_dollar.GetMonth()), int64(_dollar_dollar.GetDay())} - unwrapped_fields858 := fields857 + fields859 := []interface{}{int64(_dollar_dollar.GetYear()), int64(_dollar_dollar.GetMonth()), int64(_dollar_dollar.GetDay())} + unwrapped_fields860 := fields859 p.write("(") p.write("date") p.indentSexp() p.newline() - field859 := unwrapped_fields858[0].(int64) - p.write(fmt.Sprintf("%d", field859)) + field861 := unwrapped_fields860[0].(int64) + p.write(fmt.Sprintf("%d", field861)) p.newline() - field860 := unwrapped_fields858[1].(int64) - p.write(fmt.Sprintf("%d", field860)) + field862 := unwrapped_fields860[1].(int64) + p.write(fmt.Sprintf("%d", field862)) p.newline() - field861 := unwrapped_fields858[2].(int64) - p.write(fmt.Sprintf("%d", field861)) + field863 := unwrapped_fields860[2].(int64) + p.write(fmt.Sprintf("%d", field863)) p.dedent() p.write(")") } @@ -895,40 +895,40 @@ func (p *PrettyPrinter) pretty_raw_date(msg *pb.DateValue) interface{} { } func (p *PrettyPrinter) pretty_raw_datetime(msg *pb.DateTimeValue) interface{} { - flat873 := p.tryFlat(msg, func() { p.pretty_raw_datetime(msg) }) - if flat873 != nil { - p.write(*flat873) + flat875 := p.tryFlat(msg, func() { p.pretty_raw_datetime(msg) }) + if flat875 != nil { + p.write(*flat875) return nil } else { _dollar_dollar := msg - fields863 := []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_fields864 := fields863 + fields865 := []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_fields866 := fields865 p.write("(") p.write("datetime") p.indentSexp() p.newline() - field865 := unwrapped_fields864[0].(int64) - p.write(fmt.Sprintf("%d", field865)) - p.newline() - field866 := unwrapped_fields864[1].(int64) - p.write(fmt.Sprintf("%d", field866)) - p.newline() - field867 := unwrapped_fields864[2].(int64) + field867 := unwrapped_fields866[0].(int64) p.write(fmt.Sprintf("%d", field867)) p.newline() - field868 := unwrapped_fields864[3].(int64) + field868 := unwrapped_fields866[1].(int64) p.write(fmt.Sprintf("%d", field868)) p.newline() - field869 := unwrapped_fields864[4].(int64) + field869 := unwrapped_fields866[2].(int64) p.write(fmt.Sprintf("%d", field869)) p.newline() - field870 := unwrapped_fields864[5].(int64) + field870 := unwrapped_fields866[3].(int64) p.write(fmt.Sprintf("%d", field870)) - field871 := unwrapped_fields864[6].(*int64) - if field871 != nil { + p.newline() + field871 := unwrapped_fields866[4].(int64) + p.write(fmt.Sprintf("%d", field871)) + p.newline() + field872 := unwrapped_fields866[5].(int64) + p.write(fmt.Sprintf("%d", field872)) + field873 := unwrapped_fields866[6].(*int64) + if field873 != nil { p.newline() - opt_val872 := *field871 - p.write(fmt.Sprintf("%d", opt_val872)) + opt_val874 := *field873 + p.write(fmt.Sprintf("%d", opt_val874)) } p.dedent() p.write(")") @@ -938,25 +938,25 @@ func (p *PrettyPrinter) pretty_raw_datetime(msg *pb.DateTimeValue) interface{} { func (p *PrettyPrinter) pretty_boolean_value(msg bool) interface{} { _dollar_dollar := msg - var _t1633 []interface{} + var _t1637 []interface{} if _dollar_dollar { - _t1633 = []interface{}{} + _t1637 = []interface{}{} } - deconstruct_result876 := _t1633 - if deconstruct_result876 != nil { - unwrapped877 := deconstruct_result876 - _ = unwrapped877 + deconstruct_result878 := _t1637 + if deconstruct_result878 != nil { + unwrapped879 := deconstruct_result878 + _ = unwrapped879 p.write("true") } else { _dollar_dollar := msg - var _t1634 []interface{} + var _t1638 []interface{} if !(_dollar_dollar) { - _t1634 = []interface{}{} + _t1638 = []interface{}{} } - deconstruct_result874 := _t1634 - if deconstruct_result874 != nil { - unwrapped875 := deconstruct_result874 - _ = unwrapped875 + deconstruct_result876 := _t1638 + if deconstruct_result876 != nil { + unwrapped877 := deconstruct_result876 + _ = unwrapped877 p.write("false") } else { panic(ParseError{msg: "No matching rule for boolean_value"}) @@ -966,24 +966,24 @@ func (p *PrettyPrinter) pretty_boolean_value(msg bool) interface{} { } func (p *PrettyPrinter) pretty_sync(msg *pb.Sync) interface{} { - flat882 := p.tryFlat(msg, func() { p.pretty_sync(msg) }) - if flat882 != nil { - p.write(*flat882) + flat884 := p.tryFlat(msg, func() { p.pretty_sync(msg) }) + if flat884 != nil { + p.write(*flat884) return nil } else { _dollar_dollar := msg - fields878 := _dollar_dollar.GetFragments() - unwrapped_fields879 := fields878 + fields880 := _dollar_dollar.GetFragments() + unwrapped_fields881 := fields880 p.write("(") p.write("sync") p.indentSexp() - if !(len(unwrapped_fields879) == 0) { + if !(len(unwrapped_fields881) == 0) { p.newline() - for i881, elem880 := range unwrapped_fields879 { - if (i881 > 0) { + for i883, elem882 := range unwrapped_fields881 { + if (i883 > 0) { p.newline() } - p.pretty_fragment_id(elem880) + p.pretty_fragment_id(elem882) } } p.dedent() @@ -993,51 +993,51 @@ func (p *PrettyPrinter) pretty_sync(msg *pb.Sync) interface{} { } func (p *PrettyPrinter) pretty_fragment_id(msg *pb.FragmentId) interface{} { - flat885 := p.tryFlat(msg, func() { p.pretty_fragment_id(msg) }) - if flat885 != nil { - p.write(*flat885) + flat887 := p.tryFlat(msg, func() { p.pretty_fragment_id(msg) }) + if flat887 != nil { + p.write(*flat887) return nil } else { _dollar_dollar := msg - fields883 := p.fragmentIdToString(_dollar_dollar) - unwrapped_fields884 := fields883 + fields885 := p.fragmentIdToString(_dollar_dollar) + unwrapped_fields886 := fields885 p.write(":") - p.write(unwrapped_fields884) + p.write(unwrapped_fields886) } return nil } func (p *PrettyPrinter) pretty_epoch(msg *pb.Epoch) interface{} { - flat892 := p.tryFlat(msg, func() { p.pretty_epoch(msg) }) - if flat892 != nil { - p.write(*flat892) + flat894 := p.tryFlat(msg, func() { p.pretty_epoch(msg) }) + if flat894 != nil { + p.write(*flat894) return nil } else { _dollar_dollar := msg - var _t1635 []*pb.Write + var _t1639 []*pb.Write if !(len(_dollar_dollar.GetWrites()) == 0) { - _t1635 = _dollar_dollar.GetWrites() + _t1639 = _dollar_dollar.GetWrites() } - var _t1636 []*pb.Read + var _t1640 []*pb.Read if !(len(_dollar_dollar.GetReads()) == 0) { - _t1636 = _dollar_dollar.GetReads() + _t1640 = _dollar_dollar.GetReads() } - fields886 := []interface{}{_t1635, _t1636} - unwrapped_fields887 := fields886 + fields888 := []interface{}{_t1639, _t1640} + unwrapped_fields889 := fields888 p.write("(") p.write("epoch") p.indentSexp() - field888 := unwrapped_fields887[0].([]*pb.Write) - if field888 != nil { - p.newline() - opt_val889 := field888 - p.pretty_epoch_writes(opt_val889) - } - field890 := unwrapped_fields887[1].([]*pb.Read) + field890 := unwrapped_fields889[0].([]*pb.Write) if field890 != nil { p.newline() opt_val891 := field890 - p.pretty_epoch_reads(opt_val891) + p.pretty_epoch_writes(opt_val891) + } + field892 := unwrapped_fields889[1].([]*pb.Read) + if field892 != nil { + p.newline() + opt_val893 := field892 + p.pretty_epoch_reads(opt_val893) } p.dedent() p.write(")") @@ -1046,22 +1046,22 @@ func (p *PrettyPrinter) pretty_epoch(msg *pb.Epoch) interface{} { } func (p *PrettyPrinter) pretty_epoch_writes(msg []*pb.Write) interface{} { - flat896 := p.tryFlat(msg, func() { p.pretty_epoch_writes(msg) }) - if flat896 != nil { - p.write(*flat896) + flat898 := p.tryFlat(msg, func() { p.pretty_epoch_writes(msg) }) + if flat898 != nil { + p.write(*flat898) return nil } else { - fields893 := msg + fields895 := msg p.write("(") p.write("writes") p.indentSexp() - if !(len(fields893) == 0) { + if !(len(fields895) == 0) { p.newline() - for i895, elem894 := range fields893 { - if (i895 > 0) { + for i897, elem896 := range fields895 { + if (i897 > 0) { p.newline() } - p.pretty_write(elem894) + p.pretty_write(elem896) } } p.dedent() @@ -1071,50 +1071,50 @@ func (p *PrettyPrinter) pretty_epoch_writes(msg []*pb.Write) interface{} { } func (p *PrettyPrinter) pretty_write(msg *pb.Write) interface{} { - flat905 := p.tryFlat(msg, func() { p.pretty_write(msg) }) - if flat905 != nil { - p.write(*flat905) + flat907 := p.tryFlat(msg, func() { p.pretty_write(msg) }) + if flat907 != nil { + p.write(*flat907) return nil } else { _dollar_dollar := msg - var _t1637 *pb.Define + var _t1641 *pb.Define if hasProtoField(_dollar_dollar, "define") { - _t1637 = _dollar_dollar.GetDefine() + _t1641 = _dollar_dollar.GetDefine() } - deconstruct_result903 := _t1637 - if deconstruct_result903 != nil { - unwrapped904 := deconstruct_result903 - p.pretty_define(unwrapped904) + deconstruct_result905 := _t1641 + if deconstruct_result905 != nil { + unwrapped906 := deconstruct_result905 + p.pretty_define(unwrapped906) } else { _dollar_dollar := msg - var _t1638 *pb.Undefine + var _t1642 *pb.Undefine if hasProtoField(_dollar_dollar, "undefine") { - _t1638 = _dollar_dollar.GetUndefine() + _t1642 = _dollar_dollar.GetUndefine() } - deconstruct_result901 := _t1638 - if deconstruct_result901 != nil { - unwrapped902 := deconstruct_result901 - p.pretty_undefine(unwrapped902) + deconstruct_result903 := _t1642 + if deconstruct_result903 != nil { + unwrapped904 := deconstruct_result903 + p.pretty_undefine(unwrapped904) } else { _dollar_dollar := msg - var _t1639 *pb.Context + var _t1643 *pb.Context if hasProtoField(_dollar_dollar, "context") { - _t1639 = _dollar_dollar.GetContext() + _t1643 = _dollar_dollar.GetContext() } - deconstruct_result899 := _t1639 - if deconstruct_result899 != nil { - unwrapped900 := deconstruct_result899 - p.pretty_context(unwrapped900) + deconstruct_result901 := _t1643 + if deconstruct_result901 != nil { + unwrapped902 := deconstruct_result901 + p.pretty_context(unwrapped902) } else { _dollar_dollar := msg - var _t1640 *pb.Snapshot + var _t1644 *pb.Snapshot if hasProtoField(_dollar_dollar, "snapshot") { - _t1640 = _dollar_dollar.GetSnapshot() + _t1644 = _dollar_dollar.GetSnapshot() } - deconstruct_result897 := _t1640 - if deconstruct_result897 != nil { - unwrapped898 := deconstruct_result897 - p.pretty_snapshot(unwrapped898) + deconstruct_result899 := _t1644 + if deconstruct_result899 != nil { + unwrapped900 := deconstruct_result899 + p.pretty_snapshot(unwrapped900) } else { panic(ParseError{msg: "No matching rule for write"}) } @@ -1126,19 +1126,19 @@ func (p *PrettyPrinter) pretty_write(msg *pb.Write) interface{} { } func (p *PrettyPrinter) pretty_define(msg *pb.Define) interface{} { - flat908 := p.tryFlat(msg, func() { p.pretty_define(msg) }) - if flat908 != nil { - p.write(*flat908) + flat910 := p.tryFlat(msg, func() { p.pretty_define(msg) }) + if flat910 != nil { + p.write(*flat910) return nil } else { _dollar_dollar := msg - fields906 := _dollar_dollar.GetFragment() - unwrapped_fields907 := fields906 + fields908 := _dollar_dollar.GetFragment() + unwrapped_fields909 := fields908 p.write("(") p.write("define") p.indentSexp() p.newline() - p.pretty_fragment(unwrapped_fields907) + p.pretty_fragment(unwrapped_fields909) p.dedent() p.write(")") } @@ -1146,29 +1146,29 @@ func (p *PrettyPrinter) pretty_define(msg *pb.Define) interface{} { } func (p *PrettyPrinter) pretty_fragment(msg *pb.Fragment) interface{} { - flat915 := p.tryFlat(msg, func() { p.pretty_fragment(msg) }) - if flat915 != nil { - p.write(*flat915) + flat917 := p.tryFlat(msg, func() { p.pretty_fragment(msg) }) + if flat917 != nil { + p.write(*flat917) return nil } else { _dollar_dollar := msg p.startPrettyFragment(_dollar_dollar) - fields909 := []interface{}{_dollar_dollar.GetId(), _dollar_dollar.GetDeclarations()} - unwrapped_fields910 := fields909 + fields911 := []interface{}{_dollar_dollar.GetId(), _dollar_dollar.GetDeclarations()} + unwrapped_fields912 := fields911 p.write("(") p.write("fragment") p.indentSexp() p.newline() - field911 := unwrapped_fields910[0].(*pb.FragmentId) - p.pretty_new_fragment_id(field911) - field912 := unwrapped_fields910[1].([]*pb.Declaration) - if !(len(field912) == 0) { + field913 := unwrapped_fields912[0].(*pb.FragmentId) + p.pretty_new_fragment_id(field913) + field914 := unwrapped_fields912[1].([]*pb.Declaration) + if !(len(field914) == 0) { p.newline() - for i914, elem913 := range field912 { - if (i914 > 0) { + for i916, elem915 := range field914 { + if (i916 > 0) { p.newline() } - p.pretty_declaration(elem913) + p.pretty_declaration(elem915) } } p.dedent() @@ -1178,62 +1178,62 @@ func (p *PrettyPrinter) pretty_fragment(msg *pb.Fragment) interface{} { } func (p *PrettyPrinter) pretty_new_fragment_id(msg *pb.FragmentId) interface{} { - flat917 := p.tryFlat(msg, func() { p.pretty_new_fragment_id(msg) }) - if flat917 != nil { - p.write(*flat917) + flat919 := p.tryFlat(msg, func() { p.pretty_new_fragment_id(msg) }) + if flat919 != nil { + p.write(*flat919) return nil } else { - fields916 := msg - p.pretty_fragment_id(fields916) + fields918 := msg + p.pretty_fragment_id(fields918) } return nil } func (p *PrettyPrinter) pretty_declaration(msg *pb.Declaration) interface{} { - flat926 := p.tryFlat(msg, func() { p.pretty_declaration(msg) }) - if flat926 != nil { - p.write(*flat926) + flat928 := p.tryFlat(msg, func() { p.pretty_declaration(msg) }) + if flat928 != nil { + p.write(*flat928) return nil } else { _dollar_dollar := msg - var _t1641 *pb.Def + var _t1645 *pb.Def if hasProtoField(_dollar_dollar, "def") { - _t1641 = _dollar_dollar.GetDef() + _t1645 = _dollar_dollar.GetDef() } - deconstruct_result924 := _t1641 - if deconstruct_result924 != nil { - unwrapped925 := deconstruct_result924 - p.pretty_def(unwrapped925) + deconstruct_result926 := _t1645 + if deconstruct_result926 != nil { + unwrapped927 := deconstruct_result926 + p.pretty_def(unwrapped927) } else { _dollar_dollar := msg - var _t1642 *pb.Algorithm + var _t1646 *pb.Algorithm if hasProtoField(_dollar_dollar, "algorithm") { - _t1642 = _dollar_dollar.GetAlgorithm() + _t1646 = _dollar_dollar.GetAlgorithm() } - deconstruct_result922 := _t1642 - if deconstruct_result922 != nil { - unwrapped923 := deconstruct_result922 - p.pretty_algorithm(unwrapped923) + deconstruct_result924 := _t1646 + if deconstruct_result924 != nil { + unwrapped925 := deconstruct_result924 + p.pretty_algorithm(unwrapped925) } else { _dollar_dollar := msg - var _t1643 *pb.Constraint + var _t1647 *pb.Constraint if hasProtoField(_dollar_dollar, "constraint") { - _t1643 = _dollar_dollar.GetConstraint() + _t1647 = _dollar_dollar.GetConstraint() } - deconstruct_result920 := _t1643 - if deconstruct_result920 != nil { - unwrapped921 := deconstruct_result920 - p.pretty_constraint(unwrapped921) + deconstruct_result922 := _t1647 + if deconstruct_result922 != nil { + unwrapped923 := deconstruct_result922 + p.pretty_constraint(unwrapped923) } else { _dollar_dollar := msg - var _t1644 *pb.Data + var _t1648 *pb.Data if hasProtoField(_dollar_dollar, "data") { - _t1644 = _dollar_dollar.GetData() + _t1648 = _dollar_dollar.GetData() } - deconstruct_result918 := _t1644 - if deconstruct_result918 != nil { - unwrapped919 := deconstruct_result918 - p.pretty_data(unwrapped919) + deconstruct_result920 := _t1648 + if deconstruct_result920 != nil { + unwrapped921 := deconstruct_result920 + p.pretty_data(unwrapped921) } else { panic(ParseError{msg: "No matching rule for declaration"}) } @@ -1245,32 +1245,32 @@ func (p *PrettyPrinter) pretty_declaration(msg *pb.Declaration) interface{} { } func (p *PrettyPrinter) pretty_def(msg *pb.Def) interface{} { - flat933 := p.tryFlat(msg, func() { p.pretty_def(msg) }) - if flat933 != nil { - p.write(*flat933) + flat935 := p.tryFlat(msg, func() { p.pretty_def(msg) }) + if flat935 != nil { + p.write(*flat935) return nil } else { _dollar_dollar := msg - var _t1645 []*pb.Attribute + var _t1649 []*pb.Attribute if !(len(_dollar_dollar.GetAttrs()) == 0) { - _t1645 = _dollar_dollar.GetAttrs() + _t1649 = _dollar_dollar.GetAttrs() } - fields927 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetBody(), _t1645} - unwrapped_fields928 := fields927 + fields929 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetBody(), _t1649} + unwrapped_fields930 := fields929 p.write("(") p.write("def") p.indentSexp() p.newline() - field929 := unwrapped_fields928[0].(*pb.RelationId) - p.pretty_relation_id(field929) + field931 := unwrapped_fields930[0].(*pb.RelationId) + p.pretty_relation_id(field931) p.newline() - field930 := unwrapped_fields928[1].(*pb.Abstraction) - p.pretty_abstraction(field930) - field931 := unwrapped_fields928[2].([]*pb.Attribute) - if field931 != nil { + field932 := unwrapped_fields930[1].(*pb.Abstraction) + p.pretty_abstraction(field932) + field933 := unwrapped_fields930[2].([]*pb.Attribute) + if field933 != nil { p.newline() - opt_val932 := field931 - p.pretty_attrs(opt_val932) + opt_val934 := field933 + p.pretty_attrs(opt_val934) } p.dedent() p.write(")") @@ -1279,29 +1279,29 @@ func (p *PrettyPrinter) pretty_def(msg *pb.Def) interface{} { } func (p *PrettyPrinter) pretty_relation_id(msg *pb.RelationId) interface{} { - flat938 := p.tryFlat(msg, func() { p.pretty_relation_id(msg) }) - if flat938 != nil { - p.write(*flat938) + flat940 := p.tryFlat(msg, func() { p.pretty_relation_id(msg) }) + if flat940 != nil { + p.write(*flat940) return nil } else { _dollar_dollar := msg - var _t1646 *string + var _t1650 *string if p.relationIdToString(_dollar_dollar) != nil { - _t1647 := p.deconstruct_relation_id_string(_dollar_dollar) - _t1646 = ptr(_t1647) + _t1651 := p.deconstruct_relation_id_string(_dollar_dollar) + _t1650 = ptr(_t1651) } - deconstruct_result936 := _t1646 - if deconstruct_result936 != nil { - unwrapped937 := *deconstruct_result936 + deconstruct_result938 := _t1650 + if deconstruct_result938 != nil { + unwrapped939 := *deconstruct_result938 p.write(":") - p.write(unwrapped937) + p.write(unwrapped939) } else { _dollar_dollar := msg - _t1648 := p.deconstruct_relation_id_uint128(_dollar_dollar) - deconstruct_result934 := _t1648 - if deconstruct_result934 != nil { - unwrapped935 := deconstruct_result934 - p.write(p.formatUint128(unwrapped935)) + _t1652 := p.deconstruct_relation_id_uint128(_dollar_dollar) + deconstruct_result936 := _t1652 + if deconstruct_result936 != nil { + unwrapped937 := deconstruct_result936 + p.write(p.formatUint128(unwrapped937)) } else { panic(ParseError{msg: "No matching rule for relation_id"}) } @@ -1311,22 +1311,22 @@ func (p *PrettyPrinter) pretty_relation_id(msg *pb.RelationId) interface{} { } func (p *PrettyPrinter) pretty_abstraction(msg *pb.Abstraction) interface{} { - flat943 := p.tryFlat(msg, func() { p.pretty_abstraction(msg) }) - if flat943 != nil { - p.write(*flat943) + flat945 := p.tryFlat(msg, func() { p.pretty_abstraction(msg) }) + if flat945 != nil { + p.write(*flat945) return nil } else { _dollar_dollar := msg - _t1649 := p.deconstruct_bindings(_dollar_dollar) - fields939 := []interface{}{_t1649, _dollar_dollar.GetValue()} - unwrapped_fields940 := fields939 + _t1653 := p.deconstruct_bindings(_dollar_dollar) + fields941 := []interface{}{_t1653, _dollar_dollar.GetValue()} + unwrapped_fields942 := fields941 p.write("(") p.indent() - field941 := unwrapped_fields940[0].([]interface{}) - p.pretty_bindings(field941) + field943 := unwrapped_fields942[0].([]interface{}) + p.pretty_bindings(field943) p.newline() - field942 := unwrapped_fields940[1].(*pb.Formula) - p.pretty_formula(field942) + field944 := unwrapped_fields942[1].(*pb.Formula) + p.pretty_formula(field944) p.dedent() p.write(")") } @@ -1334,32 +1334,32 @@ func (p *PrettyPrinter) pretty_abstraction(msg *pb.Abstraction) interface{} { } func (p *PrettyPrinter) pretty_bindings(msg []interface{}) interface{} { - flat951 := p.tryFlat(msg, func() { p.pretty_bindings(msg) }) - if flat951 != nil { - p.write(*flat951) + flat953 := p.tryFlat(msg, func() { p.pretty_bindings(msg) }) + if flat953 != nil { + p.write(*flat953) return nil } else { _dollar_dollar := msg - var _t1650 []*pb.Binding + var _t1654 []*pb.Binding if !(len(_dollar_dollar[1].([]*pb.Binding)) == 0) { - _t1650 = _dollar_dollar[1].([]*pb.Binding) + _t1654 = _dollar_dollar[1].([]*pb.Binding) } - fields944 := []interface{}{_dollar_dollar[0].([]*pb.Binding), _t1650} - unwrapped_fields945 := fields944 + fields946 := []interface{}{_dollar_dollar[0].([]*pb.Binding), _t1654} + unwrapped_fields947 := fields946 p.write("[") p.indent() - field946 := unwrapped_fields945[0].([]*pb.Binding) - for i948, elem947 := range field946 { - if (i948 > 0) { + field948 := unwrapped_fields947[0].([]*pb.Binding) + for i950, elem949 := range field948 { + if (i950 > 0) { p.newline() } - p.pretty_binding(elem947) + p.pretty_binding(elem949) } - field949 := unwrapped_fields945[1].([]*pb.Binding) - if field949 != nil { + field951 := unwrapped_fields947[1].([]*pb.Binding) + if field951 != nil { p.newline() - opt_val950 := field949 - p.pretty_value_bindings(opt_val950) + opt_val952 := field951 + p.pretty_value_bindings(opt_val952) } p.dedent() p.write("]") @@ -1368,168 +1368,168 @@ func (p *PrettyPrinter) pretty_bindings(msg []interface{}) interface{} { } func (p *PrettyPrinter) pretty_binding(msg *pb.Binding) interface{} { - flat956 := p.tryFlat(msg, func() { p.pretty_binding(msg) }) - if flat956 != nil { - p.write(*flat956) + flat958 := p.tryFlat(msg, func() { p.pretty_binding(msg) }) + if flat958 != nil { + p.write(*flat958) return nil } else { _dollar_dollar := msg - fields952 := []interface{}{_dollar_dollar.GetVar().GetName(), _dollar_dollar.GetType()} - unwrapped_fields953 := fields952 - field954 := unwrapped_fields953[0].(string) - p.write(field954) + fields954 := []interface{}{_dollar_dollar.GetVar().GetName(), _dollar_dollar.GetType()} + unwrapped_fields955 := fields954 + field956 := unwrapped_fields955[0].(string) + p.write(field956) p.write("::") - field955 := unwrapped_fields953[1].(*pb.Type) - p.pretty_type(field955) + field957 := unwrapped_fields955[1].(*pb.Type) + p.pretty_type(field957) } return nil } func (p *PrettyPrinter) pretty_type(msg *pb.Type) interface{} { - flat985 := p.tryFlat(msg, func() { p.pretty_type(msg) }) - if flat985 != nil { - p.write(*flat985) + flat987 := p.tryFlat(msg, func() { p.pretty_type(msg) }) + if flat987 != nil { + p.write(*flat987) return nil } else { _dollar_dollar := msg - var _t1651 *pb.UnspecifiedType + var _t1655 *pb.UnspecifiedType if hasProtoField(_dollar_dollar, "unspecified_type") { - _t1651 = _dollar_dollar.GetUnspecifiedType() + _t1655 = _dollar_dollar.GetUnspecifiedType() } - deconstruct_result983 := _t1651 - if deconstruct_result983 != nil { - unwrapped984 := deconstruct_result983 - p.pretty_unspecified_type(unwrapped984) + deconstruct_result985 := _t1655 + if deconstruct_result985 != nil { + unwrapped986 := deconstruct_result985 + p.pretty_unspecified_type(unwrapped986) } else { _dollar_dollar := msg - var _t1652 *pb.StringType + var _t1656 *pb.StringType if hasProtoField(_dollar_dollar, "string_type") { - _t1652 = _dollar_dollar.GetStringType() + _t1656 = _dollar_dollar.GetStringType() } - deconstruct_result981 := _t1652 - if deconstruct_result981 != nil { - unwrapped982 := deconstruct_result981 - p.pretty_string_type(unwrapped982) + deconstruct_result983 := _t1656 + if deconstruct_result983 != nil { + unwrapped984 := deconstruct_result983 + p.pretty_string_type(unwrapped984) } else { _dollar_dollar := msg - var _t1653 *pb.IntType + var _t1657 *pb.IntType if hasProtoField(_dollar_dollar, "int_type") { - _t1653 = _dollar_dollar.GetIntType() + _t1657 = _dollar_dollar.GetIntType() } - deconstruct_result979 := _t1653 - if deconstruct_result979 != nil { - unwrapped980 := deconstruct_result979 - p.pretty_int_type(unwrapped980) + deconstruct_result981 := _t1657 + if deconstruct_result981 != nil { + unwrapped982 := deconstruct_result981 + p.pretty_int_type(unwrapped982) } else { _dollar_dollar := msg - var _t1654 *pb.FloatType + var _t1658 *pb.FloatType if hasProtoField(_dollar_dollar, "float_type") { - _t1654 = _dollar_dollar.GetFloatType() + _t1658 = _dollar_dollar.GetFloatType() } - deconstruct_result977 := _t1654 - if deconstruct_result977 != nil { - unwrapped978 := deconstruct_result977 - p.pretty_float_type(unwrapped978) + deconstruct_result979 := _t1658 + if deconstruct_result979 != nil { + unwrapped980 := deconstruct_result979 + p.pretty_float_type(unwrapped980) } else { _dollar_dollar := msg - var _t1655 *pb.UInt128Type + var _t1659 *pb.UInt128Type if hasProtoField(_dollar_dollar, "uint128_type") { - _t1655 = _dollar_dollar.GetUint128Type() + _t1659 = _dollar_dollar.GetUint128Type() } - deconstruct_result975 := _t1655 - if deconstruct_result975 != nil { - unwrapped976 := deconstruct_result975 - p.pretty_uint128_type(unwrapped976) + deconstruct_result977 := _t1659 + if deconstruct_result977 != nil { + unwrapped978 := deconstruct_result977 + p.pretty_uint128_type(unwrapped978) } else { _dollar_dollar := msg - var _t1656 *pb.Int128Type + var _t1660 *pb.Int128Type if hasProtoField(_dollar_dollar, "int128_type") { - _t1656 = _dollar_dollar.GetInt128Type() + _t1660 = _dollar_dollar.GetInt128Type() } - deconstruct_result973 := _t1656 - if deconstruct_result973 != nil { - unwrapped974 := deconstruct_result973 - p.pretty_int128_type(unwrapped974) + deconstruct_result975 := _t1660 + if deconstruct_result975 != nil { + unwrapped976 := deconstruct_result975 + p.pretty_int128_type(unwrapped976) } else { _dollar_dollar := msg - var _t1657 *pb.DateType + var _t1661 *pb.DateType if hasProtoField(_dollar_dollar, "date_type") { - _t1657 = _dollar_dollar.GetDateType() + _t1661 = _dollar_dollar.GetDateType() } - deconstruct_result971 := _t1657 - if deconstruct_result971 != nil { - unwrapped972 := deconstruct_result971 - p.pretty_date_type(unwrapped972) + deconstruct_result973 := _t1661 + if deconstruct_result973 != nil { + unwrapped974 := deconstruct_result973 + p.pretty_date_type(unwrapped974) } else { _dollar_dollar := msg - var _t1658 *pb.DateTimeType + var _t1662 *pb.DateTimeType if hasProtoField(_dollar_dollar, "datetime_type") { - _t1658 = _dollar_dollar.GetDatetimeType() + _t1662 = _dollar_dollar.GetDatetimeType() } - deconstruct_result969 := _t1658 - if deconstruct_result969 != nil { - unwrapped970 := deconstruct_result969 - p.pretty_datetime_type(unwrapped970) + deconstruct_result971 := _t1662 + if deconstruct_result971 != nil { + unwrapped972 := deconstruct_result971 + p.pretty_datetime_type(unwrapped972) } else { _dollar_dollar := msg - var _t1659 *pb.MissingType + var _t1663 *pb.MissingType if hasProtoField(_dollar_dollar, "missing_type") { - _t1659 = _dollar_dollar.GetMissingType() + _t1663 = _dollar_dollar.GetMissingType() } - deconstruct_result967 := _t1659 - if deconstruct_result967 != nil { - unwrapped968 := deconstruct_result967 - p.pretty_missing_type(unwrapped968) + deconstruct_result969 := _t1663 + if deconstruct_result969 != nil { + unwrapped970 := deconstruct_result969 + p.pretty_missing_type(unwrapped970) } else { _dollar_dollar := msg - var _t1660 *pb.DecimalType + var _t1664 *pb.DecimalType if hasProtoField(_dollar_dollar, "decimal_type") { - _t1660 = _dollar_dollar.GetDecimalType() + _t1664 = _dollar_dollar.GetDecimalType() } - deconstruct_result965 := _t1660 - if deconstruct_result965 != nil { - unwrapped966 := deconstruct_result965 - p.pretty_decimal_type(unwrapped966) + deconstruct_result967 := _t1664 + if deconstruct_result967 != nil { + unwrapped968 := deconstruct_result967 + p.pretty_decimal_type(unwrapped968) } else { _dollar_dollar := msg - var _t1661 *pb.BooleanType + var _t1665 *pb.BooleanType if hasProtoField(_dollar_dollar, "boolean_type") { - _t1661 = _dollar_dollar.GetBooleanType() + _t1665 = _dollar_dollar.GetBooleanType() } - deconstruct_result963 := _t1661 - if deconstruct_result963 != nil { - unwrapped964 := deconstruct_result963 - p.pretty_boolean_type(unwrapped964) + deconstruct_result965 := _t1665 + if deconstruct_result965 != nil { + unwrapped966 := deconstruct_result965 + p.pretty_boolean_type(unwrapped966) } else { _dollar_dollar := msg - var _t1662 *pb.Int32Type + var _t1666 *pb.Int32Type if hasProtoField(_dollar_dollar, "int32_type") { - _t1662 = _dollar_dollar.GetInt32Type() + _t1666 = _dollar_dollar.GetInt32Type() } - deconstruct_result961 := _t1662 - if deconstruct_result961 != nil { - unwrapped962 := deconstruct_result961 - p.pretty_int32_type(unwrapped962) + deconstruct_result963 := _t1666 + if deconstruct_result963 != nil { + unwrapped964 := deconstruct_result963 + p.pretty_int32_type(unwrapped964) } else { _dollar_dollar := msg - var _t1663 *pb.Float32Type + var _t1667 *pb.Float32Type if hasProtoField(_dollar_dollar, "float32_type") { - _t1663 = _dollar_dollar.GetFloat32Type() + _t1667 = _dollar_dollar.GetFloat32Type() } - deconstruct_result959 := _t1663 - if deconstruct_result959 != nil { - unwrapped960 := deconstruct_result959 - p.pretty_float32_type(unwrapped960) + deconstruct_result961 := _t1667 + if deconstruct_result961 != nil { + unwrapped962 := deconstruct_result961 + p.pretty_float32_type(unwrapped962) } else { _dollar_dollar := msg - var _t1664 *pb.UInt32Type + var _t1668 *pb.UInt32Type if hasProtoField(_dollar_dollar, "uint32_type") { - _t1664 = _dollar_dollar.GetUint32Type() + _t1668 = _dollar_dollar.GetUint32Type() } - deconstruct_result957 := _t1664 - if deconstruct_result957 != nil { - unwrapped958 := deconstruct_result957 - p.pretty_uint32_type(unwrapped958) + deconstruct_result959 := _t1668 + if deconstruct_result959 != nil { + unwrapped960 := deconstruct_result959 + p.pretty_uint32_type(unwrapped960) } else { panic(ParseError{msg: "No matching rule for type"}) } @@ -1551,86 +1551,86 @@ func (p *PrettyPrinter) pretty_type(msg *pb.Type) interface{} { } func (p *PrettyPrinter) pretty_unspecified_type(msg *pb.UnspecifiedType) interface{} { - fields986 := msg - _ = fields986 + fields988 := msg + _ = fields988 p.write("UNKNOWN") return nil } func (p *PrettyPrinter) pretty_string_type(msg *pb.StringType) interface{} { - fields987 := msg - _ = fields987 + fields989 := msg + _ = fields989 p.write("STRING") return nil } func (p *PrettyPrinter) pretty_int_type(msg *pb.IntType) interface{} { - fields988 := msg - _ = fields988 + fields990 := msg + _ = fields990 p.write("INT") return nil } func (p *PrettyPrinter) pretty_float_type(msg *pb.FloatType) interface{} { - fields989 := msg - _ = fields989 + fields991 := msg + _ = fields991 p.write("FLOAT") return nil } func (p *PrettyPrinter) pretty_uint128_type(msg *pb.UInt128Type) interface{} { - fields990 := msg - _ = fields990 + fields992 := msg + _ = fields992 p.write("UINT128") return nil } func (p *PrettyPrinter) pretty_int128_type(msg *pb.Int128Type) interface{} { - fields991 := msg - _ = fields991 + fields993 := msg + _ = fields993 p.write("INT128") return nil } func (p *PrettyPrinter) pretty_date_type(msg *pb.DateType) interface{} { - fields992 := msg - _ = fields992 + fields994 := msg + _ = fields994 p.write("DATE") return nil } func (p *PrettyPrinter) pretty_datetime_type(msg *pb.DateTimeType) interface{} { - fields993 := msg - _ = fields993 + fields995 := msg + _ = fields995 p.write("DATETIME") return nil } func (p *PrettyPrinter) pretty_missing_type(msg *pb.MissingType) interface{} { - fields994 := msg - _ = fields994 + fields996 := msg + _ = fields996 p.write("MISSING") return nil } func (p *PrettyPrinter) pretty_decimal_type(msg *pb.DecimalType) interface{} { - flat999 := p.tryFlat(msg, func() { p.pretty_decimal_type(msg) }) - if flat999 != nil { - p.write(*flat999) + flat1001 := p.tryFlat(msg, func() { p.pretty_decimal_type(msg) }) + if flat1001 != nil { + p.write(*flat1001) return nil } else { _dollar_dollar := msg - fields995 := []interface{}{int64(_dollar_dollar.GetPrecision()), int64(_dollar_dollar.GetScale())} - unwrapped_fields996 := fields995 + fields997 := []interface{}{int64(_dollar_dollar.GetPrecision()), int64(_dollar_dollar.GetScale())} + unwrapped_fields998 := fields997 p.write("(") p.write("DECIMAL") p.indentSexp() p.newline() - field997 := unwrapped_fields996[0].(int64) - p.write(fmt.Sprintf("%d", field997)) + field999 := unwrapped_fields998[0].(int64) + p.write(fmt.Sprintf("%d", field999)) p.newline() - field998 := unwrapped_fields996[1].(int64) - p.write(fmt.Sprintf("%d", field998)) + field1000 := unwrapped_fields998[1].(int64) + p.write(fmt.Sprintf("%d", field1000)) p.dedent() p.write(")") } @@ -1638,48 +1638,48 @@ func (p *PrettyPrinter) pretty_decimal_type(msg *pb.DecimalType) interface{} { } func (p *PrettyPrinter) pretty_boolean_type(msg *pb.BooleanType) interface{} { - fields1000 := msg - _ = fields1000 + fields1002 := msg + _ = fields1002 p.write("BOOLEAN") return nil } func (p *PrettyPrinter) pretty_int32_type(msg *pb.Int32Type) interface{} { - fields1001 := msg - _ = fields1001 + fields1003 := msg + _ = fields1003 p.write("INT32") return nil } func (p *PrettyPrinter) pretty_float32_type(msg *pb.Float32Type) interface{} { - fields1002 := msg - _ = fields1002 + fields1004 := msg + _ = fields1004 p.write("FLOAT32") return nil } func (p *PrettyPrinter) pretty_uint32_type(msg *pb.UInt32Type) interface{} { - fields1003 := msg - _ = fields1003 + fields1005 := msg + _ = fields1005 p.write("UINT32") return nil } func (p *PrettyPrinter) pretty_value_bindings(msg []*pb.Binding) interface{} { - flat1007 := p.tryFlat(msg, func() { p.pretty_value_bindings(msg) }) - if flat1007 != nil { - p.write(*flat1007) + flat1009 := p.tryFlat(msg, func() { p.pretty_value_bindings(msg) }) + if flat1009 != nil { + p.write(*flat1009) return nil } else { - fields1004 := msg + fields1006 := msg p.write("|") - if !(len(fields1004) == 0) { + if !(len(fields1006) == 0) { p.write(" ") - for i1006, elem1005 := range fields1004 { - if (i1006 > 0) { + for i1008, elem1007 := range fields1006 { + if (i1008 > 0) { p.newline() } - p.pretty_binding(elem1005) + p.pretty_binding(elem1007) } } } @@ -1687,140 +1687,140 @@ func (p *PrettyPrinter) pretty_value_bindings(msg []*pb.Binding) interface{} { } func (p *PrettyPrinter) pretty_formula(msg *pb.Formula) interface{} { - flat1034 := p.tryFlat(msg, func() { p.pretty_formula(msg) }) - if flat1034 != nil { - p.write(*flat1034) + flat1036 := p.tryFlat(msg, func() { p.pretty_formula(msg) }) + if flat1036 != nil { + p.write(*flat1036) return nil } else { _dollar_dollar := msg - var _t1665 *pb.Conjunction + var _t1669 *pb.Conjunction if (hasProtoField(_dollar_dollar, "conjunction") && len(_dollar_dollar.GetConjunction().GetArgs()) == 0) { - _t1665 = _dollar_dollar.GetConjunction() + _t1669 = _dollar_dollar.GetConjunction() } - deconstruct_result1032 := _t1665 - if deconstruct_result1032 != nil { - unwrapped1033 := deconstruct_result1032 - p.pretty_true(unwrapped1033) + deconstruct_result1034 := _t1669 + if deconstruct_result1034 != nil { + unwrapped1035 := deconstruct_result1034 + p.pretty_true(unwrapped1035) } else { _dollar_dollar := msg - var _t1666 *pb.Disjunction + var _t1670 *pb.Disjunction if (hasProtoField(_dollar_dollar, "disjunction") && len(_dollar_dollar.GetDisjunction().GetArgs()) == 0) { - _t1666 = _dollar_dollar.GetDisjunction() + _t1670 = _dollar_dollar.GetDisjunction() } - deconstruct_result1030 := _t1666 - if deconstruct_result1030 != nil { - unwrapped1031 := deconstruct_result1030 - p.pretty_false(unwrapped1031) + deconstruct_result1032 := _t1670 + if deconstruct_result1032 != nil { + unwrapped1033 := deconstruct_result1032 + p.pretty_false(unwrapped1033) } else { _dollar_dollar := msg - var _t1667 *pb.Exists + var _t1671 *pb.Exists if hasProtoField(_dollar_dollar, "exists") { - _t1667 = _dollar_dollar.GetExists() + _t1671 = _dollar_dollar.GetExists() } - deconstruct_result1028 := _t1667 - if deconstruct_result1028 != nil { - unwrapped1029 := deconstruct_result1028 - p.pretty_exists(unwrapped1029) + deconstruct_result1030 := _t1671 + if deconstruct_result1030 != nil { + unwrapped1031 := deconstruct_result1030 + p.pretty_exists(unwrapped1031) } else { _dollar_dollar := msg - var _t1668 *pb.Reduce + var _t1672 *pb.Reduce if hasProtoField(_dollar_dollar, "reduce") { - _t1668 = _dollar_dollar.GetReduce() + _t1672 = _dollar_dollar.GetReduce() } - deconstruct_result1026 := _t1668 - if deconstruct_result1026 != nil { - unwrapped1027 := deconstruct_result1026 - p.pretty_reduce(unwrapped1027) + deconstruct_result1028 := _t1672 + if deconstruct_result1028 != nil { + unwrapped1029 := deconstruct_result1028 + p.pretty_reduce(unwrapped1029) } else { _dollar_dollar := msg - var _t1669 *pb.Conjunction + var _t1673 *pb.Conjunction if (hasProtoField(_dollar_dollar, "conjunction") && !(len(_dollar_dollar.GetConjunction().GetArgs()) == 0)) { - _t1669 = _dollar_dollar.GetConjunction() + _t1673 = _dollar_dollar.GetConjunction() } - deconstruct_result1024 := _t1669 - if deconstruct_result1024 != nil { - unwrapped1025 := deconstruct_result1024 - p.pretty_conjunction(unwrapped1025) + deconstruct_result1026 := _t1673 + if deconstruct_result1026 != nil { + unwrapped1027 := deconstruct_result1026 + p.pretty_conjunction(unwrapped1027) } else { _dollar_dollar := msg - var _t1670 *pb.Disjunction + var _t1674 *pb.Disjunction if (hasProtoField(_dollar_dollar, "disjunction") && !(len(_dollar_dollar.GetDisjunction().GetArgs()) == 0)) { - _t1670 = _dollar_dollar.GetDisjunction() + _t1674 = _dollar_dollar.GetDisjunction() } - deconstruct_result1022 := _t1670 - if deconstruct_result1022 != nil { - unwrapped1023 := deconstruct_result1022 - p.pretty_disjunction(unwrapped1023) + deconstruct_result1024 := _t1674 + if deconstruct_result1024 != nil { + unwrapped1025 := deconstruct_result1024 + p.pretty_disjunction(unwrapped1025) } else { _dollar_dollar := msg - var _t1671 *pb.Not + var _t1675 *pb.Not if hasProtoField(_dollar_dollar, "not") { - _t1671 = _dollar_dollar.GetNot() + _t1675 = _dollar_dollar.GetNot() } - deconstruct_result1020 := _t1671 - if deconstruct_result1020 != nil { - unwrapped1021 := deconstruct_result1020 - p.pretty_not(unwrapped1021) + deconstruct_result1022 := _t1675 + if deconstruct_result1022 != nil { + unwrapped1023 := deconstruct_result1022 + p.pretty_not(unwrapped1023) } else { _dollar_dollar := msg - var _t1672 *pb.FFI + var _t1676 *pb.FFI if hasProtoField(_dollar_dollar, "ffi") { - _t1672 = _dollar_dollar.GetFfi() + _t1676 = _dollar_dollar.GetFfi() } - deconstruct_result1018 := _t1672 - if deconstruct_result1018 != nil { - unwrapped1019 := deconstruct_result1018 - p.pretty_ffi(unwrapped1019) + deconstruct_result1020 := _t1676 + if deconstruct_result1020 != nil { + unwrapped1021 := deconstruct_result1020 + p.pretty_ffi(unwrapped1021) } else { _dollar_dollar := msg - var _t1673 *pb.Atom + var _t1677 *pb.Atom if hasProtoField(_dollar_dollar, "atom") { - _t1673 = _dollar_dollar.GetAtom() + _t1677 = _dollar_dollar.GetAtom() } - deconstruct_result1016 := _t1673 - if deconstruct_result1016 != nil { - unwrapped1017 := deconstruct_result1016 - p.pretty_atom(unwrapped1017) + deconstruct_result1018 := _t1677 + if deconstruct_result1018 != nil { + unwrapped1019 := deconstruct_result1018 + p.pretty_atom(unwrapped1019) } else { _dollar_dollar := msg - var _t1674 *pb.Pragma + var _t1678 *pb.Pragma if hasProtoField(_dollar_dollar, "pragma") { - _t1674 = _dollar_dollar.GetPragma() + _t1678 = _dollar_dollar.GetPragma() } - deconstruct_result1014 := _t1674 - if deconstruct_result1014 != nil { - unwrapped1015 := deconstruct_result1014 - p.pretty_pragma(unwrapped1015) + deconstruct_result1016 := _t1678 + if deconstruct_result1016 != nil { + unwrapped1017 := deconstruct_result1016 + p.pretty_pragma(unwrapped1017) } else { _dollar_dollar := msg - var _t1675 *pb.Primitive + var _t1679 *pb.Primitive if hasProtoField(_dollar_dollar, "primitive") { - _t1675 = _dollar_dollar.GetPrimitive() + _t1679 = _dollar_dollar.GetPrimitive() } - deconstruct_result1012 := _t1675 - if deconstruct_result1012 != nil { - unwrapped1013 := deconstruct_result1012 - p.pretty_primitive(unwrapped1013) + deconstruct_result1014 := _t1679 + if deconstruct_result1014 != nil { + unwrapped1015 := deconstruct_result1014 + p.pretty_primitive(unwrapped1015) } else { _dollar_dollar := msg - var _t1676 *pb.RelAtom + var _t1680 *pb.RelAtom if hasProtoField(_dollar_dollar, "rel_atom") { - _t1676 = _dollar_dollar.GetRelAtom() + _t1680 = _dollar_dollar.GetRelAtom() } - deconstruct_result1010 := _t1676 - if deconstruct_result1010 != nil { - unwrapped1011 := deconstruct_result1010 - p.pretty_rel_atom(unwrapped1011) + deconstruct_result1012 := _t1680 + if deconstruct_result1012 != nil { + unwrapped1013 := deconstruct_result1012 + p.pretty_rel_atom(unwrapped1013) } else { _dollar_dollar := msg - var _t1677 *pb.Cast + var _t1681 *pb.Cast if hasProtoField(_dollar_dollar, "cast") { - _t1677 = _dollar_dollar.GetCast() + _t1681 = _dollar_dollar.GetCast() } - deconstruct_result1008 := _t1677 - if deconstruct_result1008 != nil { - unwrapped1009 := deconstruct_result1008 - p.pretty_cast(unwrapped1009) + deconstruct_result1010 := _t1681 + if deconstruct_result1010 != nil { + unwrapped1011 := deconstruct_result1010 + p.pretty_cast(unwrapped1011) } else { panic(ParseError{msg: "No matching rule for formula"}) } @@ -1841,8 +1841,8 @@ func (p *PrettyPrinter) pretty_formula(msg *pb.Formula) interface{} { } func (p *PrettyPrinter) pretty_true(msg *pb.Conjunction) interface{} { - fields1035 := msg - _ = fields1035 + fields1037 := msg + _ = fields1037 p.write("(") p.write("true") p.write(")") @@ -1850,8 +1850,8 @@ func (p *PrettyPrinter) pretty_true(msg *pb.Conjunction) interface{} { } func (p *PrettyPrinter) pretty_false(msg *pb.Disjunction) interface{} { - fields1036 := msg - _ = fields1036 + fields1038 := msg + _ = fields1038 p.write("(") p.write("false") p.write(")") @@ -1859,24 +1859,24 @@ func (p *PrettyPrinter) pretty_false(msg *pb.Disjunction) interface{} { } func (p *PrettyPrinter) pretty_exists(msg *pb.Exists) interface{} { - flat1041 := p.tryFlat(msg, func() { p.pretty_exists(msg) }) - if flat1041 != nil { - p.write(*flat1041) + flat1043 := p.tryFlat(msg, func() { p.pretty_exists(msg) }) + if flat1043 != nil { + p.write(*flat1043) return nil } else { _dollar_dollar := msg - _t1678 := p.deconstruct_bindings(_dollar_dollar.GetBody()) - fields1037 := []interface{}{_t1678, _dollar_dollar.GetBody().GetValue()} - unwrapped_fields1038 := fields1037 + _t1682 := p.deconstruct_bindings(_dollar_dollar.GetBody()) + fields1039 := []interface{}{_t1682, _dollar_dollar.GetBody().GetValue()} + unwrapped_fields1040 := fields1039 p.write("(") p.write("exists") p.indentSexp() p.newline() - field1039 := unwrapped_fields1038[0].([]interface{}) - p.pretty_bindings(field1039) + field1041 := unwrapped_fields1040[0].([]interface{}) + p.pretty_bindings(field1041) p.newline() - field1040 := unwrapped_fields1038[1].(*pb.Formula) - p.pretty_formula(field1040) + field1042 := unwrapped_fields1040[1].(*pb.Formula) + p.pretty_formula(field1042) p.dedent() p.write(")") } @@ -1884,26 +1884,26 @@ func (p *PrettyPrinter) pretty_exists(msg *pb.Exists) interface{} { } func (p *PrettyPrinter) pretty_reduce(msg *pb.Reduce) interface{} { - flat1047 := p.tryFlat(msg, func() { p.pretty_reduce(msg) }) - if flat1047 != nil { - p.write(*flat1047) + flat1049 := p.tryFlat(msg, func() { p.pretty_reduce(msg) }) + if flat1049 != nil { + p.write(*flat1049) return nil } else { _dollar_dollar := msg - fields1042 := []interface{}{_dollar_dollar.GetOp(), _dollar_dollar.GetBody(), _dollar_dollar.GetTerms()} - unwrapped_fields1043 := fields1042 + fields1044 := []interface{}{_dollar_dollar.GetOp(), _dollar_dollar.GetBody(), _dollar_dollar.GetTerms()} + unwrapped_fields1045 := fields1044 p.write("(") p.write("reduce") p.indentSexp() p.newline() - field1044 := unwrapped_fields1043[0].(*pb.Abstraction) - p.pretty_abstraction(field1044) + field1046 := unwrapped_fields1045[0].(*pb.Abstraction) + p.pretty_abstraction(field1046) p.newline() - field1045 := unwrapped_fields1043[1].(*pb.Abstraction) - p.pretty_abstraction(field1045) + field1047 := unwrapped_fields1045[1].(*pb.Abstraction) + p.pretty_abstraction(field1047) p.newline() - field1046 := unwrapped_fields1043[2].([]*pb.Term) - p.pretty_terms(field1046) + field1048 := unwrapped_fields1045[2].([]*pb.Term) + p.pretty_terms(field1048) p.dedent() p.write(")") } @@ -1911,22 +1911,22 @@ func (p *PrettyPrinter) pretty_reduce(msg *pb.Reduce) interface{} { } func (p *PrettyPrinter) pretty_terms(msg []*pb.Term) interface{} { - flat1051 := p.tryFlat(msg, func() { p.pretty_terms(msg) }) - if flat1051 != nil { - p.write(*flat1051) + flat1053 := p.tryFlat(msg, func() { p.pretty_terms(msg) }) + if flat1053 != nil { + p.write(*flat1053) return nil } else { - fields1048 := msg + fields1050 := msg p.write("(") p.write("terms") p.indentSexp() - if !(len(fields1048) == 0) { + if !(len(fields1050) == 0) { p.newline() - for i1050, elem1049 := range fields1048 { - if (i1050 > 0) { + for i1052, elem1051 := range fields1050 { + if (i1052 > 0) { p.newline() } - p.pretty_term(elem1049) + p.pretty_term(elem1051) } } p.dedent() @@ -1936,30 +1936,30 @@ func (p *PrettyPrinter) pretty_terms(msg []*pb.Term) interface{} { } func (p *PrettyPrinter) pretty_term(msg *pb.Term) interface{} { - flat1056 := p.tryFlat(msg, func() { p.pretty_term(msg) }) - if flat1056 != nil { - p.write(*flat1056) + flat1058 := p.tryFlat(msg, func() { p.pretty_term(msg) }) + if flat1058 != nil { + p.write(*flat1058) return nil } else { _dollar_dollar := msg - var _t1679 *pb.Var + var _t1683 *pb.Var if hasProtoField(_dollar_dollar, "var") { - _t1679 = _dollar_dollar.GetVar() + _t1683 = _dollar_dollar.GetVar() } - deconstruct_result1054 := _t1679 - if deconstruct_result1054 != nil { - unwrapped1055 := deconstruct_result1054 - p.pretty_var(unwrapped1055) + deconstruct_result1056 := _t1683 + if deconstruct_result1056 != nil { + unwrapped1057 := deconstruct_result1056 + p.pretty_var(unwrapped1057) } else { _dollar_dollar := msg - var _t1680 *pb.Value + var _t1684 *pb.Value if hasProtoField(_dollar_dollar, "constant") { - _t1680 = _dollar_dollar.GetConstant() + _t1684 = _dollar_dollar.GetConstant() } - deconstruct_result1052 := _t1680 - if deconstruct_result1052 != nil { - unwrapped1053 := deconstruct_result1052 - p.pretty_value(unwrapped1053) + deconstruct_result1054 := _t1684 + if deconstruct_result1054 != nil { + unwrapped1055 := deconstruct_result1054 + p.pretty_value(unwrapped1055) } else { panic(ParseError{msg: "No matching rule for term"}) } @@ -1969,147 +1969,147 @@ func (p *PrettyPrinter) pretty_term(msg *pb.Term) interface{} { } func (p *PrettyPrinter) pretty_var(msg *pb.Var) interface{} { - flat1059 := p.tryFlat(msg, func() { p.pretty_var(msg) }) - if flat1059 != nil { - p.write(*flat1059) + flat1061 := p.tryFlat(msg, func() { p.pretty_var(msg) }) + if flat1061 != nil { + p.write(*flat1061) return nil } else { _dollar_dollar := msg - fields1057 := _dollar_dollar.GetName() - unwrapped_fields1058 := fields1057 - p.write(unwrapped_fields1058) + fields1059 := _dollar_dollar.GetName() + unwrapped_fields1060 := fields1059 + p.write(unwrapped_fields1060) } return nil } func (p *PrettyPrinter) pretty_value(msg *pb.Value) interface{} { - flat1085 := p.tryFlat(msg, func() { p.pretty_value(msg) }) - if flat1085 != nil { - p.write(*flat1085) + flat1087 := p.tryFlat(msg, func() { p.pretty_value(msg) }) + if flat1087 != nil { + p.write(*flat1087) return nil } else { _dollar_dollar := msg - var _t1681 *pb.DateValue + var _t1685 *pb.DateValue if hasProtoField(_dollar_dollar, "date_value") { - _t1681 = _dollar_dollar.GetDateValue() + _t1685 = _dollar_dollar.GetDateValue() } - deconstruct_result1083 := _t1681 - if deconstruct_result1083 != nil { - unwrapped1084 := deconstruct_result1083 - p.pretty_date(unwrapped1084) + deconstruct_result1085 := _t1685 + if deconstruct_result1085 != nil { + unwrapped1086 := deconstruct_result1085 + p.pretty_date(unwrapped1086) } else { _dollar_dollar := msg - var _t1682 *pb.DateTimeValue + var _t1686 *pb.DateTimeValue if hasProtoField(_dollar_dollar, "datetime_value") { - _t1682 = _dollar_dollar.GetDatetimeValue() + _t1686 = _dollar_dollar.GetDatetimeValue() } - deconstruct_result1081 := _t1682 - if deconstruct_result1081 != nil { - unwrapped1082 := deconstruct_result1081 - p.pretty_datetime(unwrapped1082) + deconstruct_result1083 := _t1686 + if deconstruct_result1083 != nil { + unwrapped1084 := deconstruct_result1083 + p.pretty_datetime(unwrapped1084) } else { _dollar_dollar := msg - var _t1683 *string + var _t1687 *string if hasProtoField(_dollar_dollar, "string_value") { - _t1683 = ptr(_dollar_dollar.GetStringValue()) + _t1687 = ptr(_dollar_dollar.GetStringValue()) } - deconstruct_result1079 := _t1683 - if deconstruct_result1079 != nil { - unwrapped1080 := *deconstruct_result1079 - p.write(p.formatStringValue(unwrapped1080)) + deconstruct_result1081 := _t1687 + if deconstruct_result1081 != nil { + unwrapped1082 := *deconstruct_result1081 + p.write(p.formatStringValue(unwrapped1082)) } else { _dollar_dollar := msg - var _t1684 *int32 + var _t1688 *int32 if hasProtoField(_dollar_dollar, "int32_value") { - _t1684 = ptr(_dollar_dollar.GetInt32Value()) + _t1688 = ptr(_dollar_dollar.GetInt32Value()) } - deconstruct_result1077 := _t1684 - if deconstruct_result1077 != nil { - unwrapped1078 := *deconstruct_result1077 - p.write(fmt.Sprintf("%di32", unwrapped1078)) + deconstruct_result1079 := _t1688 + if deconstruct_result1079 != nil { + unwrapped1080 := *deconstruct_result1079 + p.write(fmt.Sprintf("%di32", unwrapped1080)) } else { _dollar_dollar := msg - var _t1685 *int64 + var _t1689 *int64 if hasProtoField(_dollar_dollar, "int_value") { - _t1685 = ptr(_dollar_dollar.GetIntValue()) + _t1689 = ptr(_dollar_dollar.GetIntValue()) } - deconstruct_result1075 := _t1685 - if deconstruct_result1075 != nil { - unwrapped1076 := *deconstruct_result1075 - p.write(fmt.Sprintf("%d", unwrapped1076)) + deconstruct_result1077 := _t1689 + if deconstruct_result1077 != nil { + unwrapped1078 := *deconstruct_result1077 + p.write(fmt.Sprintf("%d", unwrapped1078)) } else { _dollar_dollar := msg - var _t1686 *float32 + var _t1690 *float32 if hasProtoField(_dollar_dollar, "float32_value") { - _t1686 = ptr(_dollar_dollar.GetFloat32Value()) + _t1690 = ptr(_dollar_dollar.GetFloat32Value()) } - deconstruct_result1073 := _t1686 - if deconstruct_result1073 != nil { - unwrapped1074 := *deconstruct_result1073 - p.write(formatFloat32(unwrapped1074)) + deconstruct_result1075 := _t1690 + if deconstruct_result1075 != nil { + unwrapped1076 := *deconstruct_result1075 + p.write(formatFloat32(unwrapped1076)) } else { _dollar_dollar := msg - var _t1687 *float64 + var _t1691 *float64 if hasProtoField(_dollar_dollar, "float_value") { - _t1687 = ptr(_dollar_dollar.GetFloatValue()) + _t1691 = ptr(_dollar_dollar.GetFloatValue()) } - deconstruct_result1071 := _t1687 - if deconstruct_result1071 != nil { - unwrapped1072 := *deconstruct_result1071 - p.write(formatFloat64(unwrapped1072)) + deconstruct_result1073 := _t1691 + if deconstruct_result1073 != nil { + unwrapped1074 := *deconstruct_result1073 + p.write(formatFloat64(unwrapped1074)) } else { _dollar_dollar := msg - var _t1688 *uint32 + var _t1692 *uint32 if hasProtoField(_dollar_dollar, "uint32_value") { - _t1688 = ptr(_dollar_dollar.GetUint32Value()) + _t1692 = ptr(_dollar_dollar.GetUint32Value()) } - deconstruct_result1069 := _t1688 - if deconstruct_result1069 != nil { - unwrapped1070 := *deconstruct_result1069 - p.write(fmt.Sprintf("%du32", unwrapped1070)) + deconstruct_result1071 := _t1692 + if deconstruct_result1071 != nil { + unwrapped1072 := *deconstruct_result1071 + p.write(fmt.Sprintf("%du32", unwrapped1072)) } else { _dollar_dollar := msg - var _t1689 *pb.UInt128Value + var _t1693 *pb.UInt128Value if hasProtoField(_dollar_dollar, "uint128_value") { - _t1689 = _dollar_dollar.GetUint128Value() + _t1693 = _dollar_dollar.GetUint128Value() } - deconstruct_result1067 := _t1689 - if deconstruct_result1067 != nil { - unwrapped1068 := deconstruct_result1067 - p.write(p.formatUint128(unwrapped1068)) + deconstruct_result1069 := _t1693 + if deconstruct_result1069 != nil { + unwrapped1070 := deconstruct_result1069 + p.write(p.formatUint128(unwrapped1070)) } else { _dollar_dollar := msg - var _t1690 *pb.Int128Value + var _t1694 *pb.Int128Value if hasProtoField(_dollar_dollar, "int128_value") { - _t1690 = _dollar_dollar.GetInt128Value() + _t1694 = _dollar_dollar.GetInt128Value() } - deconstruct_result1065 := _t1690 - if deconstruct_result1065 != nil { - unwrapped1066 := deconstruct_result1065 - p.write(p.formatInt128(unwrapped1066)) + deconstruct_result1067 := _t1694 + if deconstruct_result1067 != nil { + unwrapped1068 := deconstruct_result1067 + p.write(p.formatInt128(unwrapped1068)) } else { _dollar_dollar := msg - var _t1691 *pb.DecimalValue + var _t1695 *pb.DecimalValue if hasProtoField(_dollar_dollar, "decimal_value") { - _t1691 = _dollar_dollar.GetDecimalValue() + _t1695 = _dollar_dollar.GetDecimalValue() } - deconstruct_result1063 := _t1691 - if deconstruct_result1063 != nil { - unwrapped1064 := deconstruct_result1063 - p.write(p.formatDecimal(unwrapped1064)) + deconstruct_result1065 := _t1695 + if deconstruct_result1065 != nil { + unwrapped1066 := deconstruct_result1065 + p.write(p.formatDecimal(unwrapped1066)) } else { _dollar_dollar := msg - var _t1692 *bool + var _t1696 *bool if hasProtoField(_dollar_dollar, "boolean_value") { - _t1692 = ptr(_dollar_dollar.GetBooleanValue()) + _t1696 = ptr(_dollar_dollar.GetBooleanValue()) } - deconstruct_result1061 := _t1692 - if deconstruct_result1061 != nil { - unwrapped1062 := *deconstruct_result1061 - p.pretty_boolean_value(unwrapped1062) + deconstruct_result1063 := _t1696 + if deconstruct_result1063 != nil { + unwrapped1064 := *deconstruct_result1063 + p.pretty_boolean_value(unwrapped1064) } else { - fields1060 := msg - _ = fields1060 + fields1062 := msg + _ = fields1062 p.write("missing") } } @@ -2128,26 +2128,26 @@ func (p *PrettyPrinter) pretty_value(msg *pb.Value) interface{} { } func (p *PrettyPrinter) pretty_date(msg *pb.DateValue) interface{} { - flat1091 := p.tryFlat(msg, func() { p.pretty_date(msg) }) - if flat1091 != nil { - p.write(*flat1091) + flat1093 := p.tryFlat(msg, func() { p.pretty_date(msg) }) + if flat1093 != nil { + p.write(*flat1093) return nil } else { _dollar_dollar := msg - fields1086 := []interface{}{int64(_dollar_dollar.GetYear()), int64(_dollar_dollar.GetMonth()), int64(_dollar_dollar.GetDay())} - unwrapped_fields1087 := fields1086 + fields1088 := []interface{}{int64(_dollar_dollar.GetYear()), int64(_dollar_dollar.GetMonth()), int64(_dollar_dollar.GetDay())} + unwrapped_fields1089 := fields1088 p.write("(") p.write("date") p.indentSexp() p.newline() - field1088 := unwrapped_fields1087[0].(int64) - p.write(fmt.Sprintf("%d", field1088)) + field1090 := unwrapped_fields1089[0].(int64) + p.write(fmt.Sprintf("%d", field1090)) p.newline() - field1089 := unwrapped_fields1087[1].(int64) - p.write(fmt.Sprintf("%d", field1089)) + field1091 := unwrapped_fields1089[1].(int64) + p.write(fmt.Sprintf("%d", field1091)) p.newline() - field1090 := unwrapped_fields1087[2].(int64) - p.write(fmt.Sprintf("%d", field1090)) + field1092 := unwrapped_fields1089[2].(int64) + p.write(fmt.Sprintf("%d", field1092)) p.dedent() p.write(")") } @@ -2155,40 +2155,40 @@ func (p *PrettyPrinter) pretty_date(msg *pb.DateValue) interface{} { } func (p *PrettyPrinter) pretty_datetime(msg *pb.DateTimeValue) interface{} { - flat1102 := p.tryFlat(msg, func() { p.pretty_datetime(msg) }) - if flat1102 != nil { - p.write(*flat1102) + flat1104 := p.tryFlat(msg, func() { p.pretty_datetime(msg) }) + if flat1104 != nil { + p.write(*flat1104) return nil } else { _dollar_dollar := msg - fields1092 := []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_fields1093 := fields1092 + fields1094 := []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_fields1095 := fields1094 p.write("(") p.write("datetime") p.indentSexp() p.newline() - field1094 := unwrapped_fields1093[0].(int64) - p.write(fmt.Sprintf("%d", field1094)) - p.newline() - field1095 := unwrapped_fields1093[1].(int64) - p.write(fmt.Sprintf("%d", field1095)) - p.newline() - field1096 := unwrapped_fields1093[2].(int64) + field1096 := unwrapped_fields1095[0].(int64) p.write(fmt.Sprintf("%d", field1096)) p.newline() - field1097 := unwrapped_fields1093[3].(int64) + field1097 := unwrapped_fields1095[1].(int64) p.write(fmt.Sprintf("%d", field1097)) p.newline() - field1098 := unwrapped_fields1093[4].(int64) + field1098 := unwrapped_fields1095[2].(int64) p.write(fmt.Sprintf("%d", field1098)) p.newline() - field1099 := unwrapped_fields1093[5].(int64) + field1099 := unwrapped_fields1095[3].(int64) p.write(fmt.Sprintf("%d", field1099)) - field1100 := unwrapped_fields1093[6].(*int64) - if field1100 != nil { + p.newline() + field1100 := unwrapped_fields1095[4].(int64) + p.write(fmt.Sprintf("%d", field1100)) + p.newline() + field1101 := unwrapped_fields1095[5].(int64) + p.write(fmt.Sprintf("%d", field1101)) + field1102 := unwrapped_fields1095[6].(*int64) + if field1102 != nil { p.newline() - opt_val1101 := *field1100 - p.write(fmt.Sprintf("%d", opt_val1101)) + opt_val1103 := *field1102 + p.write(fmt.Sprintf("%d", opt_val1103)) } p.dedent() p.write(")") @@ -2197,24 +2197,24 @@ func (p *PrettyPrinter) pretty_datetime(msg *pb.DateTimeValue) interface{} { } func (p *PrettyPrinter) pretty_conjunction(msg *pb.Conjunction) interface{} { - flat1107 := p.tryFlat(msg, func() { p.pretty_conjunction(msg) }) - if flat1107 != nil { - p.write(*flat1107) + flat1109 := p.tryFlat(msg, func() { p.pretty_conjunction(msg) }) + if flat1109 != nil { + p.write(*flat1109) return nil } else { _dollar_dollar := msg - fields1103 := _dollar_dollar.GetArgs() - unwrapped_fields1104 := fields1103 + fields1105 := _dollar_dollar.GetArgs() + unwrapped_fields1106 := fields1105 p.write("(") p.write("and") p.indentSexp() - if !(len(unwrapped_fields1104) == 0) { + if !(len(unwrapped_fields1106) == 0) { p.newline() - for i1106, elem1105 := range unwrapped_fields1104 { - if (i1106 > 0) { + for i1108, elem1107 := range unwrapped_fields1106 { + if (i1108 > 0) { p.newline() } - p.pretty_formula(elem1105) + p.pretty_formula(elem1107) } } p.dedent() @@ -2224,24 +2224,24 @@ func (p *PrettyPrinter) pretty_conjunction(msg *pb.Conjunction) interface{} { } func (p *PrettyPrinter) pretty_disjunction(msg *pb.Disjunction) interface{} { - flat1112 := p.tryFlat(msg, func() { p.pretty_disjunction(msg) }) - if flat1112 != nil { - p.write(*flat1112) + flat1114 := p.tryFlat(msg, func() { p.pretty_disjunction(msg) }) + if flat1114 != nil { + p.write(*flat1114) return nil } else { _dollar_dollar := msg - fields1108 := _dollar_dollar.GetArgs() - unwrapped_fields1109 := fields1108 + fields1110 := _dollar_dollar.GetArgs() + unwrapped_fields1111 := fields1110 p.write("(") p.write("or") p.indentSexp() - if !(len(unwrapped_fields1109) == 0) { + if !(len(unwrapped_fields1111) == 0) { p.newline() - for i1111, elem1110 := range unwrapped_fields1109 { - if (i1111 > 0) { + for i1113, elem1112 := range unwrapped_fields1111 { + if (i1113 > 0) { p.newline() } - p.pretty_formula(elem1110) + p.pretty_formula(elem1112) } } p.dedent() @@ -2251,19 +2251,19 @@ func (p *PrettyPrinter) pretty_disjunction(msg *pb.Disjunction) interface{} { } func (p *PrettyPrinter) pretty_not(msg *pb.Not) interface{} { - flat1115 := p.tryFlat(msg, func() { p.pretty_not(msg) }) - if flat1115 != nil { - p.write(*flat1115) + flat1117 := p.tryFlat(msg, func() { p.pretty_not(msg) }) + if flat1117 != nil { + p.write(*flat1117) return nil } else { _dollar_dollar := msg - fields1113 := _dollar_dollar.GetArg() - unwrapped_fields1114 := fields1113 + fields1115 := _dollar_dollar.GetArg() + unwrapped_fields1116 := fields1115 p.write("(") p.write("not") p.indentSexp() p.newline() - p.pretty_formula(unwrapped_fields1114) + p.pretty_formula(unwrapped_fields1116) p.dedent() p.write(")") } @@ -2271,26 +2271,26 @@ func (p *PrettyPrinter) pretty_not(msg *pb.Not) interface{} { } func (p *PrettyPrinter) pretty_ffi(msg *pb.FFI) interface{} { - flat1121 := p.tryFlat(msg, func() { p.pretty_ffi(msg) }) - if flat1121 != nil { - p.write(*flat1121) + flat1123 := p.tryFlat(msg, func() { p.pretty_ffi(msg) }) + if flat1123 != nil { + p.write(*flat1123) return nil } else { _dollar_dollar := msg - fields1116 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetArgs(), _dollar_dollar.GetTerms()} - unwrapped_fields1117 := fields1116 + fields1118 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetArgs(), _dollar_dollar.GetTerms()} + unwrapped_fields1119 := fields1118 p.write("(") p.write("ffi") p.indentSexp() p.newline() - field1118 := unwrapped_fields1117[0].(string) - p.pretty_name(field1118) + field1120 := unwrapped_fields1119[0].(string) + p.pretty_name(field1120) p.newline() - field1119 := unwrapped_fields1117[1].([]*pb.Abstraction) - p.pretty_ffi_args(field1119) + field1121 := unwrapped_fields1119[1].([]*pb.Abstraction) + p.pretty_ffi_args(field1121) p.newline() - field1120 := unwrapped_fields1117[2].([]*pb.Term) - p.pretty_terms(field1120) + field1122 := unwrapped_fields1119[2].([]*pb.Term) + p.pretty_terms(field1122) p.dedent() p.write(")") } @@ -2298,35 +2298,35 @@ func (p *PrettyPrinter) pretty_ffi(msg *pb.FFI) interface{} { } func (p *PrettyPrinter) pretty_name(msg string) interface{} { - flat1123 := p.tryFlat(msg, func() { p.pretty_name(msg) }) - if flat1123 != nil { - p.write(*flat1123) + flat1125 := p.tryFlat(msg, func() { p.pretty_name(msg) }) + if flat1125 != nil { + p.write(*flat1125) return nil } else { - fields1122 := msg + fields1124 := msg p.write(":") - p.write(fields1122) + p.write(fields1124) } return nil } func (p *PrettyPrinter) pretty_ffi_args(msg []*pb.Abstraction) interface{} { - flat1127 := p.tryFlat(msg, func() { p.pretty_ffi_args(msg) }) - if flat1127 != nil { - p.write(*flat1127) + flat1129 := p.tryFlat(msg, func() { p.pretty_ffi_args(msg) }) + if flat1129 != nil { + p.write(*flat1129) return nil } else { - fields1124 := msg + fields1126 := msg p.write("(") p.write("args") p.indentSexp() - if !(len(fields1124) == 0) { + if !(len(fields1126) == 0) { p.newline() - for i1126, elem1125 := range fields1124 { - if (i1126 > 0) { + for i1128, elem1127 := range fields1126 { + if (i1128 > 0) { p.newline() } - p.pretty_abstraction(elem1125) + p.pretty_abstraction(elem1127) } } p.dedent() @@ -2336,28 +2336,28 @@ func (p *PrettyPrinter) pretty_ffi_args(msg []*pb.Abstraction) interface{} { } func (p *PrettyPrinter) pretty_atom(msg *pb.Atom) interface{} { - flat1134 := p.tryFlat(msg, func() { p.pretty_atom(msg) }) - if flat1134 != nil { - p.write(*flat1134) + flat1136 := p.tryFlat(msg, func() { p.pretty_atom(msg) }) + if flat1136 != nil { + p.write(*flat1136) return nil } else { _dollar_dollar := msg - fields1128 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetTerms()} - unwrapped_fields1129 := fields1128 + fields1130 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetTerms()} + unwrapped_fields1131 := fields1130 p.write("(") p.write("atom") p.indentSexp() p.newline() - field1130 := unwrapped_fields1129[0].(*pb.RelationId) - p.pretty_relation_id(field1130) - field1131 := unwrapped_fields1129[1].([]*pb.Term) - if !(len(field1131) == 0) { + field1132 := unwrapped_fields1131[0].(*pb.RelationId) + p.pretty_relation_id(field1132) + field1133 := unwrapped_fields1131[1].([]*pb.Term) + if !(len(field1133) == 0) { p.newline() - for i1133, elem1132 := range field1131 { - if (i1133 > 0) { + for i1135, elem1134 := range field1133 { + if (i1135 > 0) { p.newline() } - p.pretty_term(elem1132) + p.pretty_term(elem1134) } } p.dedent() @@ -2367,28 +2367,28 @@ func (p *PrettyPrinter) pretty_atom(msg *pb.Atom) interface{} { } func (p *PrettyPrinter) pretty_pragma(msg *pb.Pragma) interface{} { - flat1141 := p.tryFlat(msg, func() { p.pretty_pragma(msg) }) - if flat1141 != nil { - p.write(*flat1141) + flat1143 := p.tryFlat(msg, func() { p.pretty_pragma(msg) }) + if flat1143 != nil { + p.write(*flat1143) return nil } else { _dollar_dollar := msg - fields1135 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetTerms()} - unwrapped_fields1136 := fields1135 + fields1137 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetTerms()} + unwrapped_fields1138 := fields1137 p.write("(") p.write("pragma") p.indentSexp() p.newline() - field1137 := unwrapped_fields1136[0].(string) - p.pretty_name(field1137) - field1138 := unwrapped_fields1136[1].([]*pb.Term) - if !(len(field1138) == 0) { + field1139 := unwrapped_fields1138[0].(string) + p.pretty_name(field1139) + field1140 := unwrapped_fields1138[1].([]*pb.Term) + if !(len(field1140) == 0) { p.newline() - for i1140, elem1139 := range field1138 { - if (i1140 > 0) { + for i1142, elem1141 := range field1140 { + if (i1142 > 0) { p.newline() } - p.pretty_term(elem1139) + p.pretty_term(elem1141) } } p.dedent() @@ -2398,109 +2398,109 @@ func (p *PrettyPrinter) pretty_pragma(msg *pb.Pragma) interface{} { } func (p *PrettyPrinter) pretty_primitive(msg *pb.Primitive) interface{} { - flat1157 := p.tryFlat(msg, func() { p.pretty_primitive(msg) }) - if flat1157 != nil { - p.write(*flat1157) + flat1159 := p.tryFlat(msg, func() { p.pretty_primitive(msg) }) + if flat1159 != nil { + p.write(*flat1159) return nil } else { _dollar_dollar := msg - var _t1693 []interface{} + var _t1697 []interface{} if _dollar_dollar.GetName() == "rel_primitive_eq" { - _t1693 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} + _t1697 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} } - guard_result1156 := _t1693 - if guard_result1156 != nil { + guard_result1158 := _t1697 + if guard_result1158 != nil { p.pretty_eq(msg) } else { _dollar_dollar := msg - var _t1694 []interface{} + var _t1698 []interface{} if _dollar_dollar.GetName() == "rel_primitive_lt_monotype" { - _t1694 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} + _t1698 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} } - guard_result1155 := _t1694 - if guard_result1155 != nil { + guard_result1157 := _t1698 + if guard_result1157 != nil { p.pretty_lt(msg) } else { _dollar_dollar := msg - var _t1695 []interface{} + var _t1699 []interface{} if _dollar_dollar.GetName() == "rel_primitive_lt_eq_monotype" { - _t1695 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} + _t1699 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} } - guard_result1154 := _t1695 - if guard_result1154 != nil { + guard_result1156 := _t1699 + if guard_result1156 != nil { p.pretty_lt_eq(msg) } else { _dollar_dollar := msg - var _t1696 []interface{} + var _t1700 []interface{} if _dollar_dollar.GetName() == "rel_primitive_gt_monotype" { - _t1696 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} + _t1700 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} } - guard_result1153 := _t1696 - if guard_result1153 != nil { + guard_result1155 := _t1700 + if guard_result1155 != nil { p.pretty_gt(msg) } else { _dollar_dollar := msg - var _t1697 []interface{} + var _t1701 []interface{} if _dollar_dollar.GetName() == "rel_primitive_gt_eq_monotype" { - _t1697 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} + _t1701 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} } - guard_result1152 := _t1697 - if guard_result1152 != nil { + guard_result1154 := _t1701 + if guard_result1154 != nil { p.pretty_gt_eq(msg) } else { _dollar_dollar := msg - var _t1698 []interface{} + var _t1702 []interface{} if _dollar_dollar.GetName() == "rel_primitive_add_monotype" { - _t1698 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} + _t1702 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} } - guard_result1151 := _t1698 - if guard_result1151 != nil { + guard_result1153 := _t1702 + if guard_result1153 != nil { p.pretty_add(msg) } else { _dollar_dollar := msg - var _t1699 []interface{} + var _t1703 []interface{} if _dollar_dollar.GetName() == "rel_primitive_subtract_monotype" { - _t1699 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} + _t1703 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} } - guard_result1150 := _t1699 - if guard_result1150 != nil { + guard_result1152 := _t1703 + if guard_result1152 != nil { p.pretty_minus(msg) } else { _dollar_dollar := msg - var _t1700 []interface{} + var _t1704 []interface{} if _dollar_dollar.GetName() == "rel_primitive_multiply_monotype" { - _t1700 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} + _t1704 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} } - guard_result1149 := _t1700 - if guard_result1149 != nil { + guard_result1151 := _t1704 + if guard_result1151 != nil { p.pretty_multiply(msg) } else { _dollar_dollar := msg - var _t1701 []interface{} + var _t1705 []interface{} if _dollar_dollar.GetName() == "rel_primitive_divide_monotype" { - _t1701 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} + _t1705 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} } - guard_result1148 := _t1701 - if guard_result1148 != nil { + guard_result1150 := _t1705 + if guard_result1150 != nil { p.pretty_divide(msg) } else { _dollar_dollar := msg - fields1142 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetTerms()} - unwrapped_fields1143 := fields1142 + fields1144 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetTerms()} + unwrapped_fields1145 := fields1144 p.write("(") p.write("primitive") p.indentSexp() p.newline() - field1144 := unwrapped_fields1143[0].(string) - p.pretty_name(field1144) - field1145 := unwrapped_fields1143[1].([]*pb.RelTerm) - if !(len(field1145) == 0) { + field1146 := unwrapped_fields1145[0].(string) + p.pretty_name(field1146) + field1147 := unwrapped_fields1145[1].([]*pb.RelTerm) + if !(len(field1147) == 0) { p.newline() - for i1147, elem1146 := range field1145 { - if (i1147 > 0) { + for i1149, elem1148 := range field1147 { + if (i1149 > 0) { p.newline() } - p.pretty_rel_term(elem1146) + p.pretty_rel_term(elem1148) } } p.dedent() @@ -2519,27 +2519,27 @@ func (p *PrettyPrinter) pretty_primitive(msg *pb.Primitive) interface{} { } func (p *PrettyPrinter) pretty_eq(msg *pb.Primitive) interface{} { - flat1162 := p.tryFlat(msg, func() { p.pretty_eq(msg) }) - if flat1162 != nil { - p.write(*flat1162) + flat1164 := p.tryFlat(msg, func() { p.pretty_eq(msg) }) + if flat1164 != nil { + p.write(*flat1164) return nil } else { _dollar_dollar := msg - var _t1702 []interface{} + var _t1706 []interface{} if _dollar_dollar.GetName() == "rel_primitive_eq" { - _t1702 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} + _t1706 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} } - fields1158 := _t1702 - unwrapped_fields1159 := fields1158 + fields1160 := _t1706 + unwrapped_fields1161 := fields1160 p.write("(") p.write("=") p.indentSexp() p.newline() - field1160 := unwrapped_fields1159[0].(*pb.Term) - p.pretty_term(field1160) + field1162 := unwrapped_fields1161[0].(*pb.Term) + p.pretty_term(field1162) p.newline() - field1161 := unwrapped_fields1159[1].(*pb.Term) - p.pretty_term(field1161) + field1163 := unwrapped_fields1161[1].(*pb.Term) + p.pretty_term(field1163) p.dedent() p.write(")") } @@ -2547,27 +2547,27 @@ func (p *PrettyPrinter) pretty_eq(msg *pb.Primitive) interface{} { } func (p *PrettyPrinter) pretty_lt(msg *pb.Primitive) interface{} { - flat1167 := p.tryFlat(msg, func() { p.pretty_lt(msg) }) - if flat1167 != nil { - p.write(*flat1167) + flat1169 := p.tryFlat(msg, func() { p.pretty_lt(msg) }) + if flat1169 != nil { + p.write(*flat1169) return nil } else { _dollar_dollar := msg - var _t1703 []interface{} + var _t1707 []interface{} if _dollar_dollar.GetName() == "rel_primitive_lt_monotype" { - _t1703 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} + _t1707 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} } - fields1163 := _t1703 - unwrapped_fields1164 := fields1163 + fields1165 := _t1707 + unwrapped_fields1166 := fields1165 p.write("(") p.write("<") p.indentSexp() p.newline() - field1165 := unwrapped_fields1164[0].(*pb.Term) - p.pretty_term(field1165) + field1167 := unwrapped_fields1166[0].(*pb.Term) + p.pretty_term(field1167) p.newline() - field1166 := unwrapped_fields1164[1].(*pb.Term) - p.pretty_term(field1166) + field1168 := unwrapped_fields1166[1].(*pb.Term) + p.pretty_term(field1168) p.dedent() p.write(")") } @@ -2575,27 +2575,27 @@ func (p *PrettyPrinter) pretty_lt(msg *pb.Primitive) interface{} { } func (p *PrettyPrinter) pretty_lt_eq(msg *pb.Primitive) interface{} { - flat1172 := p.tryFlat(msg, func() { p.pretty_lt_eq(msg) }) - if flat1172 != nil { - p.write(*flat1172) + flat1174 := p.tryFlat(msg, func() { p.pretty_lt_eq(msg) }) + if flat1174 != nil { + p.write(*flat1174) return nil } else { _dollar_dollar := msg - var _t1704 []interface{} + var _t1708 []interface{} if _dollar_dollar.GetName() == "rel_primitive_lt_eq_monotype" { - _t1704 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} + _t1708 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} } - fields1168 := _t1704 - unwrapped_fields1169 := fields1168 + fields1170 := _t1708 + unwrapped_fields1171 := fields1170 p.write("(") p.write("<=") p.indentSexp() p.newline() - field1170 := unwrapped_fields1169[0].(*pb.Term) - p.pretty_term(field1170) + field1172 := unwrapped_fields1171[0].(*pb.Term) + p.pretty_term(field1172) p.newline() - field1171 := unwrapped_fields1169[1].(*pb.Term) - p.pretty_term(field1171) + field1173 := unwrapped_fields1171[1].(*pb.Term) + p.pretty_term(field1173) p.dedent() p.write(")") } @@ -2603,27 +2603,27 @@ func (p *PrettyPrinter) pretty_lt_eq(msg *pb.Primitive) interface{} { } func (p *PrettyPrinter) pretty_gt(msg *pb.Primitive) interface{} { - flat1177 := p.tryFlat(msg, func() { p.pretty_gt(msg) }) - if flat1177 != nil { - p.write(*flat1177) + flat1179 := p.tryFlat(msg, func() { p.pretty_gt(msg) }) + if flat1179 != nil { + p.write(*flat1179) return nil } else { _dollar_dollar := msg - var _t1705 []interface{} + var _t1709 []interface{} if _dollar_dollar.GetName() == "rel_primitive_gt_monotype" { - _t1705 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} + _t1709 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} } - fields1173 := _t1705 - unwrapped_fields1174 := fields1173 + fields1175 := _t1709 + unwrapped_fields1176 := fields1175 p.write("(") p.write(">") p.indentSexp() p.newline() - field1175 := unwrapped_fields1174[0].(*pb.Term) - p.pretty_term(field1175) + field1177 := unwrapped_fields1176[0].(*pb.Term) + p.pretty_term(field1177) p.newline() - field1176 := unwrapped_fields1174[1].(*pb.Term) - p.pretty_term(field1176) + field1178 := unwrapped_fields1176[1].(*pb.Term) + p.pretty_term(field1178) p.dedent() p.write(")") } @@ -2631,27 +2631,27 @@ func (p *PrettyPrinter) pretty_gt(msg *pb.Primitive) interface{} { } func (p *PrettyPrinter) pretty_gt_eq(msg *pb.Primitive) interface{} { - flat1182 := p.tryFlat(msg, func() { p.pretty_gt_eq(msg) }) - if flat1182 != nil { - p.write(*flat1182) + flat1184 := p.tryFlat(msg, func() { p.pretty_gt_eq(msg) }) + if flat1184 != nil { + p.write(*flat1184) return nil } else { _dollar_dollar := msg - var _t1706 []interface{} + var _t1710 []interface{} if _dollar_dollar.GetName() == "rel_primitive_gt_eq_monotype" { - _t1706 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} + _t1710 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} } - fields1178 := _t1706 - unwrapped_fields1179 := fields1178 + fields1180 := _t1710 + unwrapped_fields1181 := fields1180 p.write("(") p.write(">=") p.indentSexp() p.newline() - field1180 := unwrapped_fields1179[0].(*pb.Term) - p.pretty_term(field1180) + field1182 := unwrapped_fields1181[0].(*pb.Term) + p.pretty_term(field1182) p.newline() - field1181 := unwrapped_fields1179[1].(*pb.Term) - p.pretty_term(field1181) + field1183 := unwrapped_fields1181[1].(*pb.Term) + p.pretty_term(field1183) p.dedent() p.write(")") } @@ -2659,30 +2659,30 @@ func (p *PrettyPrinter) pretty_gt_eq(msg *pb.Primitive) interface{} { } func (p *PrettyPrinter) pretty_add(msg *pb.Primitive) interface{} { - flat1188 := p.tryFlat(msg, func() { p.pretty_add(msg) }) - if flat1188 != nil { - p.write(*flat1188) + flat1190 := p.tryFlat(msg, func() { p.pretty_add(msg) }) + if flat1190 != nil { + p.write(*flat1190) return nil } else { _dollar_dollar := msg - var _t1707 []interface{} + var _t1711 []interface{} if _dollar_dollar.GetName() == "rel_primitive_add_monotype" { - _t1707 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} + _t1711 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} } - fields1183 := _t1707 - unwrapped_fields1184 := fields1183 + fields1185 := _t1711 + unwrapped_fields1186 := fields1185 p.write("(") p.write("+") p.indentSexp() p.newline() - field1185 := unwrapped_fields1184[0].(*pb.Term) - p.pretty_term(field1185) + field1187 := unwrapped_fields1186[0].(*pb.Term) + p.pretty_term(field1187) p.newline() - field1186 := unwrapped_fields1184[1].(*pb.Term) - p.pretty_term(field1186) + field1188 := unwrapped_fields1186[1].(*pb.Term) + p.pretty_term(field1188) p.newline() - field1187 := unwrapped_fields1184[2].(*pb.Term) - p.pretty_term(field1187) + field1189 := unwrapped_fields1186[2].(*pb.Term) + p.pretty_term(field1189) p.dedent() p.write(")") } @@ -2690,30 +2690,30 @@ func (p *PrettyPrinter) pretty_add(msg *pb.Primitive) interface{} { } func (p *PrettyPrinter) pretty_minus(msg *pb.Primitive) interface{} { - flat1194 := p.tryFlat(msg, func() { p.pretty_minus(msg) }) - if flat1194 != nil { - p.write(*flat1194) + flat1196 := p.tryFlat(msg, func() { p.pretty_minus(msg) }) + if flat1196 != nil { + p.write(*flat1196) return nil } else { _dollar_dollar := msg - var _t1708 []interface{} + var _t1712 []interface{} if _dollar_dollar.GetName() == "rel_primitive_subtract_monotype" { - _t1708 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} + _t1712 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} } - fields1189 := _t1708 - unwrapped_fields1190 := fields1189 + fields1191 := _t1712 + unwrapped_fields1192 := fields1191 p.write("(") p.write("-") p.indentSexp() p.newline() - field1191 := unwrapped_fields1190[0].(*pb.Term) - p.pretty_term(field1191) + field1193 := unwrapped_fields1192[0].(*pb.Term) + p.pretty_term(field1193) p.newline() - field1192 := unwrapped_fields1190[1].(*pb.Term) - p.pretty_term(field1192) + field1194 := unwrapped_fields1192[1].(*pb.Term) + p.pretty_term(field1194) p.newline() - field1193 := unwrapped_fields1190[2].(*pb.Term) - p.pretty_term(field1193) + field1195 := unwrapped_fields1192[2].(*pb.Term) + p.pretty_term(field1195) p.dedent() p.write(")") } @@ -2721,30 +2721,30 @@ func (p *PrettyPrinter) pretty_minus(msg *pb.Primitive) interface{} { } func (p *PrettyPrinter) pretty_multiply(msg *pb.Primitive) interface{} { - flat1200 := p.tryFlat(msg, func() { p.pretty_multiply(msg) }) - if flat1200 != nil { - p.write(*flat1200) + flat1202 := p.tryFlat(msg, func() { p.pretty_multiply(msg) }) + if flat1202 != nil { + p.write(*flat1202) return nil } else { _dollar_dollar := msg - var _t1709 []interface{} + var _t1713 []interface{} if _dollar_dollar.GetName() == "rel_primitive_multiply_monotype" { - _t1709 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} + _t1713 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} } - fields1195 := _t1709 - unwrapped_fields1196 := fields1195 + fields1197 := _t1713 + unwrapped_fields1198 := fields1197 p.write("(") p.write("*") p.indentSexp() p.newline() - field1197 := unwrapped_fields1196[0].(*pb.Term) - p.pretty_term(field1197) + field1199 := unwrapped_fields1198[0].(*pb.Term) + p.pretty_term(field1199) p.newline() - field1198 := unwrapped_fields1196[1].(*pb.Term) - p.pretty_term(field1198) + field1200 := unwrapped_fields1198[1].(*pb.Term) + p.pretty_term(field1200) p.newline() - field1199 := unwrapped_fields1196[2].(*pb.Term) - p.pretty_term(field1199) + field1201 := unwrapped_fields1198[2].(*pb.Term) + p.pretty_term(field1201) p.dedent() p.write(")") } @@ -2752,30 +2752,30 @@ func (p *PrettyPrinter) pretty_multiply(msg *pb.Primitive) interface{} { } func (p *PrettyPrinter) pretty_divide(msg *pb.Primitive) interface{} { - flat1206 := p.tryFlat(msg, func() { p.pretty_divide(msg) }) - if flat1206 != nil { - p.write(*flat1206) + flat1208 := p.tryFlat(msg, func() { p.pretty_divide(msg) }) + if flat1208 != nil { + p.write(*flat1208) return nil } else { _dollar_dollar := msg - var _t1710 []interface{} + var _t1714 []interface{} if _dollar_dollar.GetName() == "rel_primitive_divide_monotype" { - _t1710 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} + _t1714 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} } - fields1201 := _t1710 - unwrapped_fields1202 := fields1201 + fields1203 := _t1714 + unwrapped_fields1204 := fields1203 p.write("(") p.write("/") p.indentSexp() p.newline() - field1203 := unwrapped_fields1202[0].(*pb.Term) - p.pretty_term(field1203) + field1205 := unwrapped_fields1204[0].(*pb.Term) + p.pretty_term(field1205) p.newline() - field1204 := unwrapped_fields1202[1].(*pb.Term) - p.pretty_term(field1204) + field1206 := unwrapped_fields1204[1].(*pb.Term) + p.pretty_term(field1206) p.newline() - field1205 := unwrapped_fields1202[2].(*pb.Term) - p.pretty_term(field1205) + field1207 := unwrapped_fields1204[2].(*pb.Term) + p.pretty_term(field1207) p.dedent() p.write(")") } @@ -2783,30 +2783,30 @@ func (p *PrettyPrinter) pretty_divide(msg *pb.Primitive) interface{} { } func (p *PrettyPrinter) pretty_rel_term(msg *pb.RelTerm) interface{} { - flat1211 := p.tryFlat(msg, func() { p.pretty_rel_term(msg) }) - if flat1211 != nil { - p.write(*flat1211) + flat1213 := p.tryFlat(msg, func() { p.pretty_rel_term(msg) }) + if flat1213 != nil { + p.write(*flat1213) return nil } else { _dollar_dollar := msg - var _t1711 *pb.Value + var _t1715 *pb.Value if hasProtoField(_dollar_dollar, "specialized_value") { - _t1711 = _dollar_dollar.GetSpecializedValue() + _t1715 = _dollar_dollar.GetSpecializedValue() } - deconstruct_result1209 := _t1711 - if deconstruct_result1209 != nil { - unwrapped1210 := deconstruct_result1209 - p.pretty_specialized_value(unwrapped1210) + deconstruct_result1211 := _t1715 + if deconstruct_result1211 != nil { + unwrapped1212 := deconstruct_result1211 + p.pretty_specialized_value(unwrapped1212) } else { _dollar_dollar := msg - var _t1712 *pb.Term + var _t1716 *pb.Term if hasProtoField(_dollar_dollar, "term") { - _t1712 = _dollar_dollar.GetTerm() + _t1716 = _dollar_dollar.GetTerm() } - deconstruct_result1207 := _t1712 - if deconstruct_result1207 != nil { - unwrapped1208 := deconstruct_result1207 - p.pretty_term(unwrapped1208) + deconstruct_result1209 := _t1716 + if deconstruct_result1209 != nil { + unwrapped1210 := deconstruct_result1209 + p.pretty_term(unwrapped1210) } else { panic(ParseError{msg: "No matching rule for rel_term"}) } @@ -2816,41 +2816,41 @@ func (p *PrettyPrinter) pretty_rel_term(msg *pb.RelTerm) interface{} { } func (p *PrettyPrinter) pretty_specialized_value(msg *pb.Value) interface{} { - flat1213 := p.tryFlat(msg, func() { p.pretty_specialized_value(msg) }) - if flat1213 != nil { - p.write(*flat1213) + flat1215 := p.tryFlat(msg, func() { p.pretty_specialized_value(msg) }) + if flat1215 != nil { + p.write(*flat1215) return nil } else { - fields1212 := msg + fields1214 := msg p.write("#") - p.pretty_raw_value(fields1212) + p.pretty_raw_value(fields1214) } return nil } func (p *PrettyPrinter) pretty_rel_atom(msg *pb.RelAtom) interface{} { - flat1220 := p.tryFlat(msg, func() { p.pretty_rel_atom(msg) }) - if flat1220 != nil { - p.write(*flat1220) + flat1222 := p.tryFlat(msg, func() { p.pretty_rel_atom(msg) }) + if flat1222 != nil { + p.write(*flat1222) return nil } else { _dollar_dollar := msg - fields1214 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetTerms()} - unwrapped_fields1215 := fields1214 + fields1216 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetTerms()} + unwrapped_fields1217 := fields1216 p.write("(") p.write("relatom") p.indentSexp() p.newline() - field1216 := unwrapped_fields1215[0].(string) - p.pretty_name(field1216) - field1217 := unwrapped_fields1215[1].([]*pb.RelTerm) - if !(len(field1217) == 0) { + field1218 := unwrapped_fields1217[0].(string) + p.pretty_name(field1218) + field1219 := unwrapped_fields1217[1].([]*pb.RelTerm) + if !(len(field1219) == 0) { p.newline() - for i1219, elem1218 := range field1217 { - if (i1219 > 0) { + for i1221, elem1220 := range field1219 { + if (i1221 > 0) { p.newline() } - p.pretty_rel_term(elem1218) + p.pretty_rel_term(elem1220) } } p.dedent() @@ -2860,23 +2860,23 @@ func (p *PrettyPrinter) pretty_rel_atom(msg *pb.RelAtom) interface{} { } func (p *PrettyPrinter) pretty_cast(msg *pb.Cast) interface{} { - flat1225 := p.tryFlat(msg, func() { p.pretty_cast(msg) }) - if flat1225 != nil { - p.write(*flat1225) + flat1227 := p.tryFlat(msg, func() { p.pretty_cast(msg) }) + if flat1227 != nil { + p.write(*flat1227) return nil } else { _dollar_dollar := msg - fields1221 := []interface{}{_dollar_dollar.GetInput(), _dollar_dollar.GetResult()} - unwrapped_fields1222 := fields1221 + fields1223 := []interface{}{_dollar_dollar.GetInput(), _dollar_dollar.GetResult()} + unwrapped_fields1224 := fields1223 p.write("(") p.write("cast") p.indentSexp() p.newline() - field1223 := unwrapped_fields1222[0].(*pb.Term) - p.pretty_term(field1223) + field1225 := unwrapped_fields1224[0].(*pb.Term) + p.pretty_term(field1225) p.newline() - field1224 := unwrapped_fields1222[1].(*pb.Term) - p.pretty_term(field1224) + field1226 := unwrapped_fields1224[1].(*pb.Term) + p.pretty_term(field1226) p.dedent() p.write(")") } @@ -2884,22 +2884,22 @@ func (p *PrettyPrinter) pretty_cast(msg *pb.Cast) interface{} { } func (p *PrettyPrinter) pretty_attrs(msg []*pb.Attribute) interface{} { - flat1229 := p.tryFlat(msg, func() { p.pretty_attrs(msg) }) - if flat1229 != nil { - p.write(*flat1229) + flat1231 := p.tryFlat(msg, func() { p.pretty_attrs(msg) }) + if flat1231 != nil { + p.write(*flat1231) return nil } else { - fields1226 := msg + fields1228 := msg p.write("(") p.write("attrs") p.indentSexp() - if !(len(fields1226) == 0) { + if !(len(fields1228) == 0) { p.newline() - for i1228, elem1227 := range fields1226 { - if (i1228 > 0) { + for i1230, elem1229 := range fields1228 { + if (i1230 > 0) { p.newline() } - p.pretty_attribute(elem1227) + p.pretty_attribute(elem1229) } } p.dedent() @@ -2909,28 +2909,28 @@ func (p *PrettyPrinter) pretty_attrs(msg []*pb.Attribute) interface{} { } func (p *PrettyPrinter) pretty_attribute(msg *pb.Attribute) interface{} { - flat1236 := p.tryFlat(msg, func() { p.pretty_attribute(msg) }) - if flat1236 != nil { - p.write(*flat1236) + flat1238 := p.tryFlat(msg, func() { p.pretty_attribute(msg) }) + if flat1238 != nil { + p.write(*flat1238) return nil } else { _dollar_dollar := msg - fields1230 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetArgs()} - unwrapped_fields1231 := fields1230 + fields1232 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetArgs()} + unwrapped_fields1233 := fields1232 p.write("(") p.write("attribute") p.indentSexp() p.newline() - field1232 := unwrapped_fields1231[0].(string) - p.pretty_name(field1232) - field1233 := unwrapped_fields1231[1].([]*pb.Value) - if !(len(field1233) == 0) { + field1234 := unwrapped_fields1233[0].(string) + p.pretty_name(field1234) + field1235 := unwrapped_fields1233[1].([]*pb.Value) + if !(len(field1235) == 0) { p.newline() - for i1235, elem1234 := range field1233 { - if (i1235 > 0) { + for i1237, elem1236 := range field1235 { + if (i1237 > 0) { p.newline() } - p.pretty_raw_value(elem1234) + p.pretty_raw_value(elem1236) } } p.dedent() @@ -2940,39 +2940,39 @@ func (p *PrettyPrinter) pretty_attribute(msg *pb.Attribute) interface{} { } func (p *PrettyPrinter) pretty_algorithm(msg *pb.Algorithm) interface{} { - flat1245 := p.tryFlat(msg, func() { p.pretty_algorithm(msg) }) - if flat1245 != nil { - p.write(*flat1245) + flat1247 := p.tryFlat(msg, func() { p.pretty_algorithm(msg) }) + if flat1247 != nil { + p.write(*flat1247) return nil } else { _dollar_dollar := msg - var _t1713 []*pb.Attribute + var _t1717 []*pb.Attribute if !(len(_dollar_dollar.GetAttrs()) == 0) { - _t1713 = _dollar_dollar.GetAttrs() + _t1717 = _dollar_dollar.GetAttrs() } - fields1237 := []interface{}{_dollar_dollar.GetGlobal(), _dollar_dollar.GetBody(), _t1713} - unwrapped_fields1238 := fields1237 + fields1239 := []interface{}{_dollar_dollar.GetGlobal(), _dollar_dollar.GetBody(), _t1717} + unwrapped_fields1240 := fields1239 p.write("(") p.write("algorithm") p.indentSexp() - field1239 := unwrapped_fields1238[0].([]*pb.RelationId) - if !(len(field1239) == 0) { + field1241 := unwrapped_fields1240[0].([]*pb.RelationId) + if !(len(field1241) == 0) { p.newline() - for i1241, elem1240 := range field1239 { - if (i1241 > 0) { + for i1243, elem1242 := range field1241 { + if (i1243 > 0) { p.newline() } - p.pretty_relation_id(elem1240) + p.pretty_relation_id(elem1242) } } p.newline() - field1242 := unwrapped_fields1238[1].(*pb.Script) - p.pretty_script(field1242) - field1243 := unwrapped_fields1238[2].([]*pb.Attribute) - if field1243 != nil { + field1244 := unwrapped_fields1240[1].(*pb.Script) + p.pretty_script(field1244) + field1245 := unwrapped_fields1240[2].([]*pb.Attribute) + if field1245 != nil { p.newline() - opt_val1244 := field1243 - p.pretty_attrs(opt_val1244) + opt_val1246 := field1245 + p.pretty_attrs(opt_val1246) } p.dedent() p.write(")") @@ -2981,24 +2981,24 @@ func (p *PrettyPrinter) pretty_algorithm(msg *pb.Algorithm) interface{} { } func (p *PrettyPrinter) pretty_script(msg *pb.Script) interface{} { - flat1250 := p.tryFlat(msg, func() { p.pretty_script(msg) }) - if flat1250 != nil { - p.write(*flat1250) + flat1252 := p.tryFlat(msg, func() { p.pretty_script(msg) }) + if flat1252 != nil { + p.write(*flat1252) return nil } else { _dollar_dollar := msg - fields1246 := _dollar_dollar.GetConstructs() - unwrapped_fields1247 := fields1246 + fields1248 := _dollar_dollar.GetConstructs() + unwrapped_fields1249 := fields1248 p.write("(") p.write("script") p.indentSexp() - if !(len(unwrapped_fields1247) == 0) { + if !(len(unwrapped_fields1249) == 0) { p.newline() - for i1249, elem1248 := range unwrapped_fields1247 { - if (i1249 > 0) { + for i1251, elem1250 := range unwrapped_fields1249 { + if (i1251 > 0) { p.newline() } - p.pretty_construct(elem1248) + p.pretty_construct(elem1250) } } p.dedent() @@ -3008,30 +3008,30 @@ func (p *PrettyPrinter) pretty_script(msg *pb.Script) interface{} { } func (p *PrettyPrinter) pretty_construct(msg *pb.Construct) interface{} { - flat1255 := p.tryFlat(msg, func() { p.pretty_construct(msg) }) - if flat1255 != nil { - p.write(*flat1255) + flat1257 := p.tryFlat(msg, func() { p.pretty_construct(msg) }) + if flat1257 != nil { + p.write(*flat1257) return nil } else { _dollar_dollar := msg - var _t1714 *pb.Loop + var _t1718 *pb.Loop if hasProtoField(_dollar_dollar, "loop") { - _t1714 = _dollar_dollar.GetLoop() + _t1718 = _dollar_dollar.GetLoop() } - deconstruct_result1253 := _t1714 - if deconstruct_result1253 != nil { - unwrapped1254 := deconstruct_result1253 - p.pretty_loop(unwrapped1254) + deconstruct_result1255 := _t1718 + if deconstruct_result1255 != nil { + unwrapped1256 := deconstruct_result1255 + p.pretty_loop(unwrapped1256) } else { _dollar_dollar := msg - var _t1715 *pb.Instruction + var _t1719 *pb.Instruction if hasProtoField(_dollar_dollar, "instruction") { - _t1715 = _dollar_dollar.GetInstruction() + _t1719 = _dollar_dollar.GetInstruction() } - deconstruct_result1251 := _t1715 - if deconstruct_result1251 != nil { - unwrapped1252 := deconstruct_result1251 - p.pretty_instruction(unwrapped1252) + deconstruct_result1253 := _t1719 + if deconstruct_result1253 != nil { + unwrapped1254 := deconstruct_result1253 + p.pretty_instruction(unwrapped1254) } else { panic(ParseError{msg: "No matching rule for construct"}) } @@ -3041,32 +3041,32 @@ func (p *PrettyPrinter) pretty_construct(msg *pb.Construct) interface{} { } func (p *PrettyPrinter) pretty_loop(msg *pb.Loop) interface{} { - flat1262 := p.tryFlat(msg, func() { p.pretty_loop(msg) }) - if flat1262 != nil { - p.write(*flat1262) + flat1264 := p.tryFlat(msg, func() { p.pretty_loop(msg) }) + if flat1264 != nil { + p.write(*flat1264) return nil } else { _dollar_dollar := msg - var _t1716 []*pb.Attribute + var _t1720 []*pb.Attribute if !(len(_dollar_dollar.GetAttrs()) == 0) { - _t1716 = _dollar_dollar.GetAttrs() + _t1720 = _dollar_dollar.GetAttrs() } - fields1256 := []interface{}{_dollar_dollar.GetInit(), _dollar_dollar.GetBody(), _t1716} - unwrapped_fields1257 := fields1256 + fields1258 := []interface{}{_dollar_dollar.GetInit(), _dollar_dollar.GetBody(), _t1720} + unwrapped_fields1259 := fields1258 p.write("(") p.write("loop") p.indentSexp() p.newline() - field1258 := unwrapped_fields1257[0].([]*pb.Instruction) - p.pretty_init(field1258) + field1260 := unwrapped_fields1259[0].([]*pb.Instruction) + p.pretty_init(field1260) p.newline() - field1259 := unwrapped_fields1257[1].(*pb.Script) - p.pretty_script(field1259) - field1260 := unwrapped_fields1257[2].([]*pb.Attribute) - if field1260 != nil { + field1261 := unwrapped_fields1259[1].(*pb.Script) + p.pretty_script(field1261) + field1262 := unwrapped_fields1259[2].([]*pb.Attribute) + if field1262 != nil { p.newline() - opt_val1261 := field1260 - p.pretty_attrs(opt_val1261) + opt_val1263 := field1262 + p.pretty_attrs(opt_val1263) } p.dedent() p.write(")") @@ -3075,22 +3075,22 @@ func (p *PrettyPrinter) pretty_loop(msg *pb.Loop) interface{} { } func (p *PrettyPrinter) pretty_init(msg []*pb.Instruction) interface{} { - flat1266 := p.tryFlat(msg, func() { p.pretty_init(msg) }) - if flat1266 != nil { - p.write(*flat1266) + flat1268 := p.tryFlat(msg, func() { p.pretty_init(msg) }) + if flat1268 != nil { + p.write(*flat1268) return nil } else { - fields1263 := msg + fields1265 := msg p.write("(") p.write("init") p.indentSexp() - if !(len(fields1263) == 0) { + if !(len(fields1265) == 0) { p.newline() - for i1265, elem1264 := range fields1263 { - if (i1265 > 0) { + for i1267, elem1266 := range fields1265 { + if (i1267 > 0) { p.newline() } - p.pretty_instruction(elem1264) + p.pretty_instruction(elem1266) } } p.dedent() @@ -3100,60 +3100,60 @@ func (p *PrettyPrinter) pretty_init(msg []*pb.Instruction) interface{} { } func (p *PrettyPrinter) pretty_instruction(msg *pb.Instruction) interface{} { - flat1277 := p.tryFlat(msg, func() { p.pretty_instruction(msg) }) - if flat1277 != nil { - p.write(*flat1277) + flat1279 := p.tryFlat(msg, func() { p.pretty_instruction(msg) }) + if flat1279 != nil { + p.write(*flat1279) return nil } else { _dollar_dollar := msg - var _t1717 *pb.Assign + var _t1721 *pb.Assign if hasProtoField(_dollar_dollar, "assign") { - _t1717 = _dollar_dollar.GetAssign() + _t1721 = _dollar_dollar.GetAssign() } - deconstruct_result1275 := _t1717 - if deconstruct_result1275 != nil { - unwrapped1276 := deconstruct_result1275 - p.pretty_assign(unwrapped1276) + deconstruct_result1277 := _t1721 + if deconstruct_result1277 != nil { + unwrapped1278 := deconstruct_result1277 + p.pretty_assign(unwrapped1278) } else { _dollar_dollar := msg - var _t1718 *pb.Upsert + var _t1722 *pb.Upsert if hasProtoField(_dollar_dollar, "upsert") { - _t1718 = _dollar_dollar.GetUpsert() + _t1722 = _dollar_dollar.GetUpsert() } - deconstruct_result1273 := _t1718 - if deconstruct_result1273 != nil { - unwrapped1274 := deconstruct_result1273 - p.pretty_upsert(unwrapped1274) + deconstruct_result1275 := _t1722 + if deconstruct_result1275 != nil { + unwrapped1276 := deconstruct_result1275 + p.pretty_upsert(unwrapped1276) } else { _dollar_dollar := msg - var _t1719 *pb.Break + var _t1723 *pb.Break if hasProtoField(_dollar_dollar, "break") { - _t1719 = _dollar_dollar.GetBreak() + _t1723 = _dollar_dollar.GetBreak() } - deconstruct_result1271 := _t1719 - if deconstruct_result1271 != nil { - unwrapped1272 := deconstruct_result1271 - p.pretty_break(unwrapped1272) + deconstruct_result1273 := _t1723 + if deconstruct_result1273 != nil { + unwrapped1274 := deconstruct_result1273 + p.pretty_break(unwrapped1274) } else { _dollar_dollar := msg - var _t1720 *pb.MonoidDef + var _t1724 *pb.MonoidDef if hasProtoField(_dollar_dollar, "monoid_def") { - _t1720 = _dollar_dollar.GetMonoidDef() + _t1724 = _dollar_dollar.GetMonoidDef() } - deconstruct_result1269 := _t1720 - if deconstruct_result1269 != nil { - unwrapped1270 := deconstruct_result1269 - p.pretty_monoid_def(unwrapped1270) + deconstruct_result1271 := _t1724 + if deconstruct_result1271 != nil { + unwrapped1272 := deconstruct_result1271 + p.pretty_monoid_def(unwrapped1272) } else { _dollar_dollar := msg - var _t1721 *pb.MonusDef + var _t1725 *pb.MonusDef if hasProtoField(_dollar_dollar, "monus_def") { - _t1721 = _dollar_dollar.GetMonusDef() + _t1725 = _dollar_dollar.GetMonusDef() } - deconstruct_result1267 := _t1721 - if deconstruct_result1267 != nil { - unwrapped1268 := deconstruct_result1267 - p.pretty_monus_def(unwrapped1268) + deconstruct_result1269 := _t1725 + if deconstruct_result1269 != nil { + unwrapped1270 := deconstruct_result1269 + p.pretty_monus_def(unwrapped1270) } else { panic(ParseError{msg: "No matching rule for instruction"}) } @@ -3166,32 +3166,32 @@ func (p *PrettyPrinter) pretty_instruction(msg *pb.Instruction) interface{} { } func (p *PrettyPrinter) pretty_assign(msg *pb.Assign) interface{} { - flat1284 := p.tryFlat(msg, func() { p.pretty_assign(msg) }) - if flat1284 != nil { - p.write(*flat1284) + flat1286 := p.tryFlat(msg, func() { p.pretty_assign(msg) }) + if flat1286 != nil { + p.write(*flat1286) return nil } else { _dollar_dollar := msg - var _t1722 []*pb.Attribute + var _t1726 []*pb.Attribute if !(len(_dollar_dollar.GetAttrs()) == 0) { - _t1722 = _dollar_dollar.GetAttrs() + _t1726 = _dollar_dollar.GetAttrs() } - fields1278 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetBody(), _t1722} - unwrapped_fields1279 := fields1278 + fields1280 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetBody(), _t1726} + unwrapped_fields1281 := fields1280 p.write("(") p.write("assign") p.indentSexp() p.newline() - field1280 := unwrapped_fields1279[0].(*pb.RelationId) - p.pretty_relation_id(field1280) + field1282 := unwrapped_fields1281[0].(*pb.RelationId) + p.pretty_relation_id(field1282) p.newline() - field1281 := unwrapped_fields1279[1].(*pb.Abstraction) - p.pretty_abstraction(field1281) - field1282 := unwrapped_fields1279[2].([]*pb.Attribute) - if field1282 != nil { + field1283 := unwrapped_fields1281[1].(*pb.Abstraction) + p.pretty_abstraction(field1283) + field1284 := unwrapped_fields1281[2].([]*pb.Attribute) + if field1284 != nil { p.newline() - opt_val1283 := field1282 - p.pretty_attrs(opt_val1283) + opt_val1285 := field1284 + p.pretty_attrs(opt_val1285) } p.dedent() p.write(")") @@ -3200,32 +3200,32 @@ func (p *PrettyPrinter) pretty_assign(msg *pb.Assign) interface{} { } func (p *PrettyPrinter) pretty_upsert(msg *pb.Upsert) interface{} { - flat1291 := p.tryFlat(msg, func() { p.pretty_upsert(msg) }) - if flat1291 != nil { - p.write(*flat1291) + flat1293 := p.tryFlat(msg, func() { p.pretty_upsert(msg) }) + if flat1293 != nil { + p.write(*flat1293) return nil } else { _dollar_dollar := msg - var _t1723 []*pb.Attribute + var _t1727 []*pb.Attribute if !(len(_dollar_dollar.GetAttrs()) == 0) { - _t1723 = _dollar_dollar.GetAttrs() + _t1727 = _dollar_dollar.GetAttrs() } - fields1285 := []interface{}{_dollar_dollar.GetName(), []interface{}{_dollar_dollar.GetBody(), _dollar_dollar.GetValueArity()}, _t1723} - unwrapped_fields1286 := fields1285 + fields1287 := []interface{}{_dollar_dollar.GetName(), []interface{}{_dollar_dollar.GetBody(), _dollar_dollar.GetValueArity()}, _t1727} + unwrapped_fields1288 := fields1287 p.write("(") p.write("upsert") p.indentSexp() p.newline() - field1287 := unwrapped_fields1286[0].(*pb.RelationId) - p.pretty_relation_id(field1287) + field1289 := unwrapped_fields1288[0].(*pb.RelationId) + p.pretty_relation_id(field1289) p.newline() - field1288 := unwrapped_fields1286[1].([]interface{}) - p.pretty_abstraction_with_arity(field1288) - field1289 := unwrapped_fields1286[2].([]*pb.Attribute) - if field1289 != nil { + field1290 := unwrapped_fields1288[1].([]interface{}) + p.pretty_abstraction_with_arity(field1290) + field1291 := unwrapped_fields1288[2].([]*pb.Attribute) + if field1291 != nil { p.newline() - opt_val1290 := field1289 - p.pretty_attrs(opt_val1290) + opt_val1292 := field1291 + p.pretty_attrs(opt_val1292) } p.dedent() p.write(")") @@ -3234,22 +3234,22 @@ func (p *PrettyPrinter) pretty_upsert(msg *pb.Upsert) interface{} { } func (p *PrettyPrinter) pretty_abstraction_with_arity(msg []interface{}) interface{} { - flat1296 := p.tryFlat(msg, func() { p.pretty_abstraction_with_arity(msg) }) - if flat1296 != nil { - p.write(*flat1296) + flat1298 := p.tryFlat(msg, func() { p.pretty_abstraction_with_arity(msg) }) + if flat1298 != nil { + p.write(*flat1298) return nil } else { _dollar_dollar := msg - _t1724 := p.deconstruct_bindings_with_arity(_dollar_dollar[0].(*pb.Abstraction), _dollar_dollar[1].(int64)) - fields1292 := []interface{}{_t1724, _dollar_dollar[0].(*pb.Abstraction).GetValue()} - unwrapped_fields1293 := fields1292 + _t1728 := p.deconstruct_bindings_with_arity(_dollar_dollar[0].(*pb.Abstraction), _dollar_dollar[1].(int64)) + fields1294 := []interface{}{_t1728, _dollar_dollar[0].(*pb.Abstraction).GetValue()} + unwrapped_fields1295 := fields1294 p.write("(") p.indent() - field1294 := unwrapped_fields1293[0].([]interface{}) - p.pretty_bindings(field1294) + field1296 := unwrapped_fields1295[0].([]interface{}) + p.pretty_bindings(field1296) p.newline() - field1295 := unwrapped_fields1293[1].(*pb.Formula) - p.pretty_formula(field1295) + field1297 := unwrapped_fields1295[1].(*pb.Formula) + p.pretty_formula(field1297) p.dedent() p.write(")") } @@ -3257,32 +3257,32 @@ func (p *PrettyPrinter) pretty_abstraction_with_arity(msg []interface{}) interfa } func (p *PrettyPrinter) pretty_break(msg *pb.Break) interface{} { - flat1303 := p.tryFlat(msg, func() { p.pretty_break(msg) }) - if flat1303 != nil { - p.write(*flat1303) + flat1305 := p.tryFlat(msg, func() { p.pretty_break(msg) }) + if flat1305 != nil { + p.write(*flat1305) return nil } else { _dollar_dollar := msg - var _t1725 []*pb.Attribute + var _t1729 []*pb.Attribute if !(len(_dollar_dollar.GetAttrs()) == 0) { - _t1725 = _dollar_dollar.GetAttrs() + _t1729 = _dollar_dollar.GetAttrs() } - fields1297 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetBody(), _t1725} - unwrapped_fields1298 := fields1297 + fields1299 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetBody(), _t1729} + unwrapped_fields1300 := fields1299 p.write("(") p.write("break") p.indentSexp() p.newline() - field1299 := unwrapped_fields1298[0].(*pb.RelationId) - p.pretty_relation_id(field1299) + field1301 := unwrapped_fields1300[0].(*pb.RelationId) + p.pretty_relation_id(field1301) p.newline() - field1300 := unwrapped_fields1298[1].(*pb.Abstraction) - p.pretty_abstraction(field1300) - field1301 := unwrapped_fields1298[2].([]*pb.Attribute) - if field1301 != nil { + field1302 := unwrapped_fields1300[1].(*pb.Abstraction) + p.pretty_abstraction(field1302) + field1303 := unwrapped_fields1300[2].([]*pb.Attribute) + if field1303 != nil { p.newline() - opt_val1302 := field1301 - p.pretty_attrs(opt_val1302) + opt_val1304 := field1303 + p.pretty_attrs(opt_val1304) } p.dedent() p.write(")") @@ -3291,35 +3291,35 @@ func (p *PrettyPrinter) pretty_break(msg *pb.Break) interface{} { } func (p *PrettyPrinter) pretty_monoid_def(msg *pb.MonoidDef) interface{} { - flat1311 := p.tryFlat(msg, func() { p.pretty_monoid_def(msg) }) - if flat1311 != nil { - p.write(*flat1311) + flat1313 := p.tryFlat(msg, func() { p.pretty_monoid_def(msg) }) + if flat1313 != nil { + p.write(*flat1313) return nil } else { _dollar_dollar := msg - var _t1726 []*pb.Attribute + var _t1730 []*pb.Attribute if !(len(_dollar_dollar.GetAttrs()) == 0) { - _t1726 = _dollar_dollar.GetAttrs() + _t1730 = _dollar_dollar.GetAttrs() } - fields1304 := []interface{}{_dollar_dollar.GetMonoid(), _dollar_dollar.GetName(), []interface{}{_dollar_dollar.GetBody(), _dollar_dollar.GetValueArity()}, _t1726} - unwrapped_fields1305 := fields1304 + fields1306 := []interface{}{_dollar_dollar.GetMonoid(), _dollar_dollar.GetName(), []interface{}{_dollar_dollar.GetBody(), _dollar_dollar.GetValueArity()}, _t1730} + unwrapped_fields1307 := fields1306 p.write("(") p.write("monoid") p.indentSexp() p.newline() - field1306 := unwrapped_fields1305[0].(*pb.Monoid) - p.pretty_monoid(field1306) + field1308 := unwrapped_fields1307[0].(*pb.Monoid) + p.pretty_monoid(field1308) p.newline() - field1307 := unwrapped_fields1305[1].(*pb.RelationId) - p.pretty_relation_id(field1307) + field1309 := unwrapped_fields1307[1].(*pb.RelationId) + p.pretty_relation_id(field1309) p.newline() - field1308 := unwrapped_fields1305[2].([]interface{}) - p.pretty_abstraction_with_arity(field1308) - field1309 := unwrapped_fields1305[3].([]*pb.Attribute) - if field1309 != nil { + field1310 := unwrapped_fields1307[2].([]interface{}) + p.pretty_abstraction_with_arity(field1310) + field1311 := unwrapped_fields1307[3].([]*pb.Attribute) + if field1311 != nil { p.newline() - opt_val1310 := field1309 - p.pretty_attrs(opt_val1310) + opt_val1312 := field1311 + p.pretty_attrs(opt_val1312) } p.dedent() p.write(")") @@ -3328,50 +3328,50 @@ func (p *PrettyPrinter) pretty_monoid_def(msg *pb.MonoidDef) interface{} { } func (p *PrettyPrinter) pretty_monoid(msg *pb.Monoid) interface{} { - flat1320 := p.tryFlat(msg, func() { p.pretty_monoid(msg) }) - if flat1320 != nil { - p.write(*flat1320) + flat1322 := p.tryFlat(msg, func() { p.pretty_monoid(msg) }) + if flat1322 != nil { + p.write(*flat1322) return nil } else { _dollar_dollar := msg - var _t1727 *pb.OrMonoid + var _t1731 *pb.OrMonoid if hasProtoField(_dollar_dollar, "or_monoid") { - _t1727 = _dollar_dollar.GetOrMonoid() + _t1731 = _dollar_dollar.GetOrMonoid() } - deconstruct_result1318 := _t1727 - if deconstruct_result1318 != nil { - unwrapped1319 := deconstruct_result1318 - p.pretty_or_monoid(unwrapped1319) + deconstruct_result1320 := _t1731 + if deconstruct_result1320 != nil { + unwrapped1321 := deconstruct_result1320 + p.pretty_or_monoid(unwrapped1321) } else { _dollar_dollar := msg - var _t1728 *pb.MinMonoid + var _t1732 *pb.MinMonoid if hasProtoField(_dollar_dollar, "min_monoid") { - _t1728 = _dollar_dollar.GetMinMonoid() + _t1732 = _dollar_dollar.GetMinMonoid() } - deconstruct_result1316 := _t1728 - if deconstruct_result1316 != nil { - unwrapped1317 := deconstruct_result1316 - p.pretty_min_monoid(unwrapped1317) + deconstruct_result1318 := _t1732 + if deconstruct_result1318 != nil { + unwrapped1319 := deconstruct_result1318 + p.pretty_min_monoid(unwrapped1319) } else { _dollar_dollar := msg - var _t1729 *pb.MaxMonoid + var _t1733 *pb.MaxMonoid if hasProtoField(_dollar_dollar, "max_monoid") { - _t1729 = _dollar_dollar.GetMaxMonoid() + _t1733 = _dollar_dollar.GetMaxMonoid() } - deconstruct_result1314 := _t1729 - if deconstruct_result1314 != nil { - unwrapped1315 := deconstruct_result1314 - p.pretty_max_monoid(unwrapped1315) + deconstruct_result1316 := _t1733 + if deconstruct_result1316 != nil { + unwrapped1317 := deconstruct_result1316 + p.pretty_max_monoid(unwrapped1317) } else { _dollar_dollar := msg - var _t1730 *pb.SumMonoid + var _t1734 *pb.SumMonoid if hasProtoField(_dollar_dollar, "sum_monoid") { - _t1730 = _dollar_dollar.GetSumMonoid() + _t1734 = _dollar_dollar.GetSumMonoid() } - deconstruct_result1312 := _t1730 - if deconstruct_result1312 != nil { - unwrapped1313 := deconstruct_result1312 - p.pretty_sum_monoid(unwrapped1313) + deconstruct_result1314 := _t1734 + if deconstruct_result1314 != nil { + unwrapped1315 := deconstruct_result1314 + p.pretty_sum_monoid(unwrapped1315) } else { panic(ParseError{msg: "No matching rule for monoid"}) } @@ -3383,8 +3383,8 @@ func (p *PrettyPrinter) pretty_monoid(msg *pb.Monoid) interface{} { } func (p *PrettyPrinter) pretty_or_monoid(msg *pb.OrMonoid) interface{} { - fields1321 := msg - _ = fields1321 + fields1323 := msg + _ = fields1323 p.write("(") p.write("or") p.write(")") @@ -3392,19 +3392,19 @@ func (p *PrettyPrinter) pretty_or_monoid(msg *pb.OrMonoid) interface{} { } func (p *PrettyPrinter) pretty_min_monoid(msg *pb.MinMonoid) interface{} { - flat1324 := p.tryFlat(msg, func() { p.pretty_min_monoid(msg) }) - if flat1324 != nil { - p.write(*flat1324) + flat1326 := p.tryFlat(msg, func() { p.pretty_min_monoid(msg) }) + if flat1326 != nil { + p.write(*flat1326) return nil } else { _dollar_dollar := msg - fields1322 := _dollar_dollar.GetType() - unwrapped_fields1323 := fields1322 + fields1324 := _dollar_dollar.GetType() + unwrapped_fields1325 := fields1324 p.write("(") p.write("min") p.indentSexp() p.newline() - p.pretty_type(unwrapped_fields1323) + p.pretty_type(unwrapped_fields1325) p.dedent() p.write(")") } @@ -3412,19 +3412,19 @@ func (p *PrettyPrinter) pretty_min_monoid(msg *pb.MinMonoid) interface{} { } func (p *PrettyPrinter) pretty_max_monoid(msg *pb.MaxMonoid) interface{} { - flat1327 := p.tryFlat(msg, func() { p.pretty_max_monoid(msg) }) - if flat1327 != nil { - p.write(*flat1327) + flat1329 := p.tryFlat(msg, func() { p.pretty_max_monoid(msg) }) + if flat1329 != nil { + p.write(*flat1329) return nil } else { _dollar_dollar := msg - fields1325 := _dollar_dollar.GetType() - unwrapped_fields1326 := fields1325 + fields1327 := _dollar_dollar.GetType() + unwrapped_fields1328 := fields1327 p.write("(") p.write("max") p.indentSexp() p.newline() - p.pretty_type(unwrapped_fields1326) + p.pretty_type(unwrapped_fields1328) p.dedent() p.write(")") } @@ -3432,19 +3432,19 @@ func (p *PrettyPrinter) pretty_max_monoid(msg *pb.MaxMonoid) interface{} { } func (p *PrettyPrinter) pretty_sum_monoid(msg *pb.SumMonoid) interface{} { - flat1330 := p.tryFlat(msg, func() { p.pretty_sum_monoid(msg) }) - if flat1330 != nil { - p.write(*flat1330) + flat1332 := p.tryFlat(msg, func() { p.pretty_sum_monoid(msg) }) + if flat1332 != nil { + p.write(*flat1332) return nil } else { _dollar_dollar := msg - fields1328 := _dollar_dollar.GetType() - unwrapped_fields1329 := fields1328 + fields1330 := _dollar_dollar.GetType() + unwrapped_fields1331 := fields1330 p.write("(") p.write("sum") p.indentSexp() p.newline() - p.pretty_type(unwrapped_fields1329) + p.pretty_type(unwrapped_fields1331) p.dedent() p.write(")") } @@ -3452,35 +3452,35 @@ func (p *PrettyPrinter) pretty_sum_monoid(msg *pb.SumMonoid) interface{} { } func (p *PrettyPrinter) pretty_monus_def(msg *pb.MonusDef) interface{} { - flat1338 := p.tryFlat(msg, func() { p.pretty_monus_def(msg) }) - if flat1338 != nil { - p.write(*flat1338) + flat1340 := p.tryFlat(msg, func() { p.pretty_monus_def(msg) }) + if flat1340 != nil { + p.write(*flat1340) return nil } else { _dollar_dollar := msg - var _t1731 []*pb.Attribute + var _t1735 []*pb.Attribute if !(len(_dollar_dollar.GetAttrs()) == 0) { - _t1731 = _dollar_dollar.GetAttrs() + _t1735 = _dollar_dollar.GetAttrs() } - fields1331 := []interface{}{_dollar_dollar.GetMonoid(), _dollar_dollar.GetName(), []interface{}{_dollar_dollar.GetBody(), _dollar_dollar.GetValueArity()}, _t1731} - unwrapped_fields1332 := fields1331 + fields1333 := []interface{}{_dollar_dollar.GetMonoid(), _dollar_dollar.GetName(), []interface{}{_dollar_dollar.GetBody(), _dollar_dollar.GetValueArity()}, _t1735} + unwrapped_fields1334 := fields1333 p.write("(") p.write("monus") p.indentSexp() p.newline() - field1333 := unwrapped_fields1332[0].(*pb.Monoid) - p.pretty_monoid(field1333) + field1335 := unwrapped_fields1334[0].(*pb.Monoid) + p.pretty_monoid(field1335) p.newline() - field1334 := unwrapped_fields1332[1].(*pb.RelationId) - p.pretty_relation_id(field1334) + field1336 := unwrapped_fields1334[1].(*pb.RelationId) + p.pretty_relation_id(field1336) p.newline() - field1335 := unwrapped_fields1332[2].([]interface{}) - p.pretty_abstraction_with_arity(field1335) - field1336 := unwrapped_fields1332[3].([]*pb.Attribute) - if field1336 != nil { + field1337 := unwrapped_fields1334[2].([]interface{}) + p.pretty_abstraction_with_arity(field1337) + field1338 := unwrapped_fields1334[3].([]*pb.Attribute) + if field1338 != nil { p.newline() - opt_val1337 := field1336 - p.pretty_attrs(opt_val1337) + opt_val1339 := field1338 + p.pretty_attrs(opt_val1339) } p.dedent() p.write(")") @@ -3489,29 +3489,29 @@ func (p *PrettyPrinter) pretty_monus_def(msg *pb.MonusDef) interface{} { } func (p *PrettyPrinter) pretty_constraint(msg *pb.Constraint) interface{} { - flat1345 := p.tryFlat(msg, func() { p.pretty_constraint(msg) }) - if flat1345 != nil { - p.write(*flat1345) + flat1347 := p.tryFlat(msg, func() { p.pretty_constraint(msg) }) + if flat1347 != nil { + p.write(*flat1347) return nil } else { _dollar_dollar := msg - fields1339 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetFunctionalDependency().GetGuard(), _dollar_dollar.GetFunctionalDependency().GetKeys(), _dollar_dollar.GetFunctionalDependency().GetValues()} - unwrapped_fields1340 := fields1339 + fields1341 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetFunctionalDependency().GetGuard(), _dollar_dollar.GetFunctionalDependency().GetKeys(), _dollar_dollar.GetFunctionalDependency().GetValues()} + unwrapped_fields1342 := fields1341 p.write("(") p.write("functional_dependency") p.indentSexp() p.newline() - field1341 := unwrapped_fields1340[0].(*pb.RelationId) - p.pretty_relation_id(field1341) + field1343 := unwrapped_fields1342[0].(*pb.RelationId) + p.pretty_relation_id(field1343) p.newline() - field1342 := unwrapped_fields1340[1].(*pb.Abstraction) - p.pretty_abstraction(field1342) + field1344 := unwrapped_fields1342[1].(*pb.Abstraction) + p.pretty_abstraction(field1344) p.newline() - field1343 := unwrapped_fields1340[2].([]*pb.Var) - p.pretty_functional_dependency_keys(field1343) + field1345 := unwrapped_fields1342[2].([]*pb.Var) + p.pretty_functional_dependency_keys(field1345) p.newline() - field1344 := unwrapped_fields1340[3].([]*pb.Var) - p.pretty_functional_dependency_values(field1344) + field1346 := unwrapped_fields1342[3].([]*pb.Var) + p.pretty_functional_dependency_values(field1346) p.dedent() p.write(")") } @@ -3519,22 +3519,22 @@ func (p *PrettyPrinter) pretty_constraint(msg *pb.Constraint) interface{} { } func (p *PrettyPrinter) pretty_functional_dependency_keys(msg []*pb.Var) interface{} { - flat1349 := p.tryFlat(msg, func() { p.pretty_functional_dependency_keys(msg) }) - if flat1349 != nil { - p.write(*flat1349) + flat1351 := p.tryFlat(msg, func() { p.pretty_functional_dependency_keys(msg) }) + if flat1351 != nil { + p.write(*flat1351) return nil } else { - fields1346 := msg + fields1348 := msg p.write("(") p.write("keys") p.indentSexp() - if !(len(fields1346) == 0) { + if !(len(fields1348) == 0) { p.newline() - for i1348, elem1347 := range fields1346 { - if (i1348 > 0) { + for i1350, elem1349 := range fields1348 { + if (i1350 > 0) { p.newline() } - p.pretty_var(elem1347) + p.pretty_var(elem1349) } } p.dedent() @@ -3544,22 +3544,22 @@ func (p *PrettyPrinter) pretty_functional_dependency_keys(msg []*pb.Var) interfa } func (p *PrettyPrinter) pretty_functional_dependency_values(msg []*pb.Var) interface{} { - flat1353 := p.tryFlat(msg, func() { p.pretty_functional_dependency_values(msg) }) - if flat1353 != nil { - p.write(*flat1353) + flat1355 := p.tryFlat(msg, func() { p.pretty_functional_dependency_values(msg) }) + if flat1355 != nil { + p.write(*flat1355) return nil } else { - fields1350 := msg + fields1352 := msg p.write("(") p.write("values") p.indentSexp() - if !(len(fields1350) == 0) { + if !(len(fields1352) == 0) { p.newline() - for i1352, elem1351 := range fields1350 { - if (i1352 > 0) { + for i1354, elem1353 := range fields1352 { + if (i1354 > 0) { p.newline() } - p.pretty_var(elem1351) + p.pretty_var(elem1353) } } p.dedent() @@ -3569,50 +3569,50 @@ func (p *PrettyPrinter) pretty_functional_dependency_values(msg []*pb.Var) inter } func (p *PrettyPrinter) pretty_data(msg *pb.Data) interface{} { - flat1362 := p.tryFlat(msg, func() { p.pretty_data(msg) }) - if flat1362 != nil { - p.write(*flat1362) + flat1364 := p.tryFlat(msg, func() { p.pretty_data(msg) }) + if flat1364 != nil { + p.write(*flat1364) return nil } else { _dollar_dollar := msg - var _t1732 *pb.EDB + var _t1736 *pb.EDB if hasProtoField(_dollar_dollar, "edb") { - _t1732 = _dollar_dollar.GetEdb() + _t1736 = _dollar_dollar.GetEdb() } - deconstruct_result1360 := _t1732 - if deconstruct_result1360 != nil { - unwrapped1361 := deconstruct_result1360 - p.pretty_edb(unwrapped1361) + deconstruct_result1362 := _t1736 + if deconstruct_result1362 != nil { + unwrapped1363 := deconstruct_result1362 + p.pretty_edb(unwrapped1363) } else { _dollar_dollar := msg - var _t1733 *pb.BeTreeRelation + var _t1737 *pb.BeTreeRelation if hasProtoField(_dollar_dollar, "betree_relation") { - _t1733 = _dollar_dollar.GetBetreeRelation() + _t1737 = _dollar_dollar.GetBetreeRelation() } - deconstruct_result1358 := _t1733 - if deconstruct_result1358 != nil { - unwrapped1359 := deconstruct_result1358 - p.pretty_betree_relation(unwrapped1359) + deconstruct_result1360 := _t1737 + if deconstruct_result1360 != nil { + unwrapped1361 := deconstruct_result1360 + p.pretty_betree_relation(unwrapped1361) } else { _dollar_dollar := msg - var _t1734 *pb.CSVData + var _t1738 *pb.CSVData if hasProtoField(_dollar_dollar, "csv_data") { - _t1734 = _dollar_dollar.GetCsvData() + _t1738 = _dollar_dollar.GetCsvData() } - deconstruct_result1356 := _t1734 - if deconstruct_result1356 != nil { - unwrapped1357 := deconstruct_result1356 - p.pretty_csv_data(unwrapped1357) + deconstruct_result1358 := _t1738 + if deconstruct_result1358 != nil { + unwrapped1359 := deconstruct_result1358 + p.pretty_csv_data(unwrapped1359) } else { _dollar_dollar := msg - var _t1735 *pb.IcebergData + var _t1739 *pb.IcebergData if hasProtoField(_dollar_dollar, "iceberg_data") { - _t1735 = _dollar_dollar.GetIcebergData() + _t1739 = _dollar_dollar.GetIcebergData() } - deconstruct_result1354 := _t1735 - if deconstruct_result1354 != nil { - unwrapped1355 := deconstruct_result1354 - p.pretty_iceberg_data(unwrapped1355) + deconstruct_result1356 := _t1739 + if deconstruct_result1356 != nil { + unwrapped1357 := deconstruct_result1356 + p.pretty_iceberg_data(unwrapped1357) } else { panic(ParseError{msg: "No matching rule for data"}) } @@ -3624,26 +3624,26 @@ func (p *PrettyPrinter) pretty_data(msg *pb.Data) interface{} { } func (p *PrettyPrinter) pretty_edb(msg *pb.EDB) interface{} { - flat1368 := p.tryFlat(msg, func() { p.pretty_edb(msg) }) - if flat1368 != nil { - p.write(*flat1368) + flat1370 := p.tryFlat(msg, func() { p.pretty_edb(msg) }) + if flat1370 != nil { + p.write(*flat1370) return nil } else { _dollar_dollar := msg - fields1363 := []interface{}{_dollar_dollar.GetTargetId(), _dollar_dollar.GetPath(), _dollar_dollar.GetTypes()} - unwrapped_fields1364 := fields1363 + fields1365 := []interface{}{_dollar_dollar.GetTargetId(), _dollar_dollar.GetPath(), _dollar_dollar.GetTypes()} + unwrapped_fields1366 := fields1365 p.write("(") p.write("edb") p.indentSexp() p.newline() - field1365 := unwrapped_fields1364[0].(*pb.RelationId) - p.pretty_relation_id(field1365) + field1367 := unwrapped_fields1366[0].(*pb.RelationId) + p.pretty_relation_id(field1367) p.newline() - field1366 := unwrapped_fields1364[1].([]string) - p.pretty_edb_path(field1366) + field1368 := unwrapped_fields1366[1].([]string) + p.pretty_edb_path(field1368) p.newline() - field1367 := unwrapped_fields1364[2].([]*pb.Type) - p.pretty_edb_types(field1367) + field1369 := unwrapped_fields1366[2].([]*pb.Type) + p.pretty_edb_types(field1369) p.dedent() p.write(")") } @@ -3651,19 +3651,19 @@ func (p *PrettyPrinter) pretty_edb(msg *pb.EDB) interface{} { } func (p *PrettyPrinter) pretty_edb_path(msg []string) interface{} { - flat1372 := p.tryFlat(msg, func() { p.pretty_edb_path(msg) }) - if flat1372 != nil { - p.write(*flat1372) + flat1374 := p.tryFlat(msg, func() { p.pretty_edb_path(msg) }) + if flat1374 != nil { + p.write(*flat1374) return nil } else { - fields1369 := msg + fields1371 := msg p.write("[") p.indent() - for i1371, elem1370 := range fields1369 { - if (i1371 > 0) { + for i1373, elem1372 := range fields1371 { + if (i1373 > 0) { p.newline() } - p.write(p.formatStringValue(elem1370)) + p.write(p.formatStringValue(elem1372)) } p.dedent() p.write("]") @@ -3672,19 +3672,19 @@ func (p *PrettyPrinter) pretty_edb_path(msg []string) interface{} { } func (p *PrettyPrinter) pretty_edb_types(msg []*pb.Type) interface{} { - flat1376 := p.tryFlat(msg, func() { p.pretty_edb_types(msg) }) - if flat1376 != nil { - p.write(*flat1376) + flat1378 := p.tryFlat(msg, func() { p.pretty_edb_types(msg) }) + if flat1378 != nil { + p.write(*flat1378) return nil } else { - fields1373 := msg + fields1375 := msg p.write("[") p.indent() - for i1375, elem1374 := range fields1373 { - if (i1375 > 0) { + for i1377, elem1376 := range fields1375 { + if (i1377 > 0) { p.newline() } - p.pretty_type(elem1374) + p.pretty_type(elem1376) } p.dedent() p.write("]") @@ -3693,23 +3693,23 @@ func (p *PrettyPrinter) pretty_edb_types(msg []*pb.Type) interface{} { } func (p *PrettyPrinter) pretty_betree_relation(msg *pb.BeTreeRelation) interface{} { - flat1381 := p.tryFlat(msg, func() { p.pretty_betree_relation(msg) }) - if flat1381 != nil { - p.write(*flat1381) + flat1383 := p.tryFlat(msg, func() { p.pretty_betree_relation(msg) }) + if flat1383 != nil { + p.write(*flat1383) return nil } else { _dollar_dollar := msg - fields1377 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetRelationInfo()} - unwrapped_fields1378 := fields1377 + fields1379 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetRelationInfo()} + unwrapped_fields1380 := fields1379 p.write("(") p.write("betree_relation") p.indentSexp() p.newline() - field1379 := unwrapped_fields1378[0].(*pb.RelationId) - p.pretty_relation_id(field1379) + field1381 := unwrapped_fields1380[0].(*pb.RelationId) + p.pretty_relation_id(field1381) p.newline() - field1380 := unwrapped_fields1378[1].(*pb.BeTreeInfo) - p.pretty_betree_info(field1380) + field1382 := unwrapped_fields1380[1].(*pb.BeTreeInfo) + p.pretty_betree_info(field1382) p.dedent() p.write(")") } @@ -3717,27 +3717,27 @@ func (p *PrettyPrinter) pretty_betree_relation(msg *pb.BeTreeRelation) interface } func (p *PrettyPrinter) pretty_betree_info(msg *pb.BeTreeInfo) interface{} { - flat1387 := p.tryFlat(msg, func() { p.pretty_betree_info(msg) }) - if flat1387 != nil { - p.write(*flat1387) + flat1389 := p.tryFlat(msg, func() { p.pretty_betree_info(msg) }) + if flat1389 != nil { + p.write(*flat1389) return nil } else { _dollar_dollar := msg - _t1736 := p.deconstruct_betree_info_config(_dollar_dollar) - fields1382 := []interface{}{_dollar_dollar.GetKeyTypes(), _dollar_dollar.GetValueTypes(), _t1736} - unwrapped_fields1383 := fields1382 + _t1740 := p.deconstruct_betree_info_config(_dollar_dollar) + fields1384 := []interface{}{_dollar_dollar.GetKeyTypes(), _dollar_dollar.GetValueTypes(), _t1740} + unwrapped_fields1385 := fields1384 p.write("(") p.write("betree_info") p.indentSexp() p.newline() - field1384 := unwrapped_fields1383[0].([]*pb.Type) - p.pretty_betree_info_key_types(field1384) + field1386 := unwrapped_fields1385[0].([]*pb.Type) + p.pretty_betree_info_key_types(field1386) p.newline() - field1385 := unwrapped_fields1383[1].([]*pb.Type) - p.pretty_betree_info_value_types(field1385) + field1387 := unwrapped_fields1385[1].([]*pb.Type) + p.pretty_betree_info_value_types(field1387) p.newline() - field1386 := unwrapped_fields1383[2].([][]interface{}) - p.pretty_config_dict(field1386) + field1388 := unwrapped_fields1385[2].([][]interface{}) + p.pretty_config_dict(field1388) p.dedent() p.write(")") } @@ -3745,22 +3745,22 @@ func (p *PrettyPrinter) pretty_betree_info(msg *pb.BeTreeInfo) interface{} { } func (p *PrettyPrinter) pretty_betree_info_key_types(msg []*pb.Type) interface{} { - flat1391 := p.tryFlat(msg, func() { p.pretty_betree_info_key_types(msg) }) - if flat1391 != nil { - p.write(*flat1391) + flat1393 := p.tryFlat(msg, func() { p.pretty_betree_info_key_types(msg) }) + if flat1393 != nil { + p.write(*flat1393) return nil } else { - fields1388 := msg + fields1390 := msg p.write("(") p.write("key_types") p.indentSexp() - if !(len(fields1388) == 0) { + if !(len(fields1390) == 0) { p.newline() - for i1390, elem1389 := range fields1388 { - if (i1390 > 0) { + for i1392, elem1391 := range fields1390 { + if (i1392 > 0) { p.newline() } - p.pretty_type(elem1389) + p.pretty_type(elem1391) } } p.dedent() @@ -3770,22 +3770,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{} { - flat1395 := p.tryFlat(msg, func() { p.pretty_betree_info_value_types(msg) }) - if flat1395 != nil { - p.write(*flat1395) + flat1397 := p.tryFlat(msg, func() { p.pretty_betree_info_value_types(msg) }) + if flat1397 != nil { + p.write(*flat1397) return nil } else { - fields1392 := msg + fields1394 := msg p.write("(") p.write("value_types") p.indentSexp() - if !(len(fields1392) == 0) { + if !(len(fields1394) == 0) { p.newline() - for i1394, elem1393 := range fields1392 { - if (i1394 > 0) { + for i1396, elem1395 := range fields1394 { + if (i1396 > 0) { p.newline() } - p.pretty_type(elem1393) + p.pretty_type(elem1395) } } p.dedent() @@ -3795,29 +3795,29 @@ func (p *PrettyPrinter) pretty_betree_info_value_types(msg []*pb.Type) interface } func (p *PrettyPrinter) pretty_csv_data(msg *pb.CSVData) interface{} { - flat1402 := p.tryFlat(msg, func() { p.pretty_csv_data(msg) }) - if flat1402 != nil { - p.write(*flat1402) + flat1404 := p.tryFlat(msg, func() { p.pretty_csv_data(msg) }) + if flat1404 != nil { + p.write(*flat1404) return nil } else { _dollar_dollar := msg - fields1396 := []interface{}{_dollar_dollar.GetLocator(), _dollar_dollar.GetConfig(), _dollar_dollar.GetColumns(), _dollar_dollar.GetAsof()} - unwrapped_fields1397 := fields1396 + fields1398 := []interface{}{_dollar_dollar.GetLocator(), _dollar_dollar.GetConfig(), _dollar_dollar.GetColumns(), _dollar_dollar.GetAsof()} + unwrapped_fields1399 := fields1398 p.write("(") p.write("csv_data") p.indentSexp() p.newline() - field1398 := unwrapped_fields1397[0].(*pb.CSVLocator) - p.pretty_csvlocator(field1398) + field1400 := unwrapped_fields1399[0].(*pb.CSVLocator) + p.pretty_csvlocator(field1400) p.newline() - field1399 := unwrapped_fields1397[1].(*pb.CSVConfig) - p.pretty_csv_config(field1399) + field1401 := unwrapped_fields1399[1].(*pb.CSVConfig) + p.pretty_csv_config(field1401) p.newline() - field1400 := unwrapped_fields1397[2].([]*pb.GNFColumn) - p.pretty_gnf_columns(field1400) + field1402 := unwrapped_fields1399[2].([]*pb.GNFColumn) + p.pretty_gnf_columns(field1402) p.newline() - field1401 := unwrapped_fields1397[3].(string) - p.pretty_csv_asof(field1401) + field1403 := unwrapped_fields1399[3].(string) + p.pretty_csv_asof(field1403) p.dedent() p.write(")") } @@ -3825,36 +3825,36 @@ func (p *PrettyPrinter) pretty_csv_data(msg *pb.CSVData) interface{} { } func (p *PrettyPrinter) pretty_csvlocator(msg *pb.CSVLocator) interface{} { - flat1409 := p.tryFlat(msg, func() { p.pretty_csvlocator(msg) }) - if flat1409 != nil { - p.write(*flat1409) + flat1411 := p.tryFlat(msg, func() { p.pretty_csvlocator(msg) }) + if flat1411 != nil { + p.write(*flat1411) return nil } else { _dollar_dollar := msg - var _t1737 []string + var _t1741 []string if !(len(_dollar_dollar.GetPaths()) == 0) { - _t1737 = _dollar_dollar.GetPaths() + _t1741 = _dollar_dollar.GetPaths() } - var _t1738 *string + var _t1742 *string if string(_dollar_dollar.GetInlineData()) != "" { - _t1738 = ptr(string(_dollar_dollar.GetInlineData())) + _t1742 = ptr(string(_dollar_dollar.GetInlineData())) } - fields1403 := []interface{}{_t1737, _t1738} - unwrapped_fields1404 := fields1403 + fields1405 := []interface{}{_t1741, _t1742} + unwrapped_fields1406 := fields1405 p.write("(") p.write("csv_locator") p.indentSexp() - field1405 := unwrapped_fields1404[0].([]string) - if field1405 != nil { + field1407 := unwrapped_fields1406[0].([]string) + if field1407 != nil { p.newline() - opt_val1406 := field1405 - p.pretty_csv_locator_paths(opt_val1406) + opt_val1408 := field1407 + p.pretty_csv_locator_paths(opt_val1408) } - field1407 := unwrapped_fields1404[1].(*string) - if field1407 != nil { + field1409 := unwrapped_fields1406[1].(*string) + if field1409 != nil { p.newline() - opt_val1408 := *field1407 - p.pretty_csv_locator_inline_data(opt_val1408) + opt_val1410 := *field1409 + p.pretty_csv_locator_inline_data(opt_val1410) } p.dedent() p.write(")") @@ -3863,22 +3863,22 @@ func (p *PrettyPrinter) pretty_csvlocator(msg *pb.CSVLocator) interface{} { } func (p *PrettyPrinter) pretty_csv_locator_paths(msg []string) interface{} { - flat1413 := p.tryFlat(msg, func() { p.pretty_csv_locator_paths(msg) }) - if flat1413 != nil { - p.write(*flat1413) + flat1415 := p.tryFlat(msg, func() { p.pretty_csv_locator_paths(msg) }) + if flat1415 != nil { + p.write(*flat1415) return nil } else { - fields1410 := msg + fields1412 := msg p.write("(") p.write("paths") p.indentSexp() - if !(len(fields1410) == 0) { + if !(len(fields1412) == 0) { p.newline() - for i1412, elem1411 := range fields1410 { - if (i1412 > 0) { + for i1414, elem1413 := range fields1412 { + if (i1414 > 0) { p.newline() } - p.write(p.formatStringValue(elem1411)) + p.write(p.formatStringValue(elem1413)) } } p.dedent() @@ -3888,17 +3888,17 @@ func (p *PrettyPrinter) pretty_csv_locator_paths(msg []string) interface{} { } func (p *PrettyPrinter) pretty_csv_locator_inline_data(msg string) interface{} { - flat1415 := p.tryFlat(msg, func() { p.pretty_csv_locator_inline_data(msg) }) - if flat1415 != nil { - p.write(*flat1415) + flat1417 := p.tryFlat(msg, func() { p.pretty_csv_locator_inline_data(msg) }) + if flat1417 != nil { + p.write(*flat1417) return nil } else { - fields1414 := msg + fields1416 := msg p.write("(") p.write("inline_data") p.indentSexp() p.newline() - p.write(p.formatStringValue(fields1414)) + p.write(p.formatStringValue(fields1416)) p.dedent() p.write(")") } @@ -3906,27 +3906,27 @@ func (p *PrettyPrinter) pretty_csv_locator_inline_data(msg string) interface{} { } func (p *PrettyPrinter) pretty_csv_config(msg *pb.CSVConfig) interface{} { - flat1421 := p.tryFlat(msg, func() { p.pretty_csv_config(msg) }) - if flat1421 != nil { - p.write(*flat1421) + flat1423 := p.tryFlat(msg, func() { p.pretty_csv_config(msg) }) + if flat1423 != nil { + p.write(*flat1423) return nil } else { _dollar_dollar := msg - _t1739 := p.deconstruct_csv_config(_dollar_dollar) - _t1740 := p.deconstruct_csv_storage_integration_optional(_dollar_dollar) - fields1416 := []interface{}{_t1739, _t1740} - unwrapped_fields1417 := fields1416 + _t1743 := p.deconstruct_csv_config(_dollar_dollar) + _t1744 := p.deconstruct_csv_storage_integration_optional(_dollar_dollar) + fields1418 := []interface{}{_t1743, _t1744} + unwrapped_fields1419 := fields1418 p.write("(") p.write("csv_config") p.indentSexp() p.newline() - field1418 := unwrapped_fields1417[0].([][]interface{}) - p.pretty_config_dict(field1418) - field1419 := unwrapped_fields1417[1].([][]interface{}) - if field1419 != nil { + field1420 := unwrapped_fields1419[0].([][]interface{}) + p.pretty_config_dict(field1420) + field1421 := unwrapped_fields1419[1].([][]interface{}) + if field1421 != nil { p.newline() - opt_val1420 := field1419 - p.pretty__storage_integration(opt_val1420) + opt_val1422 := field1421 + p.pretty__storage_integration(opt_val1422) } p.dedent() p.write(")") @@ -3935,17 +3935,17 @@ func (p *PrettyPrinter) pretty_csv_config(msg *pb.CSVConfig) interface{} { } func (p *PrettyPrinter) pretty__storage_integration(msg [][]interface{}) interface{} { - flat1423 := p.tryFlat(msg, func() { p.pretty__storage_integration(msg) }) - if flat1423 != nil { - p.write(*flat1423) + flat1425 := p.tryFlat(msg, func() { p.pretty__storage_integration(msg) }) + if flat1425 != nil { + p.write(*flat1425) return nil } else { - fields1422 := msg + fields1424 := msg p.write("(") p.write("storage_integration") p.indentSexp() p.newline() - p.pretty_config_dict(fields1422) + p.pretty_config_dict(fields1424) p.dedent() p.write(")") } @@ -3953,22 +3953,22 @@ func (p *PrettyPrinter) pretty__storage_integration(msg [][]interface{}) interfa } func (p *PrettyPrinter) pretty_gnf_columns(msg []*pb.GNFColumn) interface{} { - flat1427 := p.tryFlat(msg, func() { p.pretty_gnf_columns(msg) }) - if flat1427 != nil { - p.write(*flat1427) + flat1429 := p.tryFlat(msg, func() { p.pretty_gnf_columns(msg) }) + if flat1429 != nil { + p.write(*flat1429) return nil } else { - fields1424 := msg + fields1426 := msg p.write("(") p.write("columns") p.indentSexp() - if !(len(fields1424) == 0) { + if !(len(fields1426) == 0) { p.newline() - for i1426, elem1425 := range fields1424 { - if (i1426 > 0) { + for i1428, elem1427 := range fields1426 { + if (i1428 > 0) { p.newline() } - p.pretty_gnf_column(elem1425) + p.pretty_gnf_column(elem1427) } } p.dedent() @@ -3978,38 +3978,38 @@ func (p *PrettyPrinter) pretty_gnf_columns(msg []*pb.GNFColumn) interface{} { } func (p *PrettyPrinter) pretty_gnf_column(msg *pb.GNFColumn) interface{} { - flat1436 := p.tryFlat(msg, func() { p.pretty_gnf_column(msg) }) - if flat1436 != nil { - p.write(*flat1436) + flat1438 := p.tryFlat(msg, func() { p.pretty_gnf_column(msg) }) + if flat1438 != nil { + p.write(*flat1438) return nil } else { _dollar_dollar := msg - var _t1741 *pb.RelationId + var _t1745 *pb.RelationId if hasProtoField(_dollar_dollar, "target_id") { - _t1741 = _dollar_dollar.GetTargetId() + _t1745 = _dollar_dollar.GetTargetId() } - fields1428 := []interface{}{_dollar_dollar.GetColumnPath(), _t1741, _dollar_dollar.GetTypes()} - unwrapped_fields1429 := fields1428 + fields1430 := []interface{}{_dollar_dollar.GetColumnPath(), _t1745, _dollar_dollar.GetTypes()} + unwrapped_fields1431 := fields1430 p.write("(") p.write("column") p.indentSexp() p.newline() - field1430 := unwrapped_fields1429[0].([]string) - p.pretty_gnf_column_path(field1430) - field1431 := unwrapped_fields1429[1].(*pb.RelationId) - if field1431 != nil { + field1432 := unwrapped_fields1431[0].([]string) + p.pretty_gnf_column_path(field1432) + field1433 := unwrapped_fields1431[1].(*pb.RelationId) + if field1433 != nil { p.newline() - opt_val1432 := field1431 - p.pretty_relation_id(opt_val1432) + opt_val1434 := field1433 + p.pretty_relation_id(opt_val1434) } p.newline() p.write("[") - field1433 := unwrapped_fields1429[2].([]*pb.Type) - for i1435, elem1434 := range field1433 { - if (i1435 > 0) { + field1435 := unwrapped_fields1431[2].([]*pb.Type) + for i1437, elem1436 := range field1435 { + if (i1437 > 0) { p.newline() } - p.pretty_type(elem1434) + p.pretty_type(elem1436) } p.write("]") p.dedent() @@ -4019,36 +4019,36 @@ func (p *PrettyPrinter) pretty_gnf_column(msg *pb.GNFColumn) interface{} { } func (p *PrettyPrinter) pretty_gnf_column_path(msg []string) interface{} { - flat1443 := p.tryFlat(msg, func() { p.pretty_gnf_column_path(msg) }) - if flat1443 != nil { - p.write(*flat1443) + flat1445 := p.tryFlat(msg, func() { p.pretty_gnf_column_path(msg) }) + if flat1445 != nil { + p.write(*flat1445) return nil } else { _dollar_dollar := msg - var _t1742 *string + var _t1746 *string if int64(len(_dollar_dollar)) == 1 { - _t1742 = ptr(_dollar_dollar[0]) + _t1746 = ptr(_dollar_dollar[0]) } - deconstruct_result1441 := _t1742 - if deconstruct_result1441 != nil { - unwrapped1442 := *deconstruct_result1441 - p.write(p.formatStringValue(unwrapped1442)) + deconstruct_result1443 := _t1746 + if deconstruct_result1443 != nil { + unwrapped1444 := *deconstruct_result1443 + p.write(p.formatStringValue(unwrapped1444)) } else { _dollar_dollar := msg - var _t1743 []string + var _t1747 []string if int64(len(_dollar_dollar)) != 1 { - _t1743 = _dollar_dollar + _t1747 = _dollar_dollar } - deconstruct_result1437 := _t1743 - if deconstruct_result1437 != nil { - unwrapped1438 := deconstruct_result1437 + deconstruct_result1439 := _t1747 + if deconstruct_result1439 != nil { + unwrapped1440 := deconstruct_result1439 p.write("[") p.indent() - for i1440, elem1439 := range unwrapped1438 { - if (i1440 > 0) { + for i1442, elem1441 := range unwrapped1440 { + if (i1442 > 0) { p.newline() } - p.write(p.formatStringValue(elem1439)) + p.write(p.formatStringValue(elem1441)) } p.dedent() p.write("]") @@ -4061,17 +4061,17 @@ func (p *PrettyPrinter) pretty_gnf_column_path(msg []string) interface{} { } func (p *PrettyPrinter) pretty_csv_asof(msg string) interface{} { - flat1445 := p.tryFlat(msg, func() { p.pretty_csv_asof(msg) }) - if flat1445 != nil { - p.write(*flat1445) + flat1447 := p.tryFlat(msg, func() { p.pretty_csv_asof(msg) }) + if flat1447 != nil { + p.write(*flat1447) return nil } else { - fields1444 := msg + fields1446 := msg p.write("(") p.write("asof") p.indentSexp() p.newline() - p.write(p.formatStringValue(fields1444)) + p.write(p.formatStringValue(fields1446)) p.dedent() p.write(")") } @@ -4079,43 +4079,43 @@ func (p *PrettyPrinter) pretty_csv_asof(msg string) interface{} { } func (p *PrettyPrinter) pretty_iceberg_data(msg *pb.IcebergData) interface{} { - flat1456 := p.tryFlat(msg, func() { p.pretty_iceberg_data(msg) }) - if flat1456 != nil { - p.write(*flat1456) + flat1458 := p.tryFlat(msg, func() { p.pretty_iceberg_data(msg) }) + if flat1458 != nil { + p.write(*flat1458) return nil } else { _dollar_dollar := msg - _t1744 := p.deconstruct_iceberg_data_from_snapshot_optional(_dollar_dollar) - _t1745 := p.deconstruct_iceberg_data_to_snapshot_optional(_dollar_dollar) - fields1446 := []interface{}{_dollar_dollar.GetLocator(), _dollar_dollar.GetConfig(), _dollar_dollar.GetColumns(), _t1744, _t1745, _dollar_dollar.GetReturnsDelta()} - unwrapped_fields1447 := fields1446 + _t1748 := p.deconstruct_iceberg_data_from_snapshot_optional(_dollar_dollar) + _t1749 := p.deconstruct_iceberg_data_to_snapshot_optional(_dollar_dollar) + fields1448 := []interface{}{_dollar_dollar.GetLocator(), _dollar_dollar.GetConfig(), _dollar_dollar.GetColumns(), _t1748, _t1749, _dollar_dollar.GetReturnsDelta()} + unwrapped_fields1449 := fields1448 p.write("(") p.write("iceberg_data") p.indentSexp() p.newline() - field1448 := unwrapped_fields1447[0].(*pb.IcebergLocator) - p.pretty_iceberg_locator(field1448) + field1450 := unwrapped_fields1449[0].(*pb.IcebergLocator) + p.pretty_iceberg_locator(field1450) p.newline() - field1449 := unwrapped_fields1447[1].(*pb.IcebergCatalogConfig) - p.pretty_iceberg_catalog_config(field1449) + field1451 := unwrapped_fields1449[1].(*pb.IcebergCatalogConfig) + p.pretty_iceberg_catalog_config(field1451) p.newline() - field1450 := unwrapped_fields1447[2].([]*pb.GNFColumn) - p.pretty_gnf_columns(field1450) - field1451 := unwrapped_fields1447[3].(*string) - if field1451 != nil { - p.newline() - opt_val1452 := *field1451 - p.pretty_iceberg_from_snapshot(opt_val1452) - } - field1453 := unwrapped_fields1447[4].(*string) + field1452 := unwrapped_fields1449[2].([]*pb.GNFColumn) + p.pretty_gnf_columns(field1452) + field1453 := unwrapped_fields1449[3].(*string) if field1453 != nil { p.newline() opt_val1454 := *field1453 - p.pretty_iceberg_to_snapshot(opt_val1454) + p.pretty_iceberg_from_snapshot(opt_val1454) + } + field1455 := unwrapped_fields1449[4].(*string) + if field1455 != nil { + p.newline() + opt_val1456 := *field1455 + p.pretty_iceberg_to_snapshot(opt_val1456) } p.newline() - field1455 := unwrapped_fields1447[5].(bool) - p.pretty_boolean_value(field1455) + field1457 := unwrapped_fields1449[5].(bool) + p.pretty_boolean_value(field1457) p.dedent() p.write(")") } @@ -4123,26 +4123,26 @@ func (p *PrettyPrinter) pretty_iceberg_data(msg *pb.IcebergData) interface{} { } func (p *PrettyPrinter) pretty_iceberg_locator(msg *pb.IcebergLocator) interface{} { - flat1462 := p.tryFlat(msg, func() { p.pretty_iceberg_locator(msg) }) - if flat1462 != nil { - p.write(*flat1462) + flat1464 := p.tryFlat(msg, func() { p.pretty_iceberg_locator(msg) }) + if flat1464 != nil { + p.write(*flat1464) return nil } else { _dollar_dollar := msg - fields1457 := []interface{}{_dollar_dollar.GetTableName(), _dollar_dollar.GetNamespace(), _dollar_dollar.GetWarehouse()} - unwrapped_fields1458 := fields1457 + fields1459 := []interface{}{_dollar_dollar.GetTableName(), _dollar_dollar.GetNamespace(), _dollar_dollar.GetWarehouse()} + unwrapped_fields1460 := fields1459 p.write("(") p.write("iceberg_locator") p.indentSexp() p.newline() - field1459 := unwrapped_fields1458[0].(string) - p.pretty_iceberg_locator_table_name(field1459) + field1461 := unwrapped_fields1460[0].(string) + p.pretty_iceberg_locator_table_name(field1461) p.newline() - field1460 := unwrapped_fields1458[1].([]string) - p.pretty_iceberg_locator_namespace(field1460) + field1462 := unwrapped_fields1460[1].([]string) + p.pretty_iceberg_locator_namespace(field1462) p.newline() - field1461 := unwrapped_fields1458[2].(string) - p.pretty_iceberg_locator_warehouse(field1461) + field1463 := unwrapped_fields1460[2].(string) + p.pretty_iceberg_locator_warehouse(field1463) p.dedent() p.write(")") } @@ -4150,17 +4150,17 @@ func (p *PrettyPrinter) pretty_iceberg_locator(msg *pb.IcebergLocator) interface } func (p *PrettyPrinter) pretty_iceberg_locator_table_name(msg string) interface{} { - flat1464 := p.tryFlat(msg, func() { p.pretty_iceberg_locator_table_name(msg) }) - if flat1464 != nil { - p.write(*flat1464) + flat1466 := p.tryFlat(msg, func() { p.pretty_iceberg_locator_table_name(msg) }) + if flat1466 != nil { + p.write(*flat1466) return nil } else { - fields1463 := msg + fields1465 := msg p.write("(") p.write("table_name") p.indentSexp() p.newline() - p.write(p.formatStringValue(fields1463)) + p.write(p.formatStringValue(fields1465)) p.dedent() p.write(")") } @@ -4168,22 +4168,22 @@ func (p *PrettyPrinter) pretty_iceberg_locator_table_name(msg string) interface{ } func (p *PrettyPrinter) pretty_iceberg_locator_namespace(msg []string) interface{} { - flat1468 := p.tryFlat(msg, func() { p.pretty_iceberg_locator_namespace(msg) }) - if flat1468 != nil { - p.write(*flat1468) + flat1470 := p.tryFlat(msg, func() { p.pretty_iceberg_locator_namespace(msg) }) + if flat1470 != nil { + p.write(*flat1470) return nil } else { - fields1465 := msg + fields1467 := msg p.write("(") p.write("namespace") p.indentSexp() - if !(len(fields1465) == 0) { + if !(len(fields1467) == 0) { p.newline() - for i1467, elem1466 := range fields1465 { - if (i1467 > 0) { + for i1469, elem1468 := range fields1467 { + if (i1469 > 0) { p.newline() } - p.write(p.formatStringValue(elem1466)) + p.write(p.formatStringValue(elem1468)) } } p.dedent() @@ -4193,17 +4193,17 @@ func (p *PrettyPrinter) pretty_iceberg_locator_namespace(msg []string) interface } func (p *PrettyPrinter) pretty_iceberg_locator_warehouse(msg string) interface{} { - flat1470 := p.tryFlat(msg, func() { p.pretty_iceberg_locator_warehouse(msg) }) - if flat1470 != nil { - p.write(*flat1470) + flat1472 := p.tryFlat(msg, func() { p.pretty_iceberg_locator_warehouse(msg) }) + if flat1472 != nil { + p.write(*flat1472) return nil } else { - fields1469 := msg + fields1471 := msg p.write("(") p.write("warehouse") p.indentSexp() p.newline() - p.write(p.formatStringValue(fields1469)) + p.write(p.formatStringValue(fields1471)) p.dedent() p.write(")") } @@ -4211,33 +4211,33 @@ func (p *PrettyPrinter) pretty_iceberg_locator_warehouse(msg string) interface{} } func (p *PrettyPrinter) pretty_iceberg_catalog_config(msg *pb.IcebergCatalogConfig) interface{} { - flat1478 := p.tryFlat(msg, func() { p.pretty_iceberg_catalog_config(msg) }) - if flat1478 != nil { - p.write(*flat1478) + flat1480 := p.tryFlat(msg, func() { p.pretty_iceberg_catalog_config(msg) }) + if flat1480 != nil { + p.write(*flat1480) return nil } else { _dollar_dollar := msg - _t1746 := p.deconstruct_iceberg_catalog_config_scope_optional(_dollar_dollar) - fields1471 := []interface{}{_dollar_dollar.GetCatalogUri(), _t1746, dictToPairs(_dollar_dollar.GetProperties()), dictToPairs(_dollar_dollar.GetAuthProperties())} - unwrapped_fields1472 := fields1471 + _t1750 := p.deconstruct_iceberg_catalog_config_scope_optional(_dollar_dollar) + fields1473 := []interface{}{_dollar_dollar.GetCatalogUri(), _t1750, dictToPairs(_dollar_dollar.GetProperties()), dictToPairs(_dollar_dollar.GetAuthProperties())} + unwrapped_fields1474 := fields1473 p.write("(") p.write("iceberg_catalog_config") p.indentSexp() p.newline() - field1473 := unwrapped_fields1472[0].(string) - p.pretty_iceberg_catalog_uri(field1473) - field1474 := unwrapped_fields1472[1].(*string) - if field1474 != nil { + field1475 := unwrapped_fields1474[0].(string) + p.pretty_iceberg_catalog_uri(field1475) + field1476 := unwrapped_fields1474[1].(*string) + if field1476 != nil { p.newline() - opt_val1475 := *field1474 - p.pretty_iceberg_catalog_config_scope(opt_val1475) + opt_val1477 := *field1476 + p.pretty_iceberg_catalog_config_scope(opt_val1477) } p.newline() - field1476 := unwrapped_fields1472[2].([][]interface{}) - p.pretty_iceberg_properties(field1476) + field1478 := unwrapped_fields1474[2].([][]interface{}) + p.pretty_iceberg_properties(field1478) p.newline() - field1477 := unwrapped_fields1472[3].([][]interface{}) - p.pretty_iceberg_auth_properties(field1477) + field1479 := unwrapped_fields1474[3].([][]interface{}) + p.pretty_iceberg_auth_properties(field1479) p.dedent() p.write(")") } @@ -4245,17 +4245,17 @@ func (p *PrettyPrinter) pretty_iceberg_catalog_config(msg *pb.IcebergCatalogConf } func (p *PrettyPrinter) pretty_iceberg_catalog_uri(msg string) interface{} { - flat1480 := p.tryFlat(msg, func() { p.pretty_iceberg_catalog_uri(msg) }) - if flat1480 != nil { - p.write(*flat1480) + flat1482 := p.tryFlat(msg, func() { p.pretty_iceberg_catalog_uri(msg) }) + if flat1482 != nil { + p.write(*flat1482) return nil } else { - fields1479 := msg + fields1481 := msg p.write("(") p.write("catalog_uri") p.indentSexp() p.newline() - p.write(p.formatStringValue(fields1479)) + p.write(p.formatStringValue(fields1481)) p.dedent() p.write(")") } @@ -4263,17 +4263,17 @@ func (p *PrettyPrinter) pretty_iceberg_catalog_uri(msg string) interface{} { } func (p *PrettyPrinter) pretty_iceberg_catalog_config_scope(msg string) interface{} { - flat1482 := p.tryFlat(msg, func() { p.pretty_iceberg_catalog_config_scope(msg) }) - if flat1482 != nil { - p.write(*flat1482) + flat1484 := p.tryFlat(msg, func() { p.pretty_iceberg_catalog_config_scope(msg) }) + if flat1484 != nil { + p.write(*flat1484) return nil } else { - fields1481 := msg + fields1483 := msg p.write("(") p.write("scope") p.indentSexp() p.newline() - p.write(p.formatStringValue(fields1481)) + p.write(p.formatStringValue(fields1483)) p.dedent() p.write(")") } @@ -4281,22 +4281,22 @@ func (p *PrettyPrinter) pretty_iceberg_catalog_config_scope(msg string) interfac } func (p *PrettyPrinter) pretty_iceberg_properties(msg [][]interface{}) interface{} { - flat1486 := p.tryFlat(msg, func() { p.pretty_iceberg_properties(msg) }) - if flat1486 != nil { - p.write(*flat1486) + flat1488 := p.tryFlat(msg, func() { p.pretty_iceberg_properties(msg) }) + if flat1488 != nil { + p.write(*flat1488) return nil } else { - fields1483 := msg + fields1485 := msg p.write("(") p.write("properties") p.indentSexp() - if !(len(fields1483) == 0) { + if !(len(fields1485) == 0) { p.newline() - for i1485, elem1484 := range fields1483 { - if (i1485 > 0) { + for i1487, elem1486 := range fields1485 { + if (i1487 > 0) { p.newline() } - p.pretty_iceberg_property_entry(elem1484) + p.pretty_iceberg_property_entry(elem1486) } } p.dedent() @@ -4306,23 +4306,23 @@ func (p *PrettyPrinter) pretty_iceberg_properties(msg [][]interface{}) interface } func (p *PrettyPrinter) pretty_iceberg_property_entry(msg []interface{}) interface{} { - flat1491 := p.tryFlat(msg, func() { p.pretty_iceberg_property_entry(msg) }) - if flat1491 != nil { - p.write(*flat1491) + flat1493 := p.tryFlat(msg, func() { p.pretty_iceberg_property_entry(msg) }) + if flat1493 != nil { + p.write(*flat1493) return nil } else { _dollar_dollar := msg - fields1487 := []interface{}{_dollar_dollar[0].(string), _dollar_dollar[1].(string)} - unwrapped_fields1488 := fields1487 + fields1489 := []interface{}{_dollar_dollar[0].(string), _dollar_dollar[1].(string)} + unwrapped_fields1490 := fields1489 p.write("(") p.write("prop") p.indentSexp() p.newline() - field1489 := unwrapped_fields1488[0].(string) - p.write(p.formatStringValue(field1489)) + field1491 := unwrapped_fields1490[0].(string) + p.write(p.formatStringValue(field1491)) p.newline() - field1490 := unwrapped_fields1488[1].(string) - p.write(p.formatStringValue(field1490)) + field1492 := unwrapped_fields1490[1].(string) + p.write(p.formatStringValue(field1492)) p.dedent() p.write(")") } @@ -4330,22 +4330,22 @@ func (p *PrettyPrinter) pretty_iceberg_property_entry(msg []interface{}) interfa } func (p *PrettyPrinter) pretty_iceberg_auth_properties(msg [][]interface{}) interface{} { - flat1495 := p.tryFlat(msg, func() { p.pretty_iceberg_auth_properties(msg) }) - if flat1495 != nil { - p.write(*flat1495) + flat1497 := p.tryFlat(msg, func() { p.pretty_iceberg_auth_properties(msg) }) + if flat1497 != nil { + p.write(*flat1497) return nil } else { - fields1492 := msg + fields1494 := msg p.write("(") p.write("auth_properties") p.indentSexp() - if !(len(fields1492) == 0) { + if !(len(fields1494) == 0) { p.newline() - for i1494, elem1493 := range fields1492 { - if (i1494 > 0) { + for i1496, elem1495 := range fields1494 { + if (i1496 > 0) { p.newline() } - p.pretty_iceberg_masked_property_entry(elem1493) + p.pretty_iceberg_masked_property_entry(elem1495) } } p.dedent() @@ -4355,24 +4355,24 @@ func (p *PrettyPrinter) pretty_iceberg_auth_properties(msg [][]interface{}) inte } func (p *PrettyPrinter) pretty_iceberg_masked_property_entry(msg []interface{}) interface{} { - flat1500 := p.tryFlat(msg, func() { p.pretty_iceberg_masked_property_entry(msg) }) - if flat1500 != nil { - p.write(*flat1500) + flat1502 := p.tryFlat(msg, func() { p.pretty_iceberg_masked_property_entry(msg) }) + if flat1502 != nil { + p.write(*flat1502) return nil } else { _dollar_dollar := msg - _t1747 := p.mask_secret_value(_dollar_dollar) - fields1496 := []interface{}{_dollar_dollar[0].(string), _t1747} - unwrapped_fields1497 := fields1496 + _t1751 := p.mask_secret_value(_dollar_dollar) + fields1498 := []interface{}{_dollar_dollar[0].(string), _t1751} + unwrapped_fields1499 := fields1498 p.write("(") p.write("prop") p.indentSexp() p.newline() - field1498 := unwrapped_fields1497[0].(string) - p.write(p.formatStringValue(field1498)) + field1500 := unwrapped_fields1499[0].(string) + p.write(p.formatStringValue(field1500)) p.newline() - field1499 := unwrapped_fields1497[1].(string) - p.write(p.formatStringValue(field1499)) + field1501 := unwrapped_fields1499[1].(string) + p.write(p.formatStringValue(field1501)) p.dedent() p.write(")") } @@ -4380,17 +4380,17 @@ func (p *PrettyPrinter) pretty_iceberg_masked_property_entry(msg []interface{}) } func (p *PrettyPrinter) pretty_iceberg_from_snapshot(msg string) interface{} { - flat1502 := p.tryFlat(msg, func() { p.pretty_iceberg_from_snapshot(msg) }) - if flat1502 != nil { - p.write(*flat1502) + flat1504 := p.tryFlat(msg, func() { p.pretty_iceberg_from_snapshot(msg) }) + if flat1504 != nil { + p.write(*flat1504) return nil } else { - fields1501 := msg + fields1503 := msg p.write("(") p.write("from_snapshot") p.indentSexp() p.newline() - p.write(p.formatStringValue(fields1501)) + p.write(p.formatStringValue(fields1503)) p.dedent() p.write(")") } @@ -4398,17 +4398,17 @@ func (p *PrettyPrinter) pretty_iceberg_from_snapshot(msg string) interface{} { } func (p *PrettyPrinter) pretty_iceberg_to_snapshot(msg string) interface{} { - flat1504 := p.tryFlat(msg, func() { p.pretty_iceberg_to_snapshot(msg) }) - if flat1504 != nil { - p.write(*flat1504) + flat1506 := p.tryFlat(msg, func() { p.pretty_iceberg_to_snapshot(msg) }) + if flat1506 != nil { + p.write(*flat1506) return nil } else { - fields1503 := msg + fields1505 := msg p.write("(") p.write("to_snapshot") p.indentSexp() p.newline() - p.write(p.formatStringValue(fields1503)) + p.write(p.formatStringValue(fields1505)) p.dedent() p.write(")") } @@ -4416,19 +4416,19 @@ func (p *PrettyPrinter) pretty_iceberg_to_snapshot(msg string) interface{} { } func (p *PrettyPrinter) pretty_undefine(msg *pb.Undefine) interface{} { - flat1507 := p.tryFlat(msg, func() { p.pretty_undefine(msg) }) - if flat1507 != nil { - p.write(*flat1507) + flat1509 := p.tryFlat(msg, func() { p.pretty_undefine(msg) }) + if flat1509 != nil { + p.write(*flat1509) return nil } else { _dollar_dollar := msg - fields1505 := _dollar_dollar.GetFragmentId() - unwrapped_fields1506 := fields1505 + fields1507 := _dollar_dollar.GetFragmentId() + unwrapped_fields1508 := fields1507 p.write("(") p.write("undefine") p.indentSexp() p.newline() - p.pretty_fragment_id(unwrapped_fields1506) + p.pretty_fragment_id(unwrapped_fields1508) p.dedent() p.write(")") } @@ -4436,24 +4436,24 @@ func (p *PrettyPrinter) pretty_undefine(msg *pb.Undefine) interface{} { } func (p *PrettyPrinter) pretty_context(msg *pb.Context) interface{} { - flat1512 := p.tryFlat(msg, func() { p.pretty_context(msg) }) - if flat1512 != nil { - p.write(*flat1512) + flat1514 := p.tryFlat(msg, func() { p.pretty_context(msg) }) + if flat1514 != nil { + p.write(*flat1514) return nil } else { _dollar_dollar := msg - fields1508 := _dollar_dollar.GetRelations() - unwrapped_fields1509 := fields1508 + fields1510 := _dollar_dollar.GetRelations() + unwrapped_fields1511 := fields1510 p.write("(") p.write("context") p.indentSexp() - if !(len(unwrapped_fields1509) == 0) { + if !(len(unwrapped_fields1511) == 0) { p.newline() - for i1511, elem1510 := range unwrapped_fields1509 { - if (i1511 > 0) { + for i1513, elem1512 := range unwrapped_fields1511 { + if (i1513 > 0) { p.newline() } - p.pretty_relation_id(elem1510) + p.pretty_relation_id(elem1512) } } p.dedent() @@ -4463,28 +4463,28 @@ func (p *PrettyPrinter) pretty_context(msg *pb.Context) interface{} { } func (p *PrettyPrinter) pretty_snapshot(msg *pb.Snapshot) interface{} { - flat1519 := p.tryFlat(msg, func() { p.pretty_snapshot(msg) }) - if flat1519 != nil { - p.write(*flat1519) + flat1521 := p.tryFlat(msg, func() { p.pretty_snapshot(msg) }) + if flat1521 != nil { + p.write(*flat1521) return nil } else { _dollar_dollar := msg - fields1513 := []interface{}{_dollar_dollar.GetPrefix(), _dollar_dollar.GetMappings()} - unwrapped_fields1514 := fields1513 + fields1515 := []interface{}{_dollar_dollar.GetPrefix(), _dollar_dollar.GetMappings()} + unwrapped_fields1516 := fields1515 p.write("(") p.write("snapshot") p.indentSexp() p.newline() - field1515 := unwrapped_fields1514[0].([]string) - p.pretty_edb_path(field1515) - field1516 := unwrapped_fields1514[1].([]*pb.SnapshotMapping) - if !(len(field1516) == 0) { + field1517 := unwrapped_fields1516[0].([]string) + p.pretty_edb_path(field1517) + field1518 := unwrapped_fields1516[1].([]*pb.SnapshotMapping) + if !(len(field1518) == 0) { p.newline() - for i1518, elem1517 := range field1516 { - if (i1518 > 0) { + for i1520, elem1519 := range field1518 { + if (i1520 > 0) { p.newline() } - p.pretty_snapshot_mapping(elem1517) + p.pretty_snapshot_mapping(elem1519) } } p.dedent() @@ -4494,40 +4494,40 @@ func (p *PrettyPrinter) pretty_snapshot(msg *pb.Snapshot) interface{} { } func (p *PrettyPrinter) pretty_snapshot_mapping(msg *pb.SnapshotMapping) interface{} { - flat1524 := p.tryFlat(msg, func() { p.pretty_snapshot_mapping(msg) }) - if flat1524 != nil { - p.write(*flat1524) + flat1526 := p.tryFlat(msg, func() { p.pretty_snapshot_mapping(msg) }) + if flat1526 != nil { + p.write(*flat1526) return nil } else { _dollar_dollar := msg - fields1520 := []interface{}{_dollar_dollar.GetDestinationPath(), _dollar_dollar.GetSourceRelation()} - unwrapped_fields1521 := fields1520 - field1522 := unwrapped_fields1521[0].([]string) - p.pretty_edb_path(field1522) + fields1522 := []interface{}{_dollar_dollar.GetDestinationPath(), _dollar_dollar.GetSourceRelation()} + unwrapped_fields1523 := fields1522 + field1524 := unwrapped_fields1523[0].([]string) + p.pretty_edb_path(field1524) p.write(" ") - field1523 := unwrapped_fields1521[1].(*pb.RelationId) - p.pretty_relation_id(field1523) + field1525 := unwrapped_fields1523[1].(*pb.RelationId) + p.pretty_relation_id(field1525) } return nil } func (p *PrettyPrinter) pretty_epoch_reads(msg []*pb.Read) interface{} { - flat1528 := p.tryFlat(msg, func() { p.pretty_epoch_reads(msg) }) - if flat1528 != nil { - p.write(*flat1528) + flat1530 := p.tryFlat(msg, func() { p.pretty_epoch_reads(msg) }) + if flat1530 != nil { + p.write(*flat1530) return nil } else { - fields1525 := msg + fields1527 := msg p.write("(") p.write("reads") p.indentSexp() - if !(len(fields1525) == 0) { + if !(len(fields1527) == 0) { p.newline() - for i1527, elem1526 := range fields1525 { - if (i1527 > 0) { + for i1529, elem1528 := range fields1527 { + if (i1529 > 0) { p.newline() } - p.pretty_read(elem1526) + p.pretty_read(elem1528) } } p.dedent() @@ -4537,70 +4537,70 @@ func (p *PrettyPrinter) pretty_epoch_reads(msg []*pb.Read) interface{} { } func (p *PrettyPrinter) pretty_read(msg *pb.Read) interface{} { - flat1541 := p.tryFlat(msg, func() { p.pretty_read(msg) }) - if flat1541 != nil { - p.write(*flat1541) + flat1543 := p.tryFlat(msg, func() { p.pretty_read(msg) }) + if flat1543 != nil { + p.write(*flat1543) return nil } else { _dollar_dollar := msg - var _t1748 *pb.Demand + var _t1752 *pb.Demand if hasProtoField(_dollar_dollar, "demand") { - _t1748 = _dollar_dollar.GetDemand() + _t1752 = _dollar_dollar.GetDemand() } - deconstruct_result1539 := _t1748 - if deconstruct_result1539 != nil { - unwrapped1540 := deconstruct_result1539 - p.pretty_demand(unwrapped1540) + deconstruct_result1541 := _t1752 + if deconstruct_result1541 != nil { + unwrapped1542 := deconstruct_result1541 + p.pretty_demand(unwrapped1542) } else { _dollar_dollar := msg - var _t1749 *pb.Output + var _t1753 *pb.Output if hasProtoField(_dollar_dollar, "output") { - _t1749 = _dollar_dollar.GetOutput() + _t1753 = _dollar_dollar.GetOutput() } - deconstruct_result1537 := _t1749 - if deconstruct_result1537 != nil { - unwrapped1538 := deconstruct_result1537 - p.pretty_output(unwrapped1538) + deconstruct_result1539 := _t1753 + if deconstruct_result1539 != nil { + unwrapped1540 := deconstruct_result1539 + p.pretty_output(unwrapped1540) } else { _dollar_dollar := msg - var _t1750 *pb.WhatIf + var _t1754 *pb.WhatIf if hasProtoField(_dollar_dollar, "what_if") { - _t1750 = _dollar_dollar.GetWhatIf() + _t1754 = _dollar_dollar.GetWhatIf() } - deconstruct_result1535 := _t1750 - if deconstruct_result1535 != nil { - unwrapped1536 := deconstruct_result1535 - p.pretty_what_if(unwrapped1536) + deconstruct_result1537 := _t1754 + if deconstruct_result1537 != nil { + unwrapped1538 := deconstruct_result1537 + p.pretty_what_if(unwrapped1538) } else { _dollar_dollar := msg - var _t1751 *pb.Abort + var _t1755 *pb.Abort if hasProtoField(_dollar_dollar, "abort") { - _t1751 = _dollar_dollar.GetAbort() + _t1755 = _dollar_dollar.GetAbort() } - deconstruct_result1533 := _t1751 - if deconstruct_result1533 != nil { - unwrapped1534 := deconstruct_result1533 - p.pretty_abort(unwrapped1534) + deconstruct_result1535 := _t1755 + if deconstruct_result1535 != nil { + unwrapped1536 := deconstruct_result1535 + p.pretty_abort(unwrapped1536) } else { _dollar_dollar := msg - var _t1752 *pb.Export + var _t1756 *pb.Export if hasProtoField(_dollar_dollar, "export") { - _t1752 = _dollar_dollar.GetExport() + _t1756 = _dollar_dollar.GetExport() } - deconstruct_result1531 := _t1752 - if deconstruct_result1531 != nil { - unwrapped1532 := deconstruct_result1531 - p.pretty_export(unwrapped1532) + deconstruct_result1533 := _t1756 + if deconstruct_result1533 != nil { + unwrapped1534 := deconstruct_result1533 + p.pretty_export(unwrapped1534) } else { _dollar_dollar := msg - var _t1753 *pb.ExportOutput + var _t1757 *pb.ExportOutput if hasProtoField(_dollar_dollar, "export_output") { - _t1753 = _dollar_dollar.GetExportOutput() + _t1757 = _dollar_dollar.GetExportOutput() } - deconstruct_result1529 := _t1753 - if deconstruct_result1529 != nil { - unwrapped1530 := deconstruct_result1529 - p.pretty_export_output(unwrapped1530) + deconstruct_result1531 := _t1757 + if deconstruct_result1531 != nil { + unwrapped1532 := deconstruct_result1531 + p.pretty_export_output(unwrapped1532) } else { panic(ParseError{msg: "No matching rule for read"}) } @@ -4614,19 +4614,19 @@ func (p *PrettyPrinter) pretty_read(msg *pb.Read) interface{} { } func (p *PrettyPrinter) pretty_demand(msg *pb.Demand) interface{} { - flat1544 := p.tryFlat(msg, func() { p.pretty_demand(msg) }) - if flat1544 != nil { - p.write(*flat1544) + flat1546 := p.tryFlat(msg, func() { p.pretty_demand(msg) }) + if flat1546 != nil { + p.write(*flat1546) return nil } else { _dollar_dollar := msg - fields1542 := _dollar_dollar.GetRelationId() - unwrapped_fields1543 := fields1542 + fields1544 := _dollar_dollar.GetRelationId() + unwrapped_fields1545 := fields1544 p.write("(") p.write("demand") p.indentSexp() p.newline() - p.pretty_relation_id(unwrapped_fields1543) + p.pretty_relation_id(unwrapped_fields1545) p.dedent() p.write(")") } @@ -4634,23 +4634,23 @@ func (p *PrettyPrinter) pretty_demand(msg *pb.Demand) interface{} { } func (p *PrettyPrinter) pretty_output(msg *pb.Output) interface{} { - flat1549 := p.tryFlat(msg, func() { p.pretty_output(msg) }) - if flat1549 != nil { - p.write(*flat1549) + flat1551 := p.tryFlat(msg, func() { p.pretty_output(msg) }) + if flat1551 != nil { + p.write(*flat1551) return nil } else { _dollar_dollar := msg - fields1545 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetRelationId()} - unwrapped_fields1546 := fields1545 + fields1547 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetRelationId()} + unwrapped_fields1548 := fields1547 p.write("(") p.write("output") p.indentSexp() p.newline() - field1547 := unwrapped_fields1546[0].(string) - p.pretty_name(field1547) + field1549 := unwrapped_fields1548[0].(string) + p.pretty_name(field1549) p.newline() - field1548 := unwrapped_fields1546[1].(*pb.RelationId) - p.pretty_relation_id(field1548) + field1550 := unwrapped_fields1548[1].(*pb.RelationId) + p.pretty_relation_id(field1550) p.dedent() p.write(")") } @@ -4658,23 +4658,23 @@ func (p *PrettyPrinter) pretty_output(msg *pb.Output) interface{} { } func (p *PrettyPrinter) pretty_what_if(msg *pb.WhatIf) interface{} { - flat1554 := p.tryFlat(msg, func() { p.pretty_what_if(msg) }) - if flat1554 != nil { - p.write(*flat1554) + flat1556 := p.tryFlat(msg, func() { p.pretty_what_if(msg) }) + if flat1556 != nil { + p.write(*flat1556) return nil } else { _dollar_dollar := msg - fields1550 := []interface{}{_dollar_dollar.GetBranch(), _dollar_dollar.GetEpoch()} - unwrapped_fields1551 := fields1550 + fields1552 := []interface{}{_dollar_dollar.GetBranch(), _dollar_dollar.GetEpoch()} + unwrapped_fields1553 := fields1552 p.write("(") p.write("what_if") p.indentSexp() p.newline() - field1552 := unwrapped_fields1551[0].(string) - p.pretty_name(field1552) + field1554 := unwrapped_fields1553[0].(string) + p.pretty_name(field1554) p.newline() - field1553 := unwrapped_fields1551[1].(*pb.Epoch) - p.pretty_epoch(field1553) + field1555 := unwrapped_fields1553[1].(*pb.Epoch) + p.pretty_epoch(field1555) p.dedent() p.write(")") } @@ -4682,30 +4682,30 @@ func (p *PrettyPrinter) pretty_what_if(msg *pb.WhatIf) interface{} { } func (p *PrettyPrinter) pretty_abort(msg *pb.Abort) interface{} { - flat1560 := p.tryFlat(msg, func() { p.pretty_abort(msg) }) - if flat1560 != nil { - p.write(*flat1560) + flat1562 := p.tryFlat(msg, func() { p.pretty_abort(msg) }) + if flat1562 != nil { + p.write(*flat1562) return nil } else { _dollar_dollar := msg - var _t1754 *string + var _t1758 *string if _dollar_dollar.GetName() != "abort" { - _t1754 = ptr(_dollar_dollar.GetName()) + _t1758 = ptr(_dollar_dollar.GetName()) } - fields1555 := []interface{}{_t1754, _dollar_dollar.GetRelationId()} - unwrapped_fields1556 := fields1555 + fields1557 := []interface{}{_t1758, _dollar_dollar.GetRelationId()} + unwrapped_fields1558 := fields1557 p.write("(") p.write("abort") p.indentSexp() - field1557 := unwrapped_fields1556[0].(*string) - if field1557 != nil { + field1559 := unwrapped_fields1558[0].(*string) + if field1559 != nil { p.newline() - opt_val1558 := *field1557 - p.pretty_name(opt_val1558) + opt_val1560 := *field1559 + p.pretty_name(opt_val1560) } p.newline() - field1559 := unwrapped_fields1556[1].(*pb.RelationId) - p.pretty_relation_id(field1559) + field1561 := unwrapped_fields1558[1].(*pb.RelationId) + p.pretty_relation_id(field1561) p.dedent() p.write(")") } @@ -4713,40 +4713,40 @@ func (p *PrettyPrinter) pretty_abort(msg *pb.Abort) interface{} { } func (p *PrettyPrinter) pretty_export(msg *pb.Export) interface{} { - flat1565 := p.tryFlat(msg, func() { p.pretty_export(msg) }) - if flat1565 != nil { - p.write(*flat1565) + flat1567 := p.tryFlat(msg, func() { p.pretty_export(msg) }) + if flat1567 != nil { + p.write(*flat1567) return nil } else { _dollar_dollar := msg - var _t1755 *pb.ExportCSVConfig + var _t1759 *pb.ExportCSVConfig if hasProtoField(_dollar_dollar, "csv_config") { - _t1755 = _dollar_dollar.GetCsvConfig() + _t1759 = _dollar_dollar.GetCsvConfig() } - deconstruct_result1563 := _t1755 - if deconstruct_result1563 != nil { - unwrapped1564 := deconstruct_result1563 + deconstruct_result1565 := _t1759 + if deconstruct_result1565 != nil { + unwrapped1566 := deconstruct_result1565 p.write("(") p.write("export") p.indentSexp() p.newline() - p.pretty_export_csv_config(unwrapped1564) + p.pretty_export_csv_config(unwrapped1566) p.dedent() p.write(")") } else { _dollar_dollar := msg - var _t1756 *pb.ExportIcebergConfig + var _t1760 *pb.ExportIcebergConfig if hasProtoField(_dollar_dollar, "iceberg_config") { - _t1756 = _dollar_dollar.GetIcebergConfig() + _t1760 = _dollar_dollar.GetIcebergConfig() } - deconstruct_result1561 := _t1756 - if deconstruct_result1561 != nil { - unwrapped1562 := deconstruct_result1561 + deconstruct_result1563 := _t1760 + if deconstruct_result1563 != nil { + unwrapped1564 := deconstruct_result1563 p.write("(") p.write("export_iceberg") p.indentSexp() p.newline() - p.pretty_export_iceberg_config(unwrapped1562) + p.pretty_export_iceberg_config(unwrapped1564) p.dedent() p.write(")") } else { @@ -4758,55 +4758,55 @@ func (p *PrettyPrinter) pretty_export(msg *pb.Export) interface{} { } func (p *PrettyPrinter) pretty_export_csv_config(msg *pb.ExportCSVConfig) interface{} { - flat1576 := p.tryFlat(msg, func() { p.pretty_export_csv_config(msg) }) - if flat1576 != nil { - p.write(*flat1576) + flat1578 := p.tryFlat(msg, func() { p.pretty_export_csv_config(msg) }) + if flat1578 != nil { + p.write(*flat1578) return nil } else { _dollar_dollar := msg - var _t1757 []interface{} + var _t1761 []interface{} if int64(len(_dollar_dollar.GetDataColumns())) == 0 { - _t1757 = []interface{}{_dollar_dollar.GetPath(), _dollar_dollar.GetCsvSource(), _dollar_dollar.GetCsvConfig()} + _t1761 = []interface{}{_dollar_dollar.GetPath(), _dollar_dollar.GetCsvSource(), _dollar_dollar.GetCsvConfig()} } - deconstruct_result1571 := _t1757 - if deconstruct_result1571 != nil { - unwrapped1572 := deconstruct_result1571 + deconstruct_result1573 := _t1761 + if deconstruct_result1573 != nil { + unwrapped1574 := deconstruct_result1573 p.write("(") p.write("export_csv_config_v2") p.indentSexp() p.newline() - field1573 := unwrapped1572[0].(string) - p.pretty_export_csv_path(field1573) + field1575 := unwrapped1574[0].(string) + p.pretty_export_csv_path(field1575) p.newline() - field1574 := unwrapped1572[1].(*pb.ExportCSVSource) - p.pretty_export_csv_source(field1574) + field1576 := unwrapped1574[1].(*pb.ExportCSVSource) + p.pretty_export_csv_source(field1576) p.newline() - field1575 := unwrapped1572[2].(*pb.CSVConfig) - p.pretty_csv_config(field1575) + field1577 := unwrapped1574[2].(*pb.CSVConfig) + p.pretty_csv_config(field1577) p.dedent() p.write(")") } else { _dollar_dollar := msg - var _t1758 []interface{} + var _t1762 []interface{} if int64(len(_dollar_dollar.GetDataColumns())) != 0 { - _t1759 := p.deconstruct_export_csv_config(_dollar_dollar) - _t1758 = []interface{}{_dollar_dollar.GetPath(), _dollar_dollar.GetDataColumns(), _t1759} + _t1763 := p.deconstruct_export_csv_config(_dollar_dollar) + _t1762 = []interface{}{_dollar_dollar.GetPath(), _dollar_dollar.GetDataColumns(), _t1763} } - deconstruct_result1566 := _t1758 - if deconstruct_result1566 != nil { - unwrapped1567 := deconstruct_result1566 + deconstruct_result1568 := _t1762 + if deconstruct_result1568 != nil { + unwrapped1569 := deconstruct_result1568 p.write("(") p.write("export_csv_config") p.indentSexp() p.newline() - field1568 := unwrapped1567[0].(string) - p.pretty_export_csv_path(field1568) + field1570 := unwrapped1569[0].(string) + p.pretty_export_csv_path(field1570) p.newline() - field1569 := unwrapped1567[1].([]*pb.ExportCSVColumn) - p.pretty_export_csv_columns_list(field1569) + field1571 := unwrapped1569[1].([]*pb.ExportCSVColumn) + p.pretty_export_csv_columns_list(field1571) p.newline() - field1570 := unwrapped1567[2].([][]interface{}) - p.pretty_config_dict(field1570) + field1572 := unwrapped1569[2].([][]interface{}) + p.pretty_config_dict(field1572) p.dedent() p.write(")") } else { @@ -4818,17 +4818,17 @@ func (p *PrettyPrinter) pretty_export_csv_config(msg *pb.ExportCSVConfig) interf } func (p *PrettyPrinter) pretty_export_csv_path(msg string) interface{} { - flat1578 := p.tryFlat(msg, func() { p.pretty_export_csv_path(msg) }) - if flat1578 != nil { - p.write(*flat1578) + flat1580 := p.tryFlat(msg, func() { p.pretty_export_csv_path(msg) }) + if flat1580 != nil { + p.write(*flat1580) return nil } else { - fields1577 := msg + fields1579 := msg p.write("(") p.write("path") p.indentSexp() p.newline() - p.write(p.formatStringValue(fields1577)) + p.write(p.formatStringValue(fields1579)) p.dedent() p.write(")") } @@ -4836,47 +4836,47 @@ func (p *PrettyPrinter) pretty_export_csv_path(msg string) interface{} { } func (p *PrettyPrinter) pretty_export_csv_source(msg *pb.ExportCSVSource) interface{} { - flat1585 := p.tryFlat(msg, func() { p.pretty_export_csv_source(msg) }) - if flat1585 != nil { - p.write(*flat1585) + flat1587 := p.tryFlat(msg, func() { p.pretty_export_csv_source(msg) }) + if flat1587 != nil { + p.write(*flat1587) return nil } else { _dollar_dollar := msg - var _t1760 []*pb.ExportCSVColumn + var _t1764 []*pb.ExportCSVColumn if hasProtoField(_dollar_dollar, "gnf_columns") { - _t1760 = _dollar_dollar.GetGnfColumns().GetColumns() + _t1764 = _dollar_dollar.GetGnfColumns().GetColumns() } - deconstruct_result1581 := _t1760 - if deconstruct_result1581 != nil { - unwrapped1582 := deconstruct_result1581 + deconstruct_result1583 := _t1764 + if deconstruct_result1583 != nil { + unwrapped1584 := deconstruct_result1583 p.write("(") p.write("gnf_columns") p.indentSexp() - if !(len(unwrapped1582) == 0) { + if !(len(unwrapped1584) == 0) { p.newline() - for i1584, elem1583 := range unwrapped1582 { - if (i1584 > 0) { + for i1586, elem1585 := range unwrapped1584 { + if (i1586 > 0) { p.newline() } - p.pretty_export_csv_column(elem1583) + p.pretty_export_csv_column(elem1585) } } p.dedent() p.write(")") } else { _dollar_dollar := msg - var _t1761 *pb.RelationId + var _t1765 *pb.RelationId if hasProtoField(_dollar_dollar, "table_def") { - _t1761 = _dollar_dollar.GetTableDef() + _t1765 = _dollar_dollar.GetTableDef() } - deconstruct_result1579 := _t1761 - if deconstruct_result1579 != nil { - unwrapped1580 := deconstruct_result1579 + deconstruct_result1581 := _t1765 + if deconstruct_result1581 != nil { + unwrapped1582 := deconstruct_result1581 p.write("(") p.write("table_def") p.indentSexp() p.newline() - p.pretty_relation_id(unwrapped1580) + p.pretty_relation_id(unwrapped1582) p.dedent() p.write(")") } else { @@ -4888,23 +4888,23 @@ func (p *PrettyPrinter) pretty_export_csv_source(msg *pb.ExportCSVSource) interf } func (p *PrettyPrinter) pretty_export_csv_column(msg *pb.ExportCSVColumn) interface{} { - flat1590 := p.tryFlat(msg, func() { p.pretty_export_csv_column(msg) }) - if flat1590 != nil { - p.write(*flat1590) + flat1592 := p.tryFlat(msg, func() { p.pretty_export_csv_column(msg) }) + if flat1592 != nil { + p.write(*flat1592) return nil } else { _dollar_dollar := msg - fields1586 := []interface{}{_dollar_dollar.GetColumnName(), _dollar_dollar.GetColumnData()} - unwrapped_fields1587 := fields1586 + fields1588 := []interface{}{_dollar_dollar.GetColumnName(), _dollar_dollar.GetColumnData()} + unwrapped_fields1589 := fields1588 p.write("(") p.write("column") p.indentSexp() p.newline() - field1588 := unwrapped_fields1587[0].(string) - p.write(p.formatStringValue(field1588)) + field1590 := unwrapped_fields1589[0].(string) + p.write(p.formatStringValue(field1590)) p.newline() - field1589 := unwrapped_fields1587[1].(*pb.RelationId) - p.pretty_relation_id(field1589) + field1591 := unwrapped_fields1589[1].(*pb.RelationId) + p.pretty_relation_id(field1591) p.dedent() p.write(")") } @@ -4912,22 +4912,22 @@ func (p *PrettyPrinter) pretty_export_csv_column(msg *pb.ExportCSVColumn) interf } func (p *PrettyPrinter) pretty_export_csv_columns_list(msg []*pb.ExportCSVColumn) interface{} { - flat1594 := p.tryFlat(msg, func() { p.pretty_export_csv_columns_list(msg) }) - if flat1594 != nil { - p.write(*flat1594) + flat1596 := p.tryFlat(msg, func() { p.pretty_export_csv_columns_list(msg) }) + if flat1596 != nil { + p.write(*flat1596) return nil } else { - fields1591 := msg + fields1593 := msg p.write("(") p.write("columns") p.indentSexp() - if !(len(fields1591) == 0) { + if !(len(fields1593) == 0) { p.newline() - for i1593, elem1592 := range fields1591 { - if (i1593 > 0) { + for i1595, elem1594 := range fields1593 { + if (i1595 > 0) { p.newline() } - p.pretty_export_csv_column(elem1592) + p.pretty_export_csv_column(elem1594) } } p.dedent() @@ -4937,35 +4937,35 @@ func (p *PrettyPrinter) pretty_export_csv_columns_list(msg []*pb.ExportCSVColumn } func (p *PrettyPrinter) pretty_export_iceberg_config(msg *pb.ExportIcebergConfig) interface{} { - flat1603 := p.tryFlat(msg, func() { p.pretty_export_iceberg_config(msg) }) - if flat1603 != nil { - p.write(*flat1603) + flat1605 := p.tryFlat(msg, func() { p.pretty_export_iceberg_config(msg) }) + if flat1605 != nil { + p.write(*flat1605) return nil } else { _dollar_dollar := msg - _t1762 := p.deconstruct_export_iceberg_config_optional(_dollar_dollar) - fields1595 := []interface{}{_dollar_dollar.GetLocator(), _dollar_dollar.GetConfig(), _dollar_dollar.GetTableDef(), dictToPairs(_dollar_dollar.GetTableProperties()), _t1762} - unwrapped_fields1596 := fields1595 + _t1766 := p.deconstruct_export_iceberg_config_optional(_dollar_dollar) + fields1597 := []interface{}{_dollar_dollar.GetLocator(), _dollar_dollar.GetConfig(), _dollar_dollar.GetTableDef(), dictToPairs(_dollar_dollar.GetTableProperties()), _t1766} + unwrapped_fields1598 := fields1597 p.write("(") p.write("export_iceberg_config") p.indentSexp() p.newline() - field1597 := unwrapped_fields1596[0].(*pb.IcebergLocator) - p.pretty_iceberg_locator(field1597) + field1599 := unwrapped_fields1598[0].(*pb.IcebergLocator) + p.pretty_iceberg_locator(field1599) p.newline() - field1598 := unwrapped_fields1596[1].(*pb.IcebergCatalogConfig) - p.pretty_iceberg_catalog_config(field1598) + field1600 := unwrapped_fields1598[1].(*pb.IcebergCatalogConfig) + p.pretty_iceberg_catalog_config(field1600) p.newline() - field1599 := unwrapped_fields1596[2].(*pb.RelationId) - p.pretty_export_iceberg_table_def(field1599) + field1601 := unwrapped_fields1598[2].(*pb.RelationId) + p.pretty_export_iceberg_table_def(field1601) p.newline() - field1600 := unwrapped_fields1596[3].([][]interface{}) - p.pretty_iceberg_table_properties(field1600) - field1601 := unwrapped_fields1596[4].([][]interface{}) - if field1601 != nil { + field1602 := unwrapped_fields1598[3].([][]interface{}) + p.pretty_iceberg_table_properties(field1602) + field1603 := unwrapped_fields1598[4].([][]interface{}) + if field1603 != nil { p.newline() - opt_val1602 := field1601 - p.pretty_config_dict(opt_val1602) + opt_val1604 := field1603 + p.pretty_config_dict(opt_val1604) } p.dedent() p.write(")") @@ -4974,17 +4974,17 @@ func (p *PrettyPrinter) pretty_export_iceberg_config(msg *pb.ExportIcebergConfig } func (p *PrettyPrinter) pretty_export_iceberg_table_def(msg *pb.RelationId) interface{} { - flat1605 := p.tryFlat(msg, func() { p.pretty_export_iceberg_table_def(msg) }) - if flat1605 != nil { - p.write(*flat1605) + flat1607 := p.tryFlat(msg, func() { p.pretty_export_iceberg_table_def(msg) }) + if flat1607 != nil { + p.write(*flat1607) return nil } else { - fields1604 := msg + fields1606 := msg p.write("(") p.write("table_def") p.indentSexp() p.newline() - p.pretty_relation_id(fields1604) + p.pretty_relation_id(fields1606) p.dedent() p.write(")") } @@ -4992,22 +4992,22 @@ func (p *PrettyPrinter) pretty_export_iceberg_table_def(msg *pb.RelationId) inte } func (p *PrettyPrinter) pretty_iceberg_table_properties(msg [][]interface{}) interface{} { - flat1609 := p.tryFlat(msg, func() { p.pretty_iceberg_table_properties(msg) }) - if flat1609 != nil { - p.write(*flat1609) + flat1611 := p.tryFlat(msg, func() { p.pretty_iceberg_table_properties(msg) }) + if flat1611 != nil { + p.write(*flat1611) return nil } else { - fields1606 := msg + fields1608 := msg p.write("(") p.write("table_properties") p.indentSexp() - if !(len(fields1606) == 0) { + if !(len(fields1608) == 0) { p.newline() - for i1608, elem1607 := range fields1606 { - if (i1608 > 0) { + for i1610, elem1609 := range fields1608 { + if (i1610 > 0) { p.newline() } - p.pretty_iceberg_property_entry(elem1607) + p.pretty_iceberg_property_entry(elem1609) } } p.dedent() @@ -5017,23 +5017,27 @@ func (p *PrettyPrinter) pretty_iceberg_table_properties(msg [][]interface{}) int } func (p *PrettyPrinter) pretty_export_output(msg *pb.ExportOutput) interface{} { - flat1612 := p.tryFlat(msg, func() { p.pretty_export_output(msg) }) - if flat1612 != nil { - p.write(*flat1612) + flat1616 := p.tryFlat(msg, func() { p.pretty_export_output(msg) }) + if flat1616 != nil { + p.write(*flat1616) return nil } else { _dollar_dollar := msg - var _t1763 *pb.ExportCSVOutput + var _t1767 []interface{} if hasProtoField(_dollar_dollar, "csv") { - _t1763 = _dollar_dollar.GetCsv() + _t1767 = []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetCsv()} } - fields1610 := _t1763 - unwrapped_fields1611 := fields1610 + fields1612 := _t1767 + unwrapped_fields1613 := fields1612 p.write("(") p.write("export_output") p.indentSexp() p.newline() - p.pretty_export_csv_output(unwrapped_fields1611) + field1614 := unwrapped_fields1613[0].(string) + p.pretty_name(field1614) + p.newline() + field1615 := unwrapped_fields1613[1].(*pb.ExportCSVOutput) + p.pretty_export_csv_output(field1615) p.dedent() p.write(")") } @@ -5041,23 +5045,23 @@ func (p *PrettyPrinter) pretty_export_output(msg *pb.ExportOutput) interface{} { } func (p *PrettyPrinter) pretty_export_csv_output(msg *pb.ExportCSVOutput) interface{} { - flat1617 := p.tryFlat(msg, func() { p.pretty_export_csv_output(msg) }) - if flat1617 != nil { - p.write(*flat1617) + flat1621 := p.tryFlat(msg, func() { p.pretty_export_csv_output(msg) }) + if flat1621 != nil { + p.write(*flat1621) return nil } else { _dollar_dollar := msg - fields1613 := []interface{}{_dollar_dollar.GetCsvSource(), _dollar_dollar.GetCsvConfig()} - unwrapped_fields1614 := fields1613 + fields1617 := []interface{}{_dollar_dollar.GetCsvSource(), _dollar_dollar.GetCsvConfig()} + unwrapped_fields1618 := fields1617 p.write("(") p.write("csv") p.indentSexp() p.newline() - field1615 := unwrapped_fields1614[0].(*pb.ExportCSVSource) - p.pretty_export_csv_source(field1615) + field1619 := unwrapped_fields1618[0].(*pb.ExportCSVSource) + p.pretty_export_csv_source(field1619) p.newline() - field1616 := unwrapped_fields1614[1].(*pb.CSVConfig) - p.pretty_csv_config(field1616) + field1620 := unwrapped_fields1618[1].(*pb.CSVConfig) + p.pretty_csv_config(field1620) p.dedent() p.write(")") } @@ -5073,8 +5077,8 @@ func (p *PrettyPrinter) pretty_debug_info(msg *pb.DebugInfo) interface{} { for _idx, _rid := range msg.GetIds() { p.newline() p.write("(") - _t1815 := &pb.UInt128Value{Low: _rid.GetIdLow(), High: _rid.GetIdHigh()} - p.pprintDispatch(_t1815) + _t1819 := &pb.UInt128Value{Low: _rid.GetIdLow(), High: _rid.GetIdHigh()} + p.pprintDispatch(_t1819) 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 a81b4b85..02441b81 100644 --- a/sdks/julia/LogicalQueryProtocol.jl/src/equality.jl +++ b/sdks/julia/LogicalQueryProtocol.jl/src/equality.jl @@ -501,13 +501,13 @@ Base.isequal(a::ExportCSVOutput, b::ExportCSVOutput) = isequal(a.csv_source, b.c # ExportOutput function Base.:(==)(a::ExportOutput, b::ExportOutput) - _isequal_oneof(a.export_output, b.export_output) + a.name == b.name && _isequal_oneof(a.export_output, b.export_output) end function Base.hash(a::ExportOutput, h::UInt) - _hash_oneof(a.export_output, h) + _hash_oneof(a.export_output, hash(a.name, h)) end function Base.isequal(a::ExportOutput, b::ExportOutput) - _isequal_oneof(a.export_output, b.export_output) + isequal(a.name, b.name) && _isequal_oneof(a.export_output, b.export_output) end # IVMConfig 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 5a3dc774..24ad272a 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 @@ -758,41 +758,47 @@ function PB._encoded_size(x::ExportCSVConfig) end struct ExportOutput + name::String export_output::Union{Nothing,OneOf{ExportCSVOutput}} end -ExportOutput(;export_output = nothing) = ExportOutput(export_output) +ExportOutput(;name = "", export_output = nothing) = ExportOutput(name, export_output) PB.oneof_field_types(::Type{ExportOutput}) = (; export_output = (;csv=ExportCSVOutput), ) -PB.default_values(::Type{ExportOutput}) = (;csv = nothing) -PB.field_numbers(::Type{ExportOutput}) = (;csv = 1) +PB.default_values(::Type{ExportOutput}) = (;name = "", csv = nothing) +PB.field_numbers(::Type{ExportOutput}) = (;name = 1, csv = 2) function PB.decode(d::PB.AbstractProtoDecoder, ::Type{<:ExportOutput}, _endpos::Int=0, _group::Bool=false) + name = "" export_output = nothing while !PB.message_done(d, _endpos, _group) field_number, wire_type = PB.decode_tag(d) if field_number == 1 + name = PB.decode(d, String) + elseif field_number == 2 export_output = OneOf(:csv, PB.decode(d, Ref{ExportCSVOutput})) else Base.skip(d, wire_type) end end - return ExportOutput(export_output) + return ExportOutput(name, export_output) end function PB.encode(e::PB.AbstractProtoEncoder, x::ExportOutput) initpos = position(e.io) + !isempty(x.name) && PB.encode(e, 1, x.name) if isnothing(x.export_output); elseif x.export_output.name === :csv - PB.encode(e, 1, x.export_output[]::ExportCSVOutput) + PB.encode(e, 2, x.export_output[]::ExportCSVOutput) end return position(e.io) - initpos end function PB._encoded_size(x::ExportOutput) encoded_size = 0 + !isempty(x.name) && (encoded_size += PB._encoded_size(x.name, 1)) if isnothing(x.export_output); elseif x.export_output.name === :csv - encoded_size += PB._encoded_size(x.export_output[]::ExportCSVOutput, 1) + encoded_size += PB._encoded_size(x.export_output[]::ExportCSVOutput, 2) end return encoded_size end diff --git a/sdks/julia/LogicalQueryProtocol.jl/src/parser.jl b/sdks/julia/LogicalQueryProtocol.jl/src/parser.jl index a539d18c..fd3fca66 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 - _t2113 = nothing + _t2116 = 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 - _t2114 = nothing + _t2117 = 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 - _t2115 = nothing + _t2118 = 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 - _t2116 = nothing + _t2119 = 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 - _t2117 = nothing + _t2120 = 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 - _t2118 = nothing + _t2121 = 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 - _t2119 = nothing + _t2122 = 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 - _t2120 = nothing + _t2123 = nothing end return nothing end @@ -444,90 +444,90 @@ function _try_extract_value_uint128(parser::ParserState, value::Union{Nothing, P if (!isnothing(value) && _has_proto_field(value, Symbol("uint128_value"))) return _get_oneof_field(value, :uint128_value) else - _t2121 = nothing + _t2124 = nothing end return nothing end function construct_csv_config(parser::ParserState, config_dict::Vector{Tuple{String, Proto.Value}}, storage_integration_opt::Union{Nothing, Vector{Tuple{String, Proto.Value}}})::Proto.CSVConfig config = Dict(config_dict) - _t2122 = _extract_value_int32(parser, get(config, "csv_header_row", nothing), 1) - header_row = _t2122 - _t2123 = _extract_value_int64(parser, get(config, "csv_skip", nothing), 0) - skip = _t2123 - _t2124 = _extract_value_string(parser, get(config, "csv_new_line", nothing), "") - new_line = _t2124 - _t2125 = _extract_value_string(parser, get(config, "csv_delimiter", nothing), ",") - delimiter = _t2125 - _t2126 = _extract_value_string(parser, get(config, "csv_quotechar", nothing), "\"") - quotechar = _t2126 - _t2127 = _extract_value_string(parser, get(config, "csv_escapechar", nothing), "\"") - escapechar = _t2127 - _t2128 = _extract_value_string(parser, get(config, "csv_comment", nothing), "") - comment = _t2128 - _t2129 = _extract_value_string_list(parser, get(config, "csv_missing_strings", nothing), String[]) - missing_strings = _t2129 - _t2130 = _extract_value_string(parser, get(config, "csv_decimal_separator", nothing), ".") - decimal_separator = _t2130 - _t2131 = _extract_value_string(parser, get(config, "csv_encoding", nothing), "utf-8") - encoding = _t2131 - _t2132 = _extract_value_string(parser, get(config, "csv_compression", nothing), "") - compression = _t2132 - _t2133 = _extract_value_int64(parser, get(config, "csv_partition_size_mb", nothing), 0) - partition_size_mb = _t2133 - _t2134 = construct_csv_storage_integration(parser, storage_integration_opt) - storage_integration = _t2134 - _t2135 = 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 _t2135 + _t2125 = _extract_value_int32(parser, get(config, "csv_header_row", nothing), 1) + header_row = _t2125 + _t2126 = _extract_value_int64(parser, get(config, "csv_skip", nothing), 0) + skip = _t2126 + _t2127 = _extract_value_string(parser, get(config, "csv_new_line", nothing), "") + new_line = _t2127 + _t2128 = _extract_value_string(parser, get(config, "csv_delimiter", nothing), ",") + delimiter = _t2128 + _t2129 = _extract_value_string(parser, get(config, "csv_quotechar", nothing), "\"") + quotechar = _t2129 + _t2130 = _extract_value_string(parser, get(config, "csv_escapechar", nothing), "\"") + escapechar = _t2130 + _t2131 = _extract_value_string(parser, get(config, "csv_comment", nothing), "") + comment = _t2131 + _t2132 = _extract_value_string_list(parser, get(config, "csv_missing_strings", nothing), String[]) + missing_strings = _t2132 + _t2133 = _extract_value_string(parser, get(config, "csv_decimal_separator", nothing), ".") + decimal_separator = _t2133 + _t2134 = _extract_value_string(parser, get(config, "csv_encoding", nothing), "utf-8") + encoding = _t2134 + _t2135 = _extract_value_string(parser, get(config, "csv_compression", nothing), "") + compression = _t2135 + _t2136 = _extract_value_int64(parser, get(config, "csv_partition_size_mb", nothing), 0) + partition_size_mb = _t2136 + _t2137 = construct_csv_storage_integration(parser, storage_integration_opt) + storage_integration = _t2137 + _t2138 = 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 _t2138 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 - _t2136 = nothing + _t2139 = nothing end config = Dict(storage_integration_opt) - _t2137 = _extract_value_string(parser, get(config, "provider", nothing), "") - _t2138 = _extract_value_string(parser, get(config, "azure_sas_token", nothing), "") - _t2139 = _extract_value_string(parser, get(config, "s3_region", nothing), "") - _t2140 = _extract_value_string(parser, get(config, "s3_access_key_id", nothing), "") - _t2141 = _extract_value_string(parser, get(config, "s3_secret_access_key", nothing), "") - _t2142 = Proto.StorageIntegration(provider=_t2137, azure_sas_token=_t2138, s3_region=_t2139, s3_access_key_id=_t2140, s3_secret_access_key=_t2141) - return _t2142 + _t2140 = _extract_value_string(parser, get(config, "provider", nothing), "") + _t2141 = _extract_value_string(parser, get(config, "azure_sas_token", nothing), "") + _t2142 = _extract_value_string(parser, get(config, "s3_region", nothing), "") + _t2143 = _extract_value_string(parser, get(config, "s3_access_key_id", nothing), "") + _t2144 = _extract_value_string(parser, get(config, "s3_secret_access_key", nothing), "") + _t2145 = Proto.StorageIntegration(provider=_t2140, azure_sas_token=_t2141, s3_region=_t2142, s3_access_key_id=_t2143, s3_secret_access_key=_t2144) + return _t2145 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) - _t2143 = _try_extract_value_float64(parser, get(config, "betree_config_epsilon", nothing)) - epsilon = _t2143 - _t2144 = _try_extract_value_int64(parser, get(config, "betree_config_max_pivots", nothing)) - max_pivots = _t2144 - _t2145 = _try_extract_value_int64(parser, get(config, "betree_config_max_deltas", nothing)) - max_deltas = _t2145 - _t2146 = _try_extract_value_int64(parser, get(config, "betree_config_max_leaf", nothing)) - max_leaf = _t2146 - _t2147 = Proto.BeTreeConfig(epsilon=epsilon, max_pivots=max_pivots, max_deltas=max_deltas, max_leaf=max_leaf) - storage_config = _t2147 - _t2148 = _try_extract_value_uint128(parser, get(config, "betree_locator_root_pageid", nothing)) - root_pageid = _t2148 - _t2149 = _try_extract_value_bytes(parser, get(config, "betree_locator_inline_data", nothing)) - inline_data = _t2149 - _t2150 = _try_extract_value_int64(parser, get(config, "betree_locator_element_count", nothing)) - element_count = _t2150 - _t2151 = _try_extract_value_int64(parser, get(config, "betree_locator_tree_height", nothing)) - tree_height = _t2151 - _t2152 = 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 = _t2152 - _t2153 = Proto.BeTreeInfo(key_types=key_types, value_types=value_types, storage_config=storage_config, relation_locator=relation_locator) - return _t2153 + _t2146 = _try_extract_value_float64(parser, get(config, "betree_config_epsilon", nothing)) + epsilon = _t2146 + _t2147 = _try_extract_value_int64(parser, get(config, "betree_config_max_pivots", nothing)) + max_pivots = _t2147 + _t2148 = _try_extract_value_int64(parser, get(config, "betree_config_max_deltas", nothing)) + max_deltas = _t2148 + _t2149 = _try_extract_value_int64(parser, get(config, "betree_config_max_leaf", nothing)) + max_leaf = _t2149 + _t2150 = Proto.BeTreeConfig(epsilon=epsilon, max_pivots=max_pivots, max_deltas=max_deltas, max_leaf=max_leaf) + storage_config = _t2150 + _t2151 = _try_extract_value_uint128(parser, get(config, "betree_locator_root_pageid", nothing)) + root_pageid = _t2151 + _t2152 = _try_extract_value_bytes(parser, get(config, "betree_locator_inline_data", nothing)) + inline_data = _t2152 + _t2153 = _try_extract_value_int64(parser, get(config, "betree_locator_element_count", nothing)) + element_count = _t2153 + _t2154 = _try_extract_value_int64(parser, get(config, "betree_locator_tree_height", nothing)) + tree_height = _t2154 + _t2155 = 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 = _t2155 + _t2156 = Proto.BeTreeInfo(key_types=key_types, value_types=value_types, storage_config=storage_config, relation_locator=relation_locator) + return _t2156 end function default_configure(parser::ParserState)::Proto.Configure - _t2154 = Proto.IVMConfig(level=Proto.MaintenanceLevel.MAINTENANCE_LEVEL_OFF) - ivm_config = _t2154 - _t2155 = Proto.Configure(semantics_version=0, ivm_config=ivm_config) - return _t2155 + _t2157 = Proto.IVMConfig(level=Proto.MaintenanceLevel.MAINTENANCE_LEVEL_OFF) + ivm_config = _t2157 + _t2158 = Proto.Configure(semantics_version=0, ivm_config=ivm_config) + return _t2158 end function construct_configure(parser::ParserState, config_dict::Vector{Tuple{String, Proto.Value}})::Proto.Configure @@ -549,3897 +549,3899 @@ function construct_configure(parser::ParserState, config_dict::Vector{Tuple{Stri end end end - _t2156 = Proto.IVMConfig(level=maintenance_level) - ivm_config = _t2156 - _t2157 = _extract_value_int64(parser, get(config, "semantics_version", nothing), 0) - semantics_version = _t2157 - _t2158 = Proto.Configure(semantics_version=semantics_version, ivm_config=ivm_config) - return _t2158 + _t2159 = Proto.IVMConfig(level=maintenance_level) + ivm_config = _t2159 + _t2160 = _extract_value_int64(parser, get(config, "semantics_version", nothing), 0) + semantics_version = _t2160 + _t2161 = Proto.Configure(semantics_version=semantics_version, ivm_config=ivm_config) + return _t2161 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) - _t2159 = _extract_value_int64(parser, get(config, "partition_size", nothing), 0) - partition_size = _t2159 - _t2160 = _extract_value_string(parser, get(config, "compression", nothing), "") - compression = _t2160 - _t2161 = _extract_value_boolean(parser, get(config, "syntax_header_row", nothing), true) - syntax_header_row = _t2161 - _t2162 = _extract_value_string(parser, get(config, "syntax_missing_string", nothing), "") - syntax_missing_string = _t2162 - _t2163 = _extract_value_string(parser, get(config, "syntax_delim", nothing), ",") - syntax_delim = _t2163 - _t2164 = _extract_value_string(parser, get(config, "syntax_quotechar", nothing), "\"") - syntax_quotechar = _t2164 - _t2165 = _extract_value_string(parser, get(config, "syntax_escapechar", nothing), "\\") - syntax_escapechar = _t2165 - _t2166 = 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 _t2166 + _t2162 = _extract_value_int64(parser, get(config, "partition_size", nothing), 0) + partition_size = _t2162 + _t2163 = _extract_value_string(parser, get(config, "compression", nothing), "") + compression = _t2163 + _t2164 = _extract_value_boolean(parser, get(config, "syntax_header_row", nothing), true) + syntax_header_row = _t2164 + _t2165 = _extract_value_string(parser, get(config, "syntax_missing_string", nothing), "") + syntax_missing_string = _t2165 + _t2166 = _extract_value_string(parser, get(config, "syntax_delim", nothing), ",") + syntax_delim = _t2166 + _t2167 = _extract_value_string(parser, get(config, "syntax_quotechar", nothing), "\"") + syntax_quotechar = _t2167 + _t2168 = _extract_value_string(parser, get(config, "syntax_escapechar", nothing), "\\") + syntax_escapechar = _t2168 + _t2169 = 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 _t2169 end function construct_export_csv_config_with_source(parser::ParserState, path::String, csv_source::Proto.ExportCSVSource, csv_config::Proto.CSVConfig)::Proto.ExportCSVConfig - _t2167 = Proto.ExportCSVConfig(path=path, csv_source=csv_source, csv_config=csv_config) - return _t2167 + _t2170 = Proto.ExportCSVConfig(path=path, csv_source=csv_source, csv_config=csv_config) + return _t2170 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) - _t2168 = Proto.IcebergCatalogConfig(catalog_uri=catalog_uri, scope=(!isnothing(scope_opt) ? scope_opt : ""), properties=props, auth_properties=auth_props) - return _t2168 + _t2171 = Proto.IcebergCatalogConfig(catalog_uri=catalog_uri, scope=(!isnothing(scope_opt) ? scope_opt : ""), properties=props, auth_properties=auth_props) + return _t2171 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 - _t2169 = 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 _t2169 + _t2172 = 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 _t2172 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}[])) - _t2170 = _extract_value_string(parser, get(cfg, "prefix", nothing), "") - prefix = _t2170 - _t2171 = _extract_value_int64(parser, get(cfg, "target_file_size_bytes", nothing), 0) - target_file_size_bytes = _t2171 - _t2172 = _extract_value_string(parser, get(cfg, "compression", nothing), "") - compression = _t2172 + _t2173 = _extract_value_string(parser, get(cfg, "prefix", nothing), "") + prefix = _t2173 + _t2174 = _extract_value_int64(parser, get(cfg, "target_file_size_bytes", nothing), 0) + target_file_size_bytes = _t2174 + _t2175 = _extract_value_string(parser, get(cfg, "compression", nothing), "") + compression = _t2175 table_props = Dict(table_property_pairs) - _t2173 = 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 _t2173 + _t2176 = 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 _t2176 end # --- Parse functions --- function parse_transaction(parser::ParserState)::Proto.Transaction - span_start681 = span_start(parser) + span_start682 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "transaction") if (match_lookahead_literal(parser, "(", 0) && match_lookahead_literal(parser, "configure", 1)) - _t1351 = parse_configure(parser) - _t1350 = _t1351 + _t1353 = parse_configure(parser) + _t1352 = _t1353 else - _t1350 = nothing + _t1352 = nothing end - configure675 = _t1350 + configure676 = _t1352 if (match_lookahead_literal(parser, "(", 0) && match_lookahead_literal(parser, "sync", 1)) - _t1353 = parse_sync(parser) - _t1352 = _t1353 + _t1355 = parse_sync(parser) + _t1354 = _t1355 else - _t1352 = nothing + _t1354 = nothing end - sync676 = _t1352 - xs677 = Proto.Epoch[] - cond678 = match_lookahead_literal(parser, "(", 0) - while cond678 - _t1354 = parse_epoch(parser) - item679 = _t1354 - push!(xs677, item679) - cond678 = match_lookahead_literal(parser, "(", 0) + sync677 = _t1354 + xs678 = Proto.Epoch[] + cond679 = match_lookahead_literal(parser, "(", 0) + while cond679 + _t1356 = parse_epoch(parser) + item680 = _t1356 + push!(xs678, item680) + cond679 = match_lookahead_literal(parser, "(", 0) end - epochs680 = xs677 + epochs681 = xs678 consume_literal!(parser, ")") - _t1355 = default_configure(parser) - _t1356 = Proto.Transaction(epochs=epochs680, configure=(!isnothing(configure675) ? configure675 : _t1355), sync=sync676) - result682 = _t1356 - record_span!(parser, span_start681, "Transaction") - return result682 + _t1357 = default_configure(parser) + _t1358 = Proto.Transaction(epochs=epochs681, configure=(!isnothing(configure676) ? configure676 : _t1357), sync=sync677) + result683 = _t1358 + record_span!(parser, span_start682, "Transaction") + return result683 end function parse_configure(parser::ParserState)::Proto.Configure - span_start684 = span_start(parser) + span_start685 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "configure") - _t1357 = parse_config_dict(parser) - config_dict683 = _t1357 + _t1359 = parse_config_dict(parser) + config_dict684 = _t1359 consume_literal!(parser, ")") - _t1358 = construct_configure(parser, config_dict683) - result685 = _t1358 - record_span!(parser, span_start684, "Configure") - return result685 + _t1360 = construct_configure(parser, config_dict684) + result686 = _t1360 + record_span!(parser, span_start685, "Configure") + return result686 end function parse_config_dict(parser::ParserState)::Vector{Tuple{String, Proto.Value}} consume_literal!(parser, "{") - xs686 = Tuple{String, Proto.Value}[] - cond687 = match_lookahead_literal(parser, ":", 0) - while cond687 - _t1359 = parse_config_key_value(parser) - item688 = _t1359 - push!(xs686, item688) - cond687 = match_lookahead_literal(parser, ":", 0) + xs687 = Tuple{String, Proto.Value}[] + cond688 = match_lookahead_literal(parser, ":", 0) + while cond688 + _t1361 = parse_config_key_value(parser) + item689 = _t1361 + push!(xs687, item689) + cond688 = match_lookahead_literal(parser, ":", 0) end - config_key_values689 = xs686 + config_key_values690 = xs687 consume_literal!(parser, "}") - return config_key_values689 + return config_key_values690 end function parse_config_key_value(parser::ParserState)::Tuple{String, Proto.Value} consume_literal!(parser, ":") - symbol690 = consume_terminal!(parser, "SYMBOL") - _t1360 = parse_raw_value(parser) - raw_value691 = _t1360 - return (symbol690, raw_value691,) + symbol691 = consume_terminal!(parser, "SYMBOL") + _t1362 = parse_raw_value(parser) + raw_value692 = _t1362 + return (symbol691, raw_value692,) end function parse_raw_value(parser::ParserState)::Proto.Value - span_start705 = span_start(parser) + span_start706 = span_start(parser) if match_lookahead_literal(parser, "true", 0) - _t1361 = 12 + _t1363 = 12 else if match_lookahead_literal(parser, "missing", 0) - _t1362 = 11 + _t1364 = 11 else if match_lookahead_literal(parser, "false", 0) - _t1363 = 12 + _t1365 = 12 else if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "datetime", 1) - _t1365 = 1 + _t1367 = 1 else if match_lookahead_literal(parser, "date", 1) - _t1366 = 0 + _t1368 = 0 else - _t1366 = -1 + _t1368 = -1 end - _t1365 = _t1366 + _t1367 = _t1368 end - _t1364 = _t1365 + _t1366 = _t1367 else if match_lookahead_terminal(parser, "UINT32", 0) - _t1367 = 7 + _t1369 = 7 else if match_lookahead_terminal(parser, "UINT128", 0) - _t1368 = 8 + _t1370 = 8 else if match_lookahead_terminal(parser, "STRING", 0) - _t1369 = 2 + _t1371 = 2 else if match_lookahead_terminal(parser, "INT32", 0) - _t1370 = 3 + _t1372 = 3 else if match_lookahead_terminal(parser, "INT128", 0) - _t1371 = 9 + _t1373 = 9 else if match_lookahead_terminal(parser, "INT", 0) - _t1372 = 4 + _t1374 = 4 else if match_lookahead_terminal(parser, "FLOAT32", 0) - _t1373 = 5 + _t1375 = 5 else if match_lookahead_terminal(parser, "FLOAT", 0) - _t1374 = 6 + _t1376 = 6 else if match_lookahead_terminal(parser, "DECIMAL", 0) - _t1375 = 10 + _t1377 = 10 else - _t1375 = -1 + _t1377 = -1 end - _t1374 = _t1375 + _t1376 = _t1377 end - _t1373 = _t1374 + _t1375 = _t1376 end - _t1372 = _t1373 + _t1374 = _t1375 end - _t1371 = _t1372 + _t1373 = _t1374 end - _t1370 = _t1371 + _t1372 = _t1373 end - _t1369 = _t1370 + _t1371 = _t1372 end - _t1368 = _t1369 + _t1370 = _t1371 end - _t1367 = _t1368 + _t1369 = _t1370 end - _t1364 = _t1367 + _t1366 = _t1369 end - _t1363 = _t1364 + _t1365 = _t1366 end - _t1362 = _t1363 + _t1364 = _t1365 end - _t1361 = _t1362 + _t1363 = _t1364 end - prediction692 = _t1361 - if prediction692 == 12 - _t1377 = parse_boolean_value(parser) - boolean_value704 = _t1377 - _t1378 = Proto.Value(value=OneOf(:boolean_value, boolean_value704)) - _t1376 = _t1378 + prediction693 = _t1363 + if prediction693 == 12 + _t1379 = parse_boolean_value(parser) + boolean_value705 = _t1379 + _t1380 = Proto.Value(value=OneOf(:boolean_value, boolean_value705)) + _t1378 = _t1380 else - if prediction692 == 11 + if prediction693 == 11 consume_literal!(parser, "missing") - _t1380 = Proto.MissingValue() - _t1381 = Proto.Value(value=OneOf(:missing_value, _t1380)) - _t1379 = _t1381 + _t1382 = Proto.MissingValue() + _t1383 = Proto.Value(value=OneOf(:missing_value, _t1382)) + _t1381 = _t1383 else - if prediction692 == 10 - decimal703 = consume_terminal!(parser, "DECIMAL") - _t1383 = Proto.Value(value=OneOf(:decimal_value, decimal703)) - _t1382 = _t1383 + if prediction693 == 10 + decimal704 = consume_terminal!(parser, "DECIMAL") + _t1385 = Proto.Value(value=OneOf(:decimal_value, decimal704)) + _t1384 = _t1385 else - if prediction692 == 9 - int128702 = consume_terminal!(parser, "INT128") - _t1385 = Proto.Value(value=OneOf(:int128_value, int128702)) - _t1384 = _t1385 + if prediction693 == 9 + int128703 = consume_terminal!(parser, "INT128") + _t1387 = Proto.Value(value=OneOf(:int128_value, int128703)) + _t1386 = _t1387 else - if prediction692 == 8 - uint128701 = consume_terminal!(parser, "UINT128") - _t1387 = Proto.Value(value=OneOf(:uint128_value, uint128701)) - _t1386 = _t1387 + if prediction693 == 8 + uint128702 = consume_terminal!(parser, "UINT128") + _t1389 = Proto.Value(value=OneOf(:uint128_value, uint128702)) + _t1388 = _t1389 else - if prediction692 == 7 - uint32700 = consume_terminal!(parser, "UINT32") - _t1389 = Proto.Value(value=OneOf(:uint32_value, uint32700)) - _t1388 = _t1389 + if prediction693 == 7 + uint32701 = consume_terminal!(parser, "UINT32") + _t1391 = Proto.Value(value=OneOf(:uint32_value, uint32701)) + _t1390 = _t1391 else - if prediction692 == 6 - float699 = consume_terminal!(parser, "FLOAT") - _t1391 = Proto.Value(value=OneOf(:float_value, float699)) - _t1390 = _t1391 + if prediction693 == 6 + float700 = consume_terminal!(parser, "FLOAT") + _t1393 = Proto.Value(value=OneOf(:float_value, float700)) + _t1392 = _t1393 else - if prediction692 == 5 - float32698 = consume_terminal!(parser, "FLOAT32") - _t1393 = Proto.Value(value=OneOf(:float32_value, float32698)) - _t1392 = _t1393 + if prediction693 == 5 + float32699 = consume_terminal!(parser, "FLOAT32") + _t1395 = Proto.Value(value=OneOf(:float32_value, float32699)) + _t1394 = _t1395 else - if prediction692 == 4 - int697 = consume_terminal!(parser, "INT") - _t1395 = Proto.Value(value=OneOf(:int_value, int697)) - _t1394 = _t1395 + if prediction693 == 4 + int698 = consume_terminal!(parser, "INT") + _t1397 = Proto.Value(value=OneOf(:int_value, int698)) + _t1396 = _t1397 else - if prediction692 == 3 - int32696 = consume_terminal!(parser, "INT32") - _t1397 = Proto.Value(value=OneOf(:int32_value, int32696)) - _t1396 = _t1397 + if prediction693 == 3 + int32697 = consume_terminal!(parser, "INT32") + _t1399 = Proto.Value(value=OneOf(:int32_value, int32697)) + _t1398 = _t1399 else - if prediction692 == 2 - string695 = consume_terminal!(parser, "STRING") - _t1399 = Proto.Value(value=OneOf(:string_value, string695)) - _t1398 = _t1399 + if prediction693 == 2 + string696 = consume_terminal!(parser, "STRING") + _t1401 = Proto.Value(value=OneOf(:string_value, string696)) + _t1400 = _t1401 else - if prediction692 == 1 - _t1401 = parse_raw_datetime(parser) - raw_datetime694 = _t1401 - _t1402 = Proto.Value(value=OneOf(:datetime_value, raw_datetime694)) - _t1400 = _t1402 + if prediction693 == 1 + _t1403 = parse_raw_datetime(parser) + raw_datetime695 = _t1403 + _t1404 = Proto.Value(value=OneOf(:datetime_value, raw_datetime695)) + _t1402 = _t1404 else - if prediction692 == 0 - _t1404 = parse_raw_date(parser) - raw_date693 = _t1404 - _t1405 = Proto.Value(value=OneOf(:date_value, raw_date693)) - _t1403 = _t1405 + if prediction693 == 0 + _t1406 = parse_raw_date(parser) + raw_date694 = _t1406 + _t1407 = Proto.Value(value=OneOf(:date_value, raw_date694)) + _t1405 = _t1407 else throw(ParseError("Unexpected token in raw_value" * ": " * string(lookahead(parser, 0)))) end - _t1400 = _t1403 + _t1402 = _t1405 end - _t1398 = _t1400 + _t1400 = _t1402 end - _t1396 = _t1398 + _t1398 = _t1400 end - _t1394 = _t1396 + _t1396 = _t1398 end - _t1392 = _t1394 + _t1394 = _t1396 end - _t1390 = _t1392 + _t1392 = _t1394 end - _t1388 = _t1390 + _t1390 = _t1392 end - _t1386 = _t1388 + _t1388 = _t1390 end - _t1384 = _t1386 + _t1386 = _t1388 end - _t1382 = _t1384 + _t1384 = _t1386 end - _t1379 = _t1382 + _t1381 = _t1384 end - _t1376 = _t1379 + _t1378 = _t1381 end - result706 = _t1376 - record_span!(parser, span_start705, "Value") - return result706 + result707 = _t1378 + record_span!(parser, span_start706, "Value") + return result707 end function parse_raw_date(parser::ParserState)::Proto.DateValue - span_start710 = span_start(parser) + span_start711 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "date") - int707 = consume_terminal!(parser, "INT") - int_3708 = consume_terminal!(parser, "INT") - int_4709 = consume_terminal!(parser, "INT") + int708 = consume_terminal!(parser, "INT") + int_3709 = consume_terminal!(parser, "INT") + int_4710 = consume_terminal!(parser, "INT") consume_literal!(parser, ")") - _t1406 = Proto.DateValue(year=Int32(int707), month=Int32(int_3708), day=Int32(int_4709)) - result711 = _t1406 - record_span!(parser, span_start710, "DateValue") - return result711 + _t1408 = Proto.DateValue(year=Int32(int708), month=Int32(int_3709), day=Int32(int_4710)) + result712 = _t1408 + record_span!(parser, span_start711, "DateValue") + return result712 end function parse_raw_datetime(parser::ParserState)::Proto.DateTimeValue - span_start719 = span_start(parser) + span_start720 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "datetime") - int712 = consume_terminal!(parser, "INT") - int_3713 = consume_terminal!(parser, "INT") - int_4714 = consume_terminal!(parser, "INT") - int_5715 = consume_terminal!(parser, "INT") - int_6716 = consume_terminal!(parser, "INT") - int_7717 = consume_terminal!(parser, "INT") + int713 = consume_terminal!(parser, "INT") + int_3714 = consume_terminal!(parser, "INT") + int_4715 = consume_terminal!(parser, "INT") + int_5716 = consume_terminal!(parser, "INT") + int_6717 = consume_terminal!(parser, "INT") + int_7718 = consume_terminal!(parser, "INT") if match_lookahead_terminal(parser, "INT", 0) - _t1407 = consume_terminal!(parser, "INT") + _t1409 = consume_terminal!(parser, "INT") else - _t1407 = nothing + _t1409 = nothing end - int_8718 = _t1407 + int_8719 = _t1409 consume_literal!(parser, ")") - _t1408 = Proto.DateTimeValue(year=Int32(int712), month=Int32(int_3713), day=Int32(int_4714), hour=Int32(int_5715), minute=Int32(int_6716), second=Int32(int_7717), microsecond=Int32((!isnothing(int_8718) ? int_8718 : 0))) - result720 = _t1408 - record_span!(parser, span_start719, "DateTimeValue") - return result720 + _t1410 = Proto.DateTimeValue(year=Int32(int713), month=Int32(int_3714), day=Int32(int_4715), hour=Int32(int_5716), minute=Int32(int_6717), second=Int32(int_7718), microsecond=Int32((!isnothing(int_8719) ? int_8719 : 0))) + result721 = _t1410 + record_span!(parser, span_start720, "DateTimeValue") + return result721 end function parse_boolean_value(parser::ParserState)::Bool if match_lookahead_literal(parser, "true", 0) - _t1409 = 0 + _t1411 = 0 else if match_lookahead_literal(parser, "false", 0) - _t1410 = 1 + _t1412 = 1 else - _t1410 = -1 + _t1412 = -1 end - _t1409 = _t1410 + _t1411 = _t1412 end - prediction721 = _t1409 - if prediction721 == 1 + prediction722 = _t1411 + if prediction722 == 1 consume_literal!(parser, "false") - _t1411 = false + _t1413 = false else - if prediction721 == 0 + if prediction722 == 0 consume_literal!(parser, "true") - _t1412 = true + _t1414 = true else throw(ParseError("Unexpected token in boolean_value" * ": " * string(lookahead(parser, 0)))) end - _t1411 = _t1412 + _t1413 = _t1414 end - return _t1411 + return _t1413 end function parse_sync(parser::ParserState)::Proto.Sync - span_start726 = span_start(parser) + span_start727 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "sync") - xs722 = Proto.FragmentId[] - cond723 = match_lookahead_literal(parser, ":", 0) - while cond723 - _t1413 = parse_fragment_id(parser) - item724 = _t1413 - push!(xs722, item724) - cond723 = match_lookahead_literal(parser, ":", 0) + xs723 = Proto.FragmentId[] + cond724 = match_lookahead_literal(parser, ":", 0) + while cond724 + _t1415 = parse_fragment_id(parser) + item725 = _t1415 + push!(xs723, item725) + cond724 = match_lookahead_literal(parser, ":", 0) end - fragment_ids725 = xs722 + fragment_ids726 = xs723 consume_literal!(parser, ")") - _t1414 = Proto.Sync(fragments=fragment_ids725) - result727 = _t1414 - record_span!(parser, span_start726, "Sync") - return result727 + _t1416 = Proto.Sync(fragments=fragment_ids726) + result728 = _t1416 + record_span!(parser, span_start727, "Sync") + return result728 end function parse_fragment_id(parser::ParserState)::Proto.FragmentId - span_start729 = span_start(parser) + span_start730 = span_start(parser) consume_literal!(parser, ":") - symbol728 = consume_terminal!(parser, "SYMBOL") - result730 = Proto.FragmentId(Vector{UInt8}(symbol728)) - record_span!(parser, span_start729, "FragmentId") - return result730 + symbol729 = consume_terminal!(parser, "SYMBOL") + result731 = Proto.FragmentId(Vector{UInt8}(symbol729)) + record_span!(parser, span_start730, "FragmentId") + return result731 end function parse_epoch(parser::ParserState)::Proto.Epoch - span_start733 = span_start(parser) + span_start734 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "epoch") if (match_lookahead_literal(parser, "(", 0) && match_lookahead_literal(parser, "writes", 1)) - _t1416 = parse_epoch_writes(parser) - _t1415 = _t1416 + _t1418 = parse_epoch_writes(parser) + _t1417 = _t1418 else - _t1415 = nothing + _t1417 = nothing end - epoch_writes731 = _t1415 + epoch_writes732 = _t1417 if match_lookahead_literal(parser, "(", 0) - _t1418 = parse_epoch_reads(parser) - _t1417 = _t1418 + _t1420 = parse_epoch_reads(parser) + _t1419 = _t1420 else - _t1417 = nothing + _t1419 = nothing end - epoch_reads732 = _t1417 + epoch_reads733 = _t1419 consume_literal!(parser, ")") - _t1419 = Proto.Epoch(writes=(!isnothing(epoch_writes731) ? epoch_writes731 : Proto.Write[]), reads=(!isnothing(epoch_reads732) ? epoch_reads732 : Proto.Read[])) - result734 = _t1419 - record_span!(parser, span_start733, "Epoch") - return result734 + _t1421 = Proto.Epoch(writes=(!isnothing(epoch_writes732) ? epoch_writes732 : Proto.Write[]), reads=(!isnothing(epoch_reads733) ? epoch_reads733 : Proto.Read[])) + result735 = _t1421 + record_span!(parser, span_start734, "Epoch") + return result735 end function parse_epoch_writes(parser::ParserState)::Vector{Proto.Write} consume_literal!(parser, "(") consume_literal!(parser, "writes") - xs735 = Proto.Write[] - cond736 = match_lookahead_literal(parser, "(", 0) - while cond736 - _t1420 = parse_write(parser) - item737 = _t1420 - push!(xs735, item737) - cond736 = match_lookahead_literal(parser, "(", 0) + xs736 = Proto.Write[] + cond737 = match_lookahead_literal(parser, "(", 0) + while cond737 + _t1422 = parse_write(parser) + item738 = _t1422 + push!(xs736, item738) + cond737 = match_lookahead_literal(parser, "(", 0) end - writes738 = xs735 + writes739 = xs736 consume_literal!(parser, ")") - return writes738 + return writes739 end function parse_write(parser::ParserState)::Proto.Write - span_start744 = span_start(parser) + span_start745 = span_start(parser) if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "undefine", 1) - _t1422 = 1 + _t1424 = 1 else if match_lookahead_literal(parser, "snapshot", 1) - _t1423 = 3 + _t1425 = 3 else if match_lookahead_literal(parser, "define", 1) - _t1424 = 0 + _t1426 = 0 else if match_lookahead_literal(parser, "context", 1) - _t1425 = 2 + _t1427 = 2 else - _t1425 = -1 + _t1427 = -1 end - _t1424 = _t1425 + _t1426 = _t1427 end - _t1423 = _t1424 + _t1425 = _t1426 end - _t1422 = _t1423 + _t1424 = _t1425 end - _t1421 = _t1422 + _t1423 = _t1424 else - _t1421 = -1 + _t1423 = -1 end - prediction739 = _t1421 - if prediction739 == 3 - _t1427 = parse_snapshot(parser) - snapshot743 = _t1427 - _t1428 = Proto.Write(write_type=OneOf(:snapshot, snapshot743)) - _t1426 = _t1428 + prediction740 = _t1423 + if prediction740 == 3 + _t1429 = parse_snapshot(parser) + snapshot744 = _t1429 + _t1430 = Proto.Write(write_type=OneOf(:snapshot, snapshot744)) + _t1428 = _t1430 else - if prediction739 == 2 - _t1430 = parse_context(parser) - context742 = _t1430 - _t1431 = Proto.Write(write_type=OneOf(:context, context742)) - _t1429 = _t1431 + if prediction740 == 2 + _t1432 = parse_context(parser) + context743 = _t1432 + _t1433 = Proto.Write(write_type=OneOf(:context, context743)) + _t1431 = _t1433 else - if prediction739 == 1 - _t1433 = parse_undefine(parser) - undefine741 = _t1433 - _t1434 = Proto.Write(write_type=OneOf(:undefine, undefine741)) - _t1432 = _t1434 + if prediction740 == 1 + _t1435 = parse_undefine(parser) + undefine742 = _t1435 + _t1436 = Proto.Write(write_type=OneOf(:undefine, undefine742)) + _t1434 = _t1436 else - if prediction739 == 0 - _t1436 = parse_define(parser) - define740 = _t1436 - _t1437 = Proto.Write(write_type=OneOf(:define, define740)) - _t1435 = _t1437 + if prediction740 == 0 + _t1438 = parse_define(parser) + define741 = _t1438 + _t1439 = Proto.Write(write_type=OneOf(:define, define741)) + _t1437 = _t1439 else throw(ParseError("Unexpected token in write" * ": " * string(lookahead(parser, 0)))) end - _t1432 = _t1435 + _t1434 = _t1437 end - _t1429 = _t1432 + _t1431 = _t1434 end - _t1426 = _t1429 + _t1428 = _t1431 end - result745 = _t1426 - record_span!(parser, span_start744, "Write") - return result745 + result746 = _t1428 + record_span!(parser, span_start745, "Write") + return result746 end function parse_define(parser::ParserState)::Proto.Define - span_start747 = span_start(parser) + span_start748 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "define") - _t1438 = parse_fragment(parser) - fragment746 = _t1438 + _t1440 = parse_fragment(parser) + fragment747 = _t1440 consume_literal!(parser, ")") - _t1439 = Proto.Define(fragment=fragment746) - result748 = _t1439 - record_span!(parser, span_start747, "Define") - return result748 + _t1441 = Proto.Define(fragment=fragment747) + result749 = _t1441 + record_span!(parser, span_start748, "Define") + return result749 end function parse_fragment(parser::ParserState)::Proto.Fragment - span_start754 = span_start(parser) + span_start755 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "fragment") - _t1440 = parse_new_fragment_id(parser) - new_fragment_id749 = _t1440 - xs750 = Proto.Declaration[] - cond751 = match_lookahead_literal(parser, "(", 0) - while cond751 - _t1441 = parse_declaration(parser) - item752 = _t1441 - push!(xs750, item752) - cond751 = match_lookahead_literal(parser, "(", 0) + _t1442 = parse_new_fragment_id(parser) + new_fragment_id750 = _t1442 + xs751 = Proto.Declaration[] + cond752 = match_lookahead_literal(parser, "(", 0) + while cond752 + _t1443 = parse_declaration(parser) + item753 = _t1443 + push!(xs751, item753) + cond752 = match_lookahead_literal(parser, "(", 0) end - declarations753 = xs750 + declarations754 = xs751 consume_literal!(parser, ")") - result755 = construct_fragment(parser, new_fragment_id749, declarations753) - record_span!(parser, span_start754, "Fragment") - return result755 + result756 = construct_fragment(parser, new_fragment_id750, declarations754) + record_span!(parser, span_start755, "Fragment") + return result756 end function parse_new_fragment_id(parser::ParserState)::Proto.FragmentId - span_start757 = span_start(parser) - _t1442 = parse_fragment_id(parser) - fragment_id756 = _t1442 - start_fragment!(parser, fragment_id756) - result758 = fragment_id756 - record_span!(parser, span_start757, "FragmentId") - return result758 + span_start758 = span_start(parser) + _t1444 = parse_fragment_id(parser) + fragment_id757 = _t1444 + start_fragment!(parser, fragment_id757) + result759 = fragment_id757 + record_span!(parser, span_start758, "FragmentId") + return result759 end function parse_declaration(parser::ParserState)::Proto.Declaration - span_start764 = span_start(parser) + span_start765 = span_start(parser) if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "iceberg_data", 1) - _t1444 = 3 + _t1446 = 3 else if match_lookahead_literal(parser, "functional_dependency", 1) - _t1445 = 2 + _t1447 = 2 else if match_lookahead_literal(parser, "edb", 1) - _t1446 = 3 + _t1448 = 3 else if match_lookahead_literal(parser, "def", 1) - _t1447 = 0 + _t1449 = 0 else if match_lookahead_literal(parser, "csv_data", 1) - _t1448 = 3 + _t1450 = 3 else if match_lookahead_literal(parser, "betree_relation", 1) - _t1449 = 3 + _t1451 = 3 else if match_lookahead_literal(parser, "algorithm", 1) - _t1450 = 1 + _t1452 = 1 else - _t1450 = -1 + _t1452 = -1 end - _t1449 = _t1450 + _t1451 = _t1452 end - _t1448 = _t1449 + _t1450 = _t1451 end - _t1447 = _t1448 + _t1449 = _t1450 end - _t1446 = _t1447 + _t1448 = _t1449 end - _t1445 = _t1446 + _t1447 = _t1448 end - _t1444 = _t1445 + _t1446 = _t1447 end - _t1443 = _t1444 + _t1445 = _t1446 else - _t1443 = -1 + _t1445 = -1 end - prediction759 = _t1443 - if prediction759 == 3 - _t1452 = parse_data(parser) - data763 = _t1452 - _t1453 = Proto.Declaration(declaration_type=OneOf(:data, data763)) - _t1451 = _t1453 + prediction760 = _t1445 + if prediction760 == 3 + _t1454 = parse_data(parser) + data764 = _t1454 + _t1455 = Proto.Declaration(declaration_type=OneOf(:data, data764)) + _t1453 = _t1455 else - if prediction759 == 2 - _t1455 = parse_constraint(parser) - constraint762 = _t1455 - _t1456 = Proto.Declaration(declaration_type=OneOf(:constraint, constraint762)) - _t1454 = _t1456 + if prediction760 == 2 + _t1457 = parse_constraint(parser) + constraint763 = _t1457 + _t1458 = Proto.Declaration(declaration_type=OneOf(:constraint, constraint763)) + _t1456 = _t1458 else - if prediction759 == 1 - _t1458 = parse_algorithm(parser) - algorithm761 = _t1458 - _t1459 = Proto.Declaration(declaration_type=OneOf(:algorithm, algorithm761)) - _t1457 = _t1459 + if prediction760 == 1 + _t1460 = parse_algorithm(parser) + algorithm762 = _t1460 + _t1461 = Proto.Declaration(declaration_type=OneOf(:algorithm, algorithm762)) + _t1459 = _t1461 else - if prediction759 == 0 - _t1461 = parse_def(parser) - def760 = _t1461 - _t1462 = Proto.Declaration(declaration_type=OneOf(:def, def760)) - _t1460 = _t1462 + if prediction760 == 0 + _t1463 = parse_def(parser) + def761 = _t1463 + _t1464 = Proto.Declaration(declaration_type=OneOf(:def, def761)) + _t1462 = _t1464 else throw(ParseError("Unexpected token in declaration" * ": " * string(lookahead(parser, 0)))) end - _t1457 = _t1460 + _t1459 = _t1462 end - _t1454 = _t1457 + _t1456 = _t1459 end - _t1451 = _t1454 + _t1453 = _t1456 end - result765 = _t1451 - record_span!(parser, span_start764, "Declaration") - return result765 + result766 = _t1453 + record_span!(parser, span_start765, "Declaration") + return result766 end function parse_def(parser::ParserState)::Proto.Def - span_start769 = span_start(parser) + span_start770 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "def") - _t1463 = parse_relation_id(parser) - relation_id766 = _t1463 - _t1464 = parse_abstraction(parser) - abstraction767 = _t1464 + _t1465 = parse_relation_id(parser) + relation_id767 = _t1465 + _t1466 = parse_abstraction(parser) + abstraction768 = _t1466 if match_lookahead_literal(parser, "(", 0) - _t1466 = parse_attrs(parser) - _t1465 = _t1466 + _t1468 = parse_attrs(parser) + _t1467 = _t1468 else - _t1465 = nothing + _t1467 = nothing end - attrs768 = _t1465 + attrs769 = _t1467 consume_literal!(parser, ")") - _t1467 = Proto.Def(name=relation_id766, body=abstraction767, attrs=(!isnothing(attrs768) ? attrs768 : Proto.Attribute[])) - result770 = _t1467 - record_span!(parser, span_start769, "Def") - return result770 + _t1469 = Proto.Def(name=relation_id767, body=abstraction768, attrs=(!isnothing(attrs769) ? attrs769 : Proto.Attribute[])) + result771 = _t1469 + record_span!(parser, span_start770, "Def") + return result771 end function parse_relation_id(parser::ParserState)::Proto.RelationId - span_start774 = span_start(parser) + span_start775 = span_start(parser) if match_lookahead_literal(parser, ":", 0) - _t1468 = 0 + _t1470 = 0 else if match_lookahead_terminal(parser, "UINT128", 0) - _t1469 = 1 + _t1471 = 1 else - _t1469 = -1 + _t1471 = -1 end - _t1468 = _t1469 + _t1470 = _t1471 end - prediction771 = _t1468 - if prediction771 == 1 - uint128773 = consume_terminal!(parser, "UINT128") - _t1470 = Proto.RelationId(uint128773.low, uint128773.high) + prediction772 = _t1470 + if prediction772 == 1 + uint128774 = consume_terminal!(parser, "UINT128") + _t1472 = Proto.RelationId(uint128774.low, uint128774.high) else - if prediction771 == 0 + if prediction772 == 0 consume_literal!(parser, ":") - symbol772 = consume_terminal!(parser, "SYMBOL") - _t1471 = relation_id_from_string(parser, symbol772) + symbol773 = consume_terminal!(parser, "SYMBOL") + _t1473 = relation_id_from_string(parser, symbol773) else throw(ParseError("Unexpected token in relation_id" * ": " * string(lookahead(parser, 0)))) end - _t1470 = _t1471 + _t1472 = _t1473 end - result775 = _t1470 - record_span!(parser, span_start774, "RelationId") - return result775 + result776 = _t1472 + record_span!(parser, span_start775, "RelationId") + return result776 end function parse_abstraction(parser::ParserState)::Proto.Abstraction - span_start778 = span_start(parser) + span_start779 = span_start(parser) consume_literal!(parser, "(") - _t1472 = parse_bindings(parser) - bindings776 = _t1472 - _t1473 = parse_formula(parser) - formula777 = _t1473 + _t1474 = parse_bindings(parser) + bindings777 = _t1474 + _t1475 = parse_formula(parser) + formula778 = _t1475 consume_literal!(parser, ")") - _t1474 = Proto.Abstraction(vars=vcat(bindings776[1], !isnothing(bindings776[2]) ? bindings776[2] : []), value=formula777) - result779 = _t1474 - record_span!(parser, span_start778, "Abstraction") - return result779 + _t1476 = Proto.Abstraction(vars=vcat(bindings777[1], !isnothing(bindings777[2]) ? bindings777[2] : []), value=formula778) + result780 = _t1476 + record_span!(parser, span_start779, "Abstraction") + return result780 end function parse_bindings(parser::ParserState)::Tuple{Vector{Proto.Binding}, Vector{Proto.Binding}} consume_literal!(parser, "[") - xs780 = Proto.Binding[] - cond781 = match_lookahead_terminal(parser, "SYMBOL", 0) - while cond781 - _t1475 = parse_binding(parser) - item782 = _t1475 - push!(xs780, item782) - cond781 = match_lookahead_terminal(parser, "SYMBOL", 0) + xs781 = Proto.Binding[] + cond782 = match_lookahead_terminal(parser, "SYMBOL", 0) + while cond782 + _t1477 = parse_binding(parser) + item783 = _t1477 + push!(xs781, item783) + cond782 = match_lookahead_terminal(parser, "SYMBOL", 0) end - bindings783 = xs780 + bindings784 = xs781 if match_lookahead_literal(parser, "|", 0) - _t1477 = parse_value_bindings(parser) - _t1476 = _t1477 + _t1479 = parse_value_bindings(parser) + _t1478 = _t1479 else - _t1476 = nothing + _t1478 = nothing end - value_bindings784 = _t1476 + value_bindings785 = _t1478 consume_literal!(parser, "]") - return (bindings783, (!isnothing(value_bindings784) ? value_bindings784 : Proto.Binding[]),) + return (bindings784, (!isnothing(value_bindings785) ? value_bindings785 : Proto.Binding[]),) end function parse_binding(parser::ParserState)::Proto.Binding - span_start787 = span_start(parser) - symbol785 = consume_terminal!(parser, "SYMBOL") + span_start788 = span_start(parser) + symbol786 = consume_terminal!(parser, "SYMBOL") consume_literal!(parser, "::") - _t1478 = parse_type(parser) - type786 = _t1478 - _t1479 = Proto.Var(name=symbol785) - _t1480 = Proto.Binding(var=_t1479, var"#type"=type786) - result788 = _t1480 - record_span!(parser, span_start787, "Binding") - return result788 + _t1480 = parse_type(parser) + type787 = _t1480 + _t1481 = Proto.Var(name=symbol786) + _t1482 = Proto.Binding(var=_t1481, var"#type"=type787) + result789 = _t1482 + record_span!(parser, span_start788, "Binding") + return result789 end function parse_type(parser::ParserState)::Proto.var"#Type" - span_start804 = span_start(parser) + span_start805 = span_start(parser) if match_lookahead_literal(parser, "UNKNOWN", 0) - _t1481 = 0 + _t1483 = 0 else if match_lookahead_literal(parser, "UINT32", 0) - _t1482 = 13 + _t1484 = 13 else if match_lookahead_literal(parser, "UINT128", 0) - _t1483 = 4 + _t1485 = 4 else if match_lookahead_literal(parser, "STRING", 0) - _t1484 = 1 + _t1486 = 1 else if match_lookahead_literal(parser, "MISSING", 0) - _t1485 = 8 + _t1487 = 8 else if match_lookahead_literal(parser, "INT32", 0) - _t1486 = 11 + _t1488 = 11 else if match_lookahead_literal(parser, "INT128", 0) - _t1487 = 5 + _t1489 = 5 else if match_lookahead_literal(parser, "INT", 0) - _t1488 = 2 + _t1490 = 2 else if match_lookahead_literal(parser, "FLOAT32", 0) - _t1489 = 12 + _t1491 = 12 else if match_lookahead_literal(parser, "FLOAT", 0) - _t1490 = 3 + _t1492 = 3 else if match_lookahead_literal(parser, "DATETIME", 0) - _t1491 = 7 + _t1493 = 7 else if match_lookahead_literal(parser, "DATE", 0) - _t1492 = 6 + _t1494 = 6 else if match_lookahead_literal(parser, "BOOLEAN", 0) - _t1493 = 10 + _t1495 = 10 else if match_lookahead_literal(parser, "(", 0) - _t1494 = 9 + _t1496 = 9 else - _t1494 = -1 + _t1496 = -1 end - _t1493 = _t1494 + _t1495 = _t1496 end - _t1492 = _t1493 + _t1494 = _t1495 end - _t1491 = _t1492 + _t1493 = _t1494 end - _t1490 = _t1491 + _t1492 = _t1493 end - _t1489 = _t1490 + _t1491 = _t1492 end - _t1488 = _t1489 + _t1490 = _t1491 end - _t1487 = _t1488 + _t1489 = _t1490 end - _t1486 = _t1487 + _t1488 = _t1489 end - _t1485 = _t1486 + _t1487 = _t1488 end - _t1484 = _t1485 + _t1486 = _t1487 end - _t1483 = _t1484 + _t1485 = _t1486 end - _t1482 = _t1483 + _t1484 = _t1485 end - _t1481 = _t1482 + _t1483 = _t1484 end - prediction789 = _t1481 - if prediction789 == 13 - _t1496 = parse_uint32_type(parser) - uint32_type803 = _t1496 - _t1497 = Proto.var"#Type"(var"#type"=OneOf(:uint32_type, uint32_type803)) - _t1495 = _t1497 + prediction790 = _t1483 + if prediction790 == 13 + _t1498 = parse_uint32_type(parser) + uint32_type804 = _t1498 + _t1499 = Proto.var"#Type"(var"#type"=OneOf(:uint32_type, uint32_type804)) + _t1497 = _t1499 else - if prediction789 == 12 - _t1499 = parse_float32_type(parser) - float32_type802 = _t1499 - _t1500 = Proto.var"#Type"(var"#type"=OneOf(:float32_type, float32_type802)) - _t1498 = _t1500 + if prediction790 == 12 + _t1501 = parse_float32_type(parser) + float32_type803 = _t1501 + _t1502 = Proto.var"#Type"(var"#type"=OneOf(:float32_type, float32_type803)) + _t1500 = _t1502 else - if prediction789 == 11 - _t1502 = parse_int32_type(parser) - int32_type801 = _t1502 - _t1503 = Proto.var"#Type"(var"#type"=OneOf(:int32_type, int32_type801)) - _t1501 = _t1503 + if prediction790 == 11 + _t1504 = parse_int32_type(parser) + int32_type802 = _t1504 + _t1505 = Proto.var"#Type"(var"#type"=OneOf(:int32_type, int32_type802)) + _t1503 = _t1505 else - if prediction789 == 10 - _t1505 = parse_boolean_type(parser) - boolean_type800 = _t1505 - _t1506 = Proto.var"#Type"(var"#type"=OneOf(:boolean_type, boolean_type800)) - _t1504 = _t1506 + if prediction790 == 10 + _t1507 = parse_boolean_type(parser) + boolean_type801 = _t1507 + _t1508 = Proto.var"#Type"(var"#type"=OneOf(:boolean_type, boolean_type801)) + _t1506 = _t1508 else - if prediction789 == 9 - _t1508 = parse_decimal_type(parser) - decimal_type799 = _t1508 - _t1509 = Proto.var"#Type"(var"#type"=OneOf(:decimal_type, decimal_type799)) - _t1507 = _t1509 + if prediction790 == 9 + _t1510 = parse_decimal_type(parser) + decimal_type800 = _t1510 + _t1511 = Proto.var"#Type"(var"#type"=OneOf(:decimal_type, decimal_type800)) + _t1509 = _t1511 else - if prediction789 == 8 - _t1511 = parse_missing_type(parser) - missing_type798 = _t1511 - _t1512 = Proto.var"#Type"(var"#type"=OneOf(:missing_type, missing_type798)) - _t1510 = _t1512 + if prediction790 == 8 + _t1513 = parse_missing_type(parser) + missing_type799 = _t1513 + _t1514 = Proto.var"#Type"(var"#type"=OneOf(:missing_type, missing_type799)) + _t1512 = _t1514 else - if prediction789 == 7 - _t1514 = parse_datetime_type(parser) - datetime_type797 = _t1514 - _t1515 = Proto.var"#Type"(var"#type"=OneOf(:datetime_type, datetime_type797)) - _t1513 = _t1515 + if prediction790 == 7 + _t1516 = parse_datetime_type(parser) + datetime_type798 = _t1516 + _t1517 = Proto.var"#Type"(var"#type"=OneOf(:datetime_type, datetime_type798)) + _t1515 = _t1517 else - if prediction789 == 6 - _t1517 = parse_date_type(parser) - date_type796 = _t1517 - _t1518 = Proto.var"#Type"(var"#type"=OneOf(:date_type, date_type796)) - _t1516 = _t1518 + if prediction790 == 6 + _t1519 = parse_date_type(parser) + date_type797 = _t1519 + _t1520 = Proto.var"#Type"(var"#type"=OneOf(:date_type, date_type797)) + _t1518 = _t1520 else - if prediction789 == 5 - _t1520 = parse_int128_type(parser) - int128_type795 = _t1520 - _t1521 = Proto.var"#Type"(var"#type"=OneOf(:int128_type, int128_type795)) - _t1519 = _t1521 + if prediction790 == 5 + _t1522 = parse_int128_type(parser) + int128_type796 = _t1522 + _t1523 = Proto.var"#Type"(var"#type"=OneOf(:int128_type, int128_type796)) + _t1521 = _t1523 else - if prediction789 == 4 - _t1523 = parse_uint128_type(parser) - uint128_type794 = _t1523 - _t1524 = Proto.var"#Type"(var"#type"=OneOf(:uint128_type, uint128_type794)) - _t1522 = _t1524 + if prediction790 == 4 + _t1525 = parse_uint128_type(parser) + uint128_type795 = _t1525 + _t1526 = Proto.var"#Type"(var"#type"=OneOf(:uint128_type, uint128_type795)) + _t1524 = _t1526 else - if prediction789 == 3 - _t1526 = parse_float_type(parser) - float_type793 = _t1526 - _t1527 = Proto.var"#Type"(var"#type"=OneOf(:float_type, float_type793)) - _t1525 = _t1527 + if prediction790 == 3 + _t1528 = parse_float_type(parser) + float_type794 = _t1528 + _t1529 = Proto.var"#Type"(var"#type"=OneOf(:float_type, float_type794)) + _t1527 = _t1529 else - if prediction789 == 2 - _t1529 = parse_int_type(parser) - int_type792 = _t1529 - _t1530 = Proto.var"#Type"(var"#type"=OneOf(:int_type, int_type792)) - _t1528 = _t1530 + if prediction790 == 2 + _t1531 = parse_int_type(parser) + int_type793 = _t1531 + _t1532 = Proto.var"#Type"(var"#type"=OneOf(:int_type, int_type793)) + _t1530 = _t1532 else - if prediction789 == 1 - _t1532 = parse_string_type(parser) - string_type791 = _t1532 - _t1533 = Proto.var"#Type"(var"#type"=OneOf(:string_type, string_type791)) - _t1531 = _t1533 + if prediction790 == 1 + _t1534 = parse_string_type(parser) + string_type792 = _t1534 + _t1535 = Proto.var"#Type"(var"#type"=OneOf(:string_type, string_type792)) + _t1533 = _t1535 else - if prediction789 == 0 - _t1535 = parse_unspecified_type(parser) - unspecified_type790 = _t1535 - _t1536 = Proto.var"#Type"(var"#type"=OneOf(:unspecified_type, unspecified_type790)) - _t1534 = _t1536 + if prediction790 == 0 + _t1537 = parse_unspecified_type(parser) + unspecified_type791 = _t1537 + _t1538 = Proto.var"#Type"(var"#type"=OneOf(:unspecified_type, unspecified_type791)) + _t1536 = _t1538 else throw(ParseError("Unexpected token in type" * ": " * string(lookahead(parser, 0)))) end - _t1531 = _t1534 + _t1533 = _t1536 end - _t1528 = _t1531 + _t1530 = _t1533 end - _t1525 = _t1528 + _t1527 = _t1530 end - _t1522 = _t1525 + _t1524 = _t1527 end - _t1519 = _t1522 + _t1521 = _t1524 end - _t1516 = _t1519 + _t1518 = _t1521 end - _t1513 = _t1516 + _t1515 = _t1518 end - _t1510 = _t1513 + _t1512 = _t1515 end - _t1507 = _t1510 + _t1509 = _t1512 end - _t1504 = _t1507 + _t1506 = _t1509 end - _t1501 = _t1504 + _t1503 = _t1506 end - _t1498 = _t1501 + _t1500 = _t1503 end - _t1495 = _t1498 + _t1497 = _t1500 end - result805 = _t1495 - record_span!(parser, span_start804, "Type") - return result805 + result806 = _t1497 + record_span!(parser, span_start805, "Type") + return result806 end function parse_unspecified_type(parser::ParserState)::Proto.UnspecifiedType - span_start806 = span_start(parser) + span_start807 = span_start(parser) consume_literal!(parser, "UNKNOWN") - _t1537 = Proto.UnspecifiedType() - result807 = _t1537 - record_span!(parser, span_start806, "UnspecifiedType") - return result807 + _t1539 = Proto.UnspecifiedType() + result808 = _t1539 + record_span!(parser, span_start807, "UnspecifiedType") + return result808 end function parse_string_type(parser::ParserState)::Proto.StringType - span_start808 = span_start(parser) + span_start809 = span_start(parser) consume_literal!(parser, "STRING") - _t1538 = Proto.StringType() - result809 = _t1538 - record_span!(parser, span_start808, "StringType") - return result809 + _t1540 = Proto.StringType() + result810 = _t1540 + record_span!(parser, span_start809, "StringType") + return result810 end function parse_int_type(parser::ParserState)::Proto.IntType - span_start810 = span_start(parser) + span_start811 = span_start(parser) consume_literal!(parser, "INT") - _t1539 = Proto.IntType() - result811 = _t1539 - record_span!(parser, span_start810, "IntType") - return result811 + _t1541 = Proto.IntType() + result812 = _t1541 + record_span!(parser, span_start811, "IntType") + return result812 end function parse_float_type(parser::ParserState)::Proto.FloatType - span_start812 = span_start(parser) + span_start813 = span_start(parser) consume_literal!(parser, "FLOAT") - _t1540 = Proto.FloatType() - result813 = _t1540 - record_span!(parser, span_start812, "FloatType") - return result813 + _t1542 = Proto.FloatType() + result814 = _t1542 + record_span!(parser, span_start813, "FloatType") + return result814 end function parse_uint128_type(parser::ParserState)::Proto.UInt128Type - span_start814 = span_start(parser) + span_start815 = span_start(parser) consume_literal!(parser, "UINT128") - _t1541 = Proto.UInt128Type() - result815 = _t1541 - record_span!(parser, span_start814, "UInt128Type") - return result815 + _t1543 = Proto.UInt128Type() + result816 = _t1543 + record_span!(parser, span_start815, "UInt128Type") + return result816 end function parse_int128_type(parser::ParserState)::Proto.Int128Type - span_start816 = span_start(parser) + span_start817 = span_start(parser) consume_literal!(parser, "INT128") - _t1542 = Proto.Int128Type() - result817 = _t1542 - record_span!(parser, span_start816, "Int128Type") - return result817 + _t1544 = Proto.Int128Type() + result818 = _t1544 + record_span!(parser, span_start817, "Int128Type") + return result818 end function parse_date_type(parser::ParserState)::Proto.DateType - span_start818 = span_start(parser) + span_start819 = span_start(parser) consume_literal!(parser, "DATE") - _t1543 = Proto.DateType() - result819 = _t1543 - record_span!(parser, span_start818, "DateType") - return result819 + _t1545 = Proto.DateType() + result820 = _t1545 + record_span!(parser, span_start819, "DateType") + return result820 end function parse_datetime_type(parser::ParserState)::Proto.DateTimeType - span_start820 = span_start(parser) + span_start821 = span_start(parser) consume_literal!(parser, "DATETIME") - _t1544 = Proto.DateTimeType() - result821 = _t1544 - record_span!(parser, span_start820, "DateTimeType") - return result821 + _t1546 = Proto.DateTimeType() + result822 = _t1546 + record_span!(parser, span_start821, "DateTimeType") + return result822 end function parse_missing_type(parser::ParserState)::Proto.MissingType - span_start822 = span_start(parser) + span_start823 = span_start(parser) consume_literal!(parser, "MISSING") - _t1545 = Proto.MissingType() - result823 = _t1545 - record_span!(parser, span_start822, "MissingType") - return result823 + _t1547 = Proto.MissingType() + result824 = _t1547 + record_span!(parser, span_start823, "MissingType") + return result824 end function parse_decimal_type(parser::ParserState)::Proto.DecimalType - span_start826 = span_start(parser) + span_start827 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "DECIMAL") - int824 = consume_terminal!(parser, "INT") - int_3825 = consume_terminal!(parser, "INT") + int825 = consume_terminal!(parser, "INT") + int_3826 = consume_terminal!(parser, "INT") consume_literal!(parser, ")") - _t1546 = Proto.DecimalType(precision=Int32(int824), scale=Int32(int_3825)) - result827 = _t1546 - record_span!(parser, span_start826, "DecimalType") - return result827 + _t1548 = Proto.DecimalType(precision=Int32(int825), scale=Int32(int_3826)) + result828 = _t1548 + record_span!(parser, span_start827, "DecimalType") + return result828 end function parse_boolean_type(parser::ParserState)::Proto.BooleanType - span_start828 = span_start(parser) + span_start829 = span_start(parser) consume_literal!(parser, "BOOLEAN") - _t1547 = Proto.BooleanType() - result829 = _t1547 - record_span!(parser, span_start828, "BooleanType") - return result829 + _t1549 = Proto.BooleanType() + result830 = _t1549 + record_span!(parser, span_start829, "BooleanType") + return result830 end function parse_int32_type(parser::ParserState)::Proto.Int32Type - span_start830 = span_start(parser) + span_start831 = span_start(parser) consume_literal!(parser, "INT32") - _t1548 = Proto.Int32Type() - result831 = _t1548 - record_span!(parser, span_start830, "Int32Type") - return result831 + _t1550 = Proto.Int32Type() + result832 = _t1550 + record_span!(parser, span_start831, "Int32Type") + return result832 end function parse_float32_type(parser::ParserState)::Proto.Float32Type - span_start832 = span_start(parser) + span_start833 = span_start(parser) consume_literal!(parser, "FLOAT32") - _t1549 = Proto.Float32Type() - result833 = _t1549 - record_span!(parser, span_start832, "Float32Type") - return result833 + _t1551 = Proto.Float32Type() + result834 = _t1551 + record_span!(parser, span_start833, "Float32Type") + return result834 end function parse_uint32_type(parser::ParserState)::Proto.UInt32Type - span_start834 = span_start(parser) + span_start835 = span_start(parser) consume_literal!(parser, "UINT32") - _t1550 = Proto.UInt32Type() - result835 = _t1550 - record_span!(parser, span_start834, "UInt32Type") - return result835 + _t1552 = Proto.UInt32Type() + result836 = _t1552 + record_span!(parser, span_start835, "UInt32Type") + return result836 end function parse_value_bindings(parser::ParserState)::Vector{Proto.Binding} consume_literal!(parser, "|") - xs836 = Proto.Binding[] - cond837 = match_lookahead_terminal(parser, "SYMBOL", 0) - while cond837 - _t1551 = parse_binding(parser) - item838 = _t1551 - push!(xs836, item838) - cond837 = match_lookahead_terminal(parser, "SYMBOL", 0) + xs837 = Proto.Binding[] + cond838 = match_lookahead_terminal(parser, "SYMBOL", 0) + while cond838 + _t1553 = parse_binding(parser) + item839 = _t1553 + push!(xs837, item839) + cond838 = match_lookahead_terminal(parser, "SYMBOL", 0) end - bindings839 = xs836 - return bindings839 + bindings840 = xs837 + return bindings840 end function parse_formula(parser::ParserState)::Proto.Formula - span_start854 = span_start(parser) + span_start855 = span_start(parser) if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "true", 1) - _t1553 = 0 + _t1555 = 0 else if match_lookahead_literal(parser, "relatom", 1) - _t1554 = 11 + _t1556 = 11 else if match_lookahead_literal(parser, "reduce", 1) - _t1555 = 3 + _t1557 = 3 else if match_lookahead_literal(parser, "primitive", 1) - _t1556 = 10 + _t1558 = 10 else if match_lookahead_literal(parser, "pragma", 1) - _t1557 = 9 + _t1559 = 9 else if match_lookahead_literal(parser, "or", 1) - _t1558 = 5 + _t1560 = 5 else if match_lookahead_literal(parser, "not", 1) - _t1559 = 6 + _t1561 = 6 else if match_lookahead_literal(parser, "ffi", 1) - _t1560 = 7 + _t1562 = 7 else if match_lookahead_literal(parser, "false", 1) - _t1561 = 1 + _t1563 = 1 else if match_lookahead_literal(parser, "exists", 1) - _t1562 = 2 + _t1564 = 2 else if match_lookahead_literal(parser, "cast", 1) - _t1563 = 12 + _t1565 = 12 else if match_lookahead_literal(parser, "atom", 1) - _t1564 = 8 + _t1566 = 8 else if match_lookahead_literal(parser, "and", 1) - _t1565 = 4 + _t1567 = 4 else if match_lookahead_literal(parser, ">=", 1) - _t1566 = 10 + _t1568 = 10 else if match_lookahead_literal(parser, ">", 1) - _t1567 = 10 + _t1569 = 10 else if match_lookahead_literal(parser, "=", 1) - _t1568 = 10 + _t1570 = 10 else if match_lookahead_literal(parser, "<=", 1) - _t1569 = 10 + _t1571 = 10 else if match_lookahead_literal(parser, "<", 1) - _t1570 = 10 + _t1572 = 10 else if match_lookahead_literal(parser, "/", 1) - _t1571 = 10 + _t1573 = 10 else if match_lookahead_literal(parser, "-", 1) - _t1572 = 10 + _t1574 = 10 else if match_lookahead_literal(parser, "+", 1) - _t1573 = 10 + _t1575 = 10 else if match_lookahead_literal(parser, "*", 1) - _t1574 = 10 + _t1576 = 10 else - _t1574 = -1 + _t1576 = -1 end - _t1573 = _t1574 + _t1575 = _t1576 end - _t1572 = _t1573 + _t1574 = _t1575 end - _t1571 = _t1572 + _t1573 = _t1574 end - _t1570 = _t1571 + _t1572 = _t1573 end - _t1569 = _t1570 + _t1571 = _t1572 end - _t1568 = _t1569 + _t1570 = _t1571 end - _t1567 = _t1568 + _t1569 = _t1570 end - _t1566 = _t1567 + _t1568 = _t1569 end - _t1565 = _t1566 + _t1567 = _t1568 end - _t1564 = _t1565 + _t1566 = _t1567 end - _t1563 = _t1564 + _t1565 = _t1566 end - _t1562 = _t1563 + _t1564 = _t1565 end - _t1561 = _t1562 + _t1563 = _t1564 end - _t1560 = _t1561 + _t1562 = _t1563 end - _t1559 = _t1560 + _t1561 = _t1562 end - _t1558 = _t1559 + _t1560 = _t1561 end - _t1557 = _t1558 + _t1559 = _t1560 end - _t1556 = _t1557 + _t1558 = _t1559 end - _t1555 = _t1556 + _t1557 = _t1558 end - _t1554 = _t1555 + _t1556 = _t1557 end - _t1553 = _t1554 + _t1555 = _t1556 end - _t1552 = _t1553 + _t1554 = _t1555 else - _t1552 = -1 + _t1554 = -1 end - prediction840 = _t1552 - if prediction840 == 12 - _t1576 = parse_cast(parser) - cast853 = _t1576 - _t1577 = Proto.Formula(formula_type=OneOf(:cast, cast853)) - _t1575 = _t1577 + prediction841 = _t1554 + if prediction841 == 12 + _t1578 = parse_cast(parser) + cast854 = _t1578 + _t1579 = Proto.Formula(formula_type=OneOf(:cast, cast854)) + _t1577 = _t1579 else - if prediction840 == 11 - _t1579 = parse_rel_atom(parser) - rel_atom852 = _t1579 - _t1580 = Proto.Formula(formula_type=OneOf(:rel_atom, rel_atom852)) - _t1578 = _t1580 + if prediction841 == 11 + _t1581 = parse_rel_atom(parser) + rel_atom853 = _t1581 + _t1582 = Proto.Formula(formula_type=OneOf(:rel_atom, rel_atom853)) + _t1580 = _t1582 else - if prediction840 == 10 - _t1582 = parse_primitive(parser) - primitive851 = _t1582 - _t1583 = Proto.Formula(formula_type=OneOf(:primitive, primitive851)) - _t1581 = _t1583 + if prediction841 == 10 + _t1584 = parse_primitive(parser) + primitive852 = _t1584 + _t1585 = Proto.Formula(formula_type=OneOf(:primitive, primitive852)) + _t1583 = _t1585 else - if prediction840 == 9 - _t1585 = parse_pragma(parser) - pragma850 = _t1585 - _t1586 = Proto.Formula(formula_type=OneOf(:pragma, pragma850)) - _t1584 = _t1586 + if prediction841 == 9 + _t1587 = parse_pragma(parser) + pragma851 = _t1587 + _t1588 = Proto.Formula(formula_type=OneOf(:pragma, pragma851)) + _t1586 = _t1588 else - if prediction840 == 8 - _t1588 = parse_atom(parser) - atom849 = _t1588 - _t1589 = Proto.Formula(formula_type=OneOf(:atom, atom849)) - _t1587 = _t1589 + if prediction841 == 8 + _t1590 = parse_atom(parser) + atom850 = _t1590 + _t1591 = Proto.Formula(formula_type=OneOf(:atom, atom850)) + _t1589 = _t1591 else - if prediction840 == 7 - _t1591 = parse_ffi(parser) - ffi848 = _t1591 - _t1592 = Proto.Formula(formula_type=OneOf(:ffi, ffi848)) - _t1590 = _t1592 + if prediction841 == 7 + _t1593 = parse_ffi(parser) + ffi849 = _t1593 + _t1594 = Proto.Formula(formula_type=OneOf(:ffi, ffi849)) + _t1592 = _t1594 else - if prediction840 == 6 - _t1594 = parse_not(parser) - not847 = _t1594 - _t1595 = Proto.Formula(formula_type=OneOf(:not, not847)) - _t1593 = _t1595 + if prediction841 == 6 + _t1596 = parse_not(parser) + not848 = _t1596 + _t1597 = Proto.Formula(formula_type=OneOf(:not, not848)) + _t1595 = _t1597 else - if prediction840 == 5 - _t1597 = parse_disjunction(parser) - disjunction846 = _t1597 - _t1598 = Proto.Formula(formula_type=OneOf(:disjunction, disjunction846)) - _t1596 = _t1598 + if prediction841 == 5 + _t1599 = parse_disjunction(parser) + disjunction847 = _t1599 + _t1600 = Proto.Formula(formula_type=OneOf(:disjunction, disjunction847)) + _t1598 = _t1600 else - if prediction840 == 4 - _t1600 = parse_conjunction(parser) - conjunction845 = _t1600 - _t1601 = Proto.Formula(formula_type=OneOf(:conjunction, conjunction845)) - _t1599 = _t1601 + if prediction841 == 4 + _t1602 = parse_conjunction(parser) + conjunction846 = _t1602 + _t1603 = Proto.Formula(formula_type=OneOf(:conjunction, conjunction846)) + _t1601 = _t1603 else - if prediction840 == 3 - _t1603 = parse_reduce(parser) - reduce844 = _t1603 - _t1604 = Proto.Formula(formula_type=OneOf(:reduce, reduce844)) - _t1602 = _t1604 + if prediction841 == 3 + _t1605 = parse_reduce(parser) + reduce845 = _t1605 + _t1606 = Proto.Formula(formula_type=OneOf(:reduce, reduce845)) + _t1604 = _t1606 else - if prediction840 == 2 - _t1606 = parse_exists(parser) - exists843 = _t1606 - _t1607 = Proto.Formula(formula_type=OneOf(:exists, exists843)) - _t1605 = _t1607 + if prediction841 == 2 + _t1608 = parse_exists(parser) + exists844 = _t1608 + _t1609 = Proto.Formula(formula_type=OneOf(:exists, exists844)) + _t1607 = _t1609 else - if prediction840 == 1 - _t1609 = parse_false(parser) - false842 = _t1609 - _t1610 = Proto.Formula(formula_type=OneOf(:disjunction, false842)) - _t1608 = _t1610 + if prediction841 == 1 + _t1611 = parse_false(parser) + false843 = _t1611 + _t1612 = Proto.Formula(formula_type=OneOf(:disjunction, false843)) + _t1610 = _t1612 else - if prediction840 == 0 - _t1612 = parse_true(parser) - true841 = _t1612 - _t1613 = Proto.Formula(formula_type=OneOf(:conjunction, true841)) - _t1611 = _t1613 + if prediction841 == 0 + _t1614 = parse_true(parser) + true842 = _t1614 + _t1615 = Proto.Formula(formula_type=OneOf(:conjunction, true842)) + _t1613 = _t1615 else throw(ParseError("Unexpected token in formula" * ": " * string(lookahead(parser, 0)))) end - _t1608 = _t1611 + _t1610 = _t1613 end - _t1605 = _t1608 + _t1607 = _t1610 end - _t1602 = _t1605 + _t1604 = _t1607 end - _t1599 = _t1602 + _t1601 = _t1604 end - _t1596 = _t1599 + _t1598 = _t1601 end - _t1593 = _t1596 + _t1595 = _t1598 end - _t1590 = _t1593 + _t1592 = _t1595 end - _t1587 = _t1590 + _t1589 = _t1592 end - _t1584 = _t1587 + _t1586 = _t1589 end - _t1581 = _t1584 + _t1583 = _t1586 end - _t1578 = _t1581 + _t1580 = _t1583 end - _t1575 = _t1578 + _t1577 = _t1580 end - result855 = _t1575 - record_span!(parser, span_start854, "Formula") - return result855 + result856 = _t1577 + record_span!(parser, span_start855, "Formula") + return result856 end function parse_true(parser::ParserState)::Proto.Conjunction - span_start856 = span_start(parser) + span_start857 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "true") consume_literal!(parser, ")") - _t1614 = Proto.Conjunction(args=Proto.Formula[]) - result857 = _t1614 - record_span!(parser, span_start856, "Conjunction") - return result857 + _t1616 = Proto.Conjunction(args=Proto.Formula[]) + result858 = _t1616 + record_span!(parser, span_start857, "Conjunction") + return result858 end function parse_false(parser::ParserState)::Proto.Disjunction - span_start858 = span_start(parser) + span_start859 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "false") consume_literal!(parser, ")") - _t1615 = Proto.Disjunction(args=Proto.Formula[]) - result859 = _t1615 - record_span!(parser, span_start858, "Disjunction") - return result859 + _t1617 = Proto.Disjunction(args=Proto.Formula[]) + result860 = _t1617 + record_span!(parser, span_start859, "Disjunction") + return result860 end function parse_exists(parser::ParserState)::Proto.Exists - span_start862 = span_start(parser) + span_start863 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "exists") - _t1616 = parse_bindings(parser) - bindings860 = _t1616 - _t1617 = parse_formula(parser) - formula861 = _t1617 + _t1618 = parse_bindings(parser) + bindings861 = _t1618 + _t1619 = parse_formula(parser) + formula862 = _t1619 consume_literal!(parser, ")") - _t1618 = Proto.Abstraction(vars=vcat(bindings860[1], !isnothing(bindings860[2]) ? bindings860[2] : []), value=formula861) - _t1619 = Proto.Exists(body=_t1618) - result863 = _t1619 - record_span!(parser, span_start862, "Exists") - return result863 + _t1620 = Proto.Abstraction(vars=vcat(bindings861[1], !isnothing(bindings861[2]) ? bindings861[2] : []), value=formula862) + _t1621 = Proto.Exists(body=_t1620) + result864 = _t1621 + record_span!(parser, span_start863, "Exists") + return result864 end function parse_reduce(parser::ParserState)::Proto.Reduce - span_start867 = span_start(parser) + span_start868 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "reduce") - _t1620 = parse_abstraction(parser) - abstraction864 = _t1620 - _t1621 = parse_abstraction(parser) - abstraction_3865 = _t1621 - _t1622 = parse_terms(parser) - terms866 = _t1622 + _t1622 = parse_abstraction(parser) + abstraction865 = _t1622 + _t1623 = parse_abstraction(parser) + abstraction_3866 = _t1623 + _t1624 = parse_terms(parser) + terms867 = _t1624 consume_literal!(parser, ")") - _t1623 = Proto.Reduce(op=abstraction864, body=abstraction_3865, terms=terms866) - result868 = _t1623 - record_span!(parser, span_start867, "Reduce") - return result868 + _t1625 = Proto.Reduce(op=abstraction865, body=abstraction_3866, terms=terms867) + result869 = _t1625 + record_span!(parser, span_start868, "Reduce") + return result869 end function parse_terms(parser::ParserState)::Vector{Proto.Term} consume_literal!(parser, "(") consume_literal!(parser, "terms") - xs869 = Proto.Term[] - cond870 = (((((((((((((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 cond870 - _t1624 = parse_term(parser) - item871 = _t1624 - push!(xs869, item871) - cond870 = (((((((((((((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)) + xs870 = Proto.Term[] + cond871 = (((((((((((((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 cond871 + _t1626 = parse_term(parser) + item872 = _t1626 + push!(xs870, item872) + cond871 = (((((((((((((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 - terms872 = xs869 + terms873 = xs870 consume_literal!(parser, ")") - return terms872 + return terms873 end function parse_term(parser::ParserState)::Proto.Term - span_start876 = span_start(parser) + span_start877 = span_start(parser) if match_lookahead_literal(parser, "true", 0) - _t1625 = 1 + _t1627 = 1 else if match_lookahead_literal(parser, "missing", 0) - _t1626 = 1 + _t1628 = 1 else if match_lookahead_literal(parser, "false", 0) - _t1627 = 1 + _t1629 = 1 else if match_lookahead_literal(parser, "(", 0) - _t1628 = 1 + _t1630 = 1 else if match_lookahead_terminal(parser, "SYMBOL", 0) - _t1629 = 0 + _t1631 = 0 else if match_lookahead_terminal(parser, "UINT32", 0) - _t1630 = 1 + _t1632 = 1 else if match_lookahead_terminal(parser, "UINT128", 0) - _t1631 = 1 + _t1633 = 1 else if match_lookahead_terminal(parser, "STRING", 0) - _t1632 = 1 + _t1634 = 1 else if match_lookahead_terminal(parser, "INT32", 0) - _t1633 = 1 + _t1635 = 1 else if match_lookahead_terminal(parser, "INT128", 0) - _t1634 = 1 + _t1636 = 1 else if match_lookahead_terminal(parser, "INT", 0) - _t1635 = 1 + _t1637 = 1 else if match_lookahead_terminal(parser, "FLOAT32", 0) - _t1636 = 1 + _t1638 = 1 else if match_lookahead_terminal(parser, "FLOAT", 0) - _t1637 = 1 + _t1639 = 1 else if match_lookahead_terminal(parser, "DECIMAL", 0) - _t1638 = 1 + _t1640 = 1 else - _t1638 = -1 + _t1640 = -1 end - _t1637 = _t1638 + _t1639 = _t1640 end - _t1636 = _t1637 + _t1638 = _t1639 end - _t1635 = _t1636 + _t1637 = _t1638 end - _t1634 = _t1635 + _t1636 = _t1637 end - _t1633 = _t1634 + _t1635 = _t1636 end - _t1632 = _t1633 + _t1634 = _t1635 end - _t1631 = _t1632 + _t1633 = _t1634 end - _t1630 = _t1631 + _t1632 = _t1633 end - _t1629 = _t1630 + _t1631 = _t1632 end - _t1628 = _t1629 + _t1630 = _t1631 end - _t1627 = _t1628 + _t1629 = _t1630 end - _t1626 = _t1627 + _t1628 = _t1629 end - _t1625 = _t1626 + _t1627 = _t1628 end - prediction873 = _t1625 - if prediction873 == 1 - _t1640 = parse_value(parser) - value875 = _t1640 - _t1641 = Proto.Term(term_type=OneOf(:constant, value875)) - _t1639 = _t1641 + prediction874 = _t1627 + if prediction874 == 1 + _t1642 = parse_value(parser) + value876 = _t1642 + _t1643 = Proto.Term(term_type=OneOf(:constant, value876)) + _t1641 = _t1643 else - if prediction873 == 0 - _t1643 = parse_var(parser) - var874 = _t1643 - _t1644 = Proto.Term(term_type=OneOf(:var, var874)) - _t1642 = _t1644 + if prediction874 == 0 + _t1645 = parse_var(parser) + var875 = _t1645 + _t1646 = Proto.Term(term_type=OneOf(:var, var875)) + _t1644 = _t1646 else throw(ParseError("Unexpected token in term" * ": " * string(lookahead(parser, 0)))) end - _t1639 = _t1642 + _t1641 = _t1644 end - result877 = _t1639 - record_span!(parser, span_start876, "Term") - return result877 + result878 = _t1641 + record_span!(parser, span_start877, "Term") + return result878 end function parse_var(parser::ParserState)::Proto.Var - span_start879 = span_start(parser) - symbol878 = consume_terminal!(parser, "SYMBOL") - _t1645 = Proto.Var(name=symbol878) - result880 = _t1645 - record_span!(parser, span_start879, "Var") - return result880 + span_start880 = span_start(parser) + symbol879 = consume_terminal!(parser, "SYMBOL") + _t1647 = Proto.Var(name=symbol879) + result881 = _t1647 + record_span!(parser, span_start880, "Var") + return result881 end function parse_value(parser::ParserState)::Proto.Value - span_start894 = span_start(parser) + span_start895 = span_start(parser) if match_lookahead_literal(parser, "true", 0) - _t1646 = 12 + _t1648 = 12 else if match_lookahead_literal(parser, "missing", 0) - _t1647 = 11 + _t1649 = 11 else if match_lookahead_literal(parser, "false", 0) - _t1648 = 12 + _t1650 = 12 else if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "datetime", 1) - _t1650 = 1 + _t1652 = 1 else if match_lookahead_literal(parser, "date", 1) - _t1651 = 0 + _t1653 = 0 else - _t1651 = -1 + _t1653 = -1 end - _t1650 = _t1651 + _t1652 = _t1653 end - _t1649 = _t1650 + _t1651 = _t1652 else if match_lookahead_terminal(parser, "UINT32", 0) - _t1652 = 7 + _t1654 = 7 else if match_lookahead_terminal(parser, "UINT128", 0) - _t1653 = 8 + _t1655 = 8 else if match_lookahead_terminal(parser, "STRING", 0) - _t1654 = 2 + _t1656 = 2 else if match_lookahead_terminal(parser, "INT32", 0) - _t1655 = 3 + _t1657 = 3 else if match_lookahead_terminal(parser, "INT128", 0) - _t1656 = 9 + _t1658 = 9 else if match_lookahead_terminal(parser, "INT", 0) - _t1657 = 4 + _t1659 = 4 else if match_lookahead_terminal(parser, "FLOAT32", 0) - _t1658 = 5 + _t1660 = 5 else if match_lookahead_terminal(parser, "FLOAT", 0) - _t1659 = 6 + _t1661 = 6 else if match_lookahead_terminal(parser, "DECIMAL", 0) - _t1660 = 10 + _t1662 = 10 else - _t1660 = -1 + _t1662 = -1 end - _t1659 = _t1660 + _t1661 = _t1662 end - _t1658 = _t1659 + _t1660 = _t1661 end - _t1657 = _t1658 + _t1659 = _t1660 end - _t1656 = _t1657 + _t1658 = _t1659 end - _t1655 = _t1656 + _t1657 = _t1658 end - _t1654 = _t1655 + _t1656 = _t1657 end - _t1653 = _t1654 + _t1655 = _t1656 end - _t1652 = _t1653 + _t1654 = _t1655 end - _t1649 = _t1652 + _t1651 = _t1654 end - _t1648 = _t1649 + _t1650 = _t1651 end - _t1647 = _t1648 + _t1649 = _t1650 end - _t1646 = _t1647 + _t1648 = _t1649 end - prediction881 = _t1646 - if prediction881 == 12 - _t1662 = parse_boolean_value(parser) - boolean_value893 = _t1662 - _t1663 = Proto.Value(value=OneOf(:boolean_value, boolean_value893)) - _t1661 = _t1663 + prediction882 = _t1648 + if prediction882 == 12 + _t1664 = parse_boolean_value(parser) + boolean_value894 = _t1664 + _t1665 = Proto.Value(value=OneOf(:boolean_value, boolean_value894)) + _t1663 = _t1665 else - if prediction881 == 11 + if prediction882 == 11 consume_literal!(parser, "missing") - _t1665 = Proto.MissingValue() - _t1666 = Proto.Value(value=OneOf(:missing_value, _t1665)) - _t1664 = _t1666 + _t1667 = Proto.MissingValue() + _t1668 = Proto.Value(value=OneOf(:missing_value, _t1667)) + _t1666 = _t1668 else - if prediction881 == 10 - formatted_decimal892 = consume_terminal!(parser, "DECIMAL") - _t1668 = Proto.Value(value=OneOf(:decimal_value, formatted_decimal892)) - _t1667 = _t1668 + if prediction882 == 10 + formatted_decimal893 = consume_terminal!(parser, "DECIMAL") + _t1670 = Proto.Value(value=OneOf(:decimal_value, formatted_decimal893)) + _t1669 = _t1670 else - if prediction881 == 9 - formatted_int128891 = consume_terminal!(parser, "INT128") - _t1670 = Proto.Value(value=OneOf(:int128_value, formatted_int128891)) - _t1669 = _t1670 + if prediction882 == 9 + formatted_int128892 = consume_terminal!(parser, "INT128") + _t1672 = Proto.Value(value=OneOf(:int128_value, formatted_int128892)) + _t1671 = _t1672 else - if prediction881 == 8 - formatted_uint128890 = consume_terminal!(parser, "UINT128") - _t1672 = Proto.Value(value=OneOf(:uint128_value, formatted_uint128890)) - _t1671 = _t1672 + if prediction882 == 8 + formatted_uint128891 = consume_terminal!(parser, "UINT128") + _t1674 = Proto.Value(value=OneOf(:uint128_value, formatted_uint128891)) + _t1673 = _t1674 else - if prediction881 == 7 - formatted_uint32889 = consume_terminal!(parser, "UINT32") - _t1674 = Proto.Value(value=OneOf(:uint32_value, formatted_uint32889)) - _t1673 = _t1674 + if prediction882 == 7 + formatted_uint32890 = consume_terminal!(parser, "UINT32") + _t1676 = Proto.Value(value=OneOf(:uint32_value, formatted_uint32890)) + _t1675 = _t1676 else - if prediction881 == 6 - formatted_float888 = consume_terminal!(parser, "FLOAT") - _t1676 = Proto.Value(value=OneOf(:float_value, formatted_float888)) - _t1675 = _t1676 + if prediction882 == 6 + formatted_float889 = consume_terminal!(parser, "FLOAT") + _t1678 = Proto.Value(value=OneOf(:float_value, formatted_float889)) + _t1677 = _t1678 else - if prediction881 == 5 - formatted_float32887 = consume_terminal!(parser, "FLOAT32") - _t1678 = Proto.Value(value=OneOf(:float32_value, formatted_float32887)) - _t1677 = _t1678 + if prediction882 == 5 + formatted_float32888 = consume_terminal!(parser, "FLOAT32") + _t1680 = Proto.Value(value=OneOf(:float32_value, formatted_float32888)) + _t1679 = _t1680 else - if prediction881 == 4 - formatted_int886 = consume_terminal!(parser, "INT") - _t1680 = Proto.Value(value=OneOf(:int_value, formatted_int886)) - _t1679 = _t1680 + if prediction882 == 4 + formatted_int887 = consume_terminal!(parser, "INT") + _t1682 = Proto.Value(value=OneOf(:int_value, formatted_int887)) + _t1681 = _t1682 else - if prediction881 == 3 - formatted_int32885 = consume_terminal!(parser, "INT32") - _t1682 = Proto.Value(value=OneOf(:int32_value, formatted_int32885)) - _t1681 = _t1682 + if prediction882 == 3 + formatted_int32886 = consume_terminal!(parser, "INT32") + _t1684 = Proto.Value(value=OneOf(:int32_value, formatted_int32886)) + _t1683 = _t1684 else - if prediction881 == 2 - formatted_string884 = consume_terminal!(parser, "STRING") - _t1684 = Proto.Value(value=OneOf(:string_value, formatted_string884)) - _t1683 = _t1684 + if prediction882 == 2 + formatted_string885 = consume_terminal!(parser, "STRING") + _t1686 = Proto.Value(value=OneOf(:string_value, formatted_string885)) + _t1685 = _t1686 else - if prediction881 == 1 - _t1686 = parse_datetime(parser) - datetime883 = _t1686 - _t1687 = Proto.Value(value=OneOf(:datetime_value, datetime883)) - _t1685 = _t1687 + if prediction882 == 1 + _t1688 = parse_datetime(parser) + datetime884 = _t1688 + _t1689 = Proto.Value(value=OneOf(:datetime_value, datetime884)) + _t1687 = _t1689 else - if prediction881 == 0 - _t1689 = parse_date(parser) - date882 = _t1689 - _t1690 = Proto.Value(value=OneOf(:date_value, date882)) - _t1688 = _t1690 + if prediction882 == 0 + _t1691 = parse_date(parser) + date883 = _t1691 + _t1692 = Proto.Value(value=OneOf(:date_value, date883)) + _t1690 = _t1692 else throw(ParseError("Unexpected token in value" * ": " * string(lookahead(parser, 0)))) end - _t1685 = _t1688 + _t1687 = _t1690 end - _t1683 = _t1685 + _t1685 = _t1687 end - _t1681 = _t1683 + _t1683 = _t1685 end - _t1679 = _t1681 + _t1681 = _t1683 end - _t1677 = _t1679 + _t1679 = _t1681 end - _t1675 = _t1677 + _t1677 = _t1679 end - _t1673 = _t1675 + _t1675 = _t1677 end - _t1671 = _t1673 + _t1673 = _t1675 end - _t1669 = _t1671 + _t1671 = _t1673 end - _t1667 = _t1669 + _t1669 = _t1671 end - _t1664 = _t1667 + _t1666 = _t1669 end - _t1661 = _t1664 + _t1663 = _t1666 end - result895 = _t1661 - record_span!(parser, span_start894, "Value") - return result895 + result896 = _t1663 + record_span!(parser, span_start895, "Value") + return result896 end function parse_date(parser::ParserState)::Proto.DateValue - span_start899 = span_start(parser) + span_start900 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "date") - formatted_int896 = consume_terminal!(parser, "INT") - formatted_int_3897 = consume_terminal!(parser, "INT") - formatted_int_4898 = consume_terminal!(parser, "INT") + formatted_int897 = consume_terminal!(parser, "INT") + formatted_int_3898 = consume_terminal!(parser, "INT") + formatted_int_4899 = consume_terminal!(parser, "INT") consume_literal!(parser, ")") - _t1691 = Proto.DateValue(year=Int32(formatted_int896), month=Int32(formatted_int_3897), day=Int32(formatted_int_4898)) - result900 = _t1691 - record_span!(parser, span_start899, "DateValue") - return result900 + _t1693 = Proto.DateValue(year=Int32(formatted_int897), month=Int32(formatted_int_3898), day=Int32(formatted_int_4899)) + result901 = _t1693 + record_span!(parser, span_start900, "DateValue") + return result901 end function parse_datetime(parser::ParserState)::Proto.DateTimeValue - span_start908 = span_start(parser) + span_start909 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "datetime") - formatted_int901 = consume_terminal!(parser, "INT") - formatted_int_3902 = consume_terminal!(parser, "INT") - formatted_int_4903 = consume_terminal!(parser, "INT") - formatted_int_5904 = consume_terminal!(parser, "INT") - formatted_int_6905 = consume_terminal!(parser, "INT") - formatted_int_7906 = consume_terminal!(parser, "INT") + formatted_int902 = consume_terminal!(parser, "INT") + formatted_int_3903 = consume_terminal!(parser, "INT") + formatted_int_4904 = consume_terminal!(parser, "INT") + formatted_int_5905 = consume_terminal!(parser, "INT") + formatted_int_6906 = consume_terminal!(parser, "INT") + formatted_int_7907 = consume_terminal!(parser, "INT") if match_lookahead_terminal(parser, "INT", 0) - _t1692 = consume_terminal!(parser, "INT") + _t1694 = consume_terminal!(parser, "INT") else - _t1692 = nothing + _t1694 = nothing end - formatted_int_8907 = _t1692 + formatted_int_8908 = _t1694 consume_literal!(parser, ")") - _t1693 = Proto.DateTimeValue(year=Int32(formatted_int901), month=Int32(formatted_int_3902), day=Int32(formatted_int_4903), hour=Int32(formatted_int_5904), minute=Int32(formatted_int_6905), second=Int32(formatted_int_7906), microsecond=Int32((!isnothing(formatted_int_8907) ? formatted_int_8907 : 0))) - result909 = _t1693 - record_span!(parser, span_start908, "DateTimeValue") - return result909 + _t1695 = Proto.DateTimeValue(year=Int32(formatted_int902), month=Int32(formatted_int_3903), day=Int32(formatted_int_4904), hour=Int32(formatted_int_5905), minute=Int32(formatted_int_6906), second=Int32(formatted_int_7907), microsecond=Int32((!isnothing(formatted_int_8908) ? formatted_int_8908 : 0))) + result910 = _t1695 + record_span!(parser, span_start909, "DateTimeValue") + return result910 end function parse_conjunction(parser::ParserState)::Proto.Conjunction - span_start914 = span_start(parser) + span_start915 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "and") - xs910 = Proto.Formula[] - cond911 = match_lookahead_literal(parser, "(", 0) - while cond911 - _t1694 = parse_formula(parser) - item912 = _t1694 - push!(xs910, item912) - cond911 = match_lookahead_literal(parser, "(", 0) + xs911 = Proto.Formula[] + cond912 = match_lookahead_literal(parser, "(", 0) + while cond912 + _t1696 = parse_formula(parser) + item913 = _t1696 + push!(xs911, item913) + cond912 = match_lookahead_literal(parser, "(", 0) end - formulas913 = xs910 + formulas914 = xs911 consume_literal!(parser, ")") - _t1695 = Proto.Conjunction(args=formulas913) - result915 = _t1695 - record_span!(parser, span_start914, "Conjunction") - return result915 + _t1697 = Proto.Conjunction(args=formulas914) + result916 = _t1697 + record_span!(parser, span_start915, "Conjunction") + return result916 end function parse_disjunction(parser::ParserState)::Proto.Disjunction - span_start920 = span_start(parser) + span_start921 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "or") - xs916 = Proto.Formula[] - cond917 = match_lookahead_literal(parser, "(", 0) - while cond917 - _t1696 = parse_formula(parser) - item918 = _t1696 - push!(xs916, item918) - cond917 = match_lookahead_literal(parser, "(", 0) + xs917 = Proto.Formula[] + cond918 = match_lookahead_literal(parser, "(", 0) + while cond918 + _t1698 = parse_formula(parser) + item919 = _t1698 + push!(xs917, item919) + cond918 = match_lookahead_literal(parser, "(", 0) end - formulas919 = xs916 + formulas920 = xs917 consume_literal!(parser, ")") - _t1697 = Proto.Disjunction(args=formulas919) - result921 = _t1697 - record_span!(parser, span_start920, "Disjunction") - return result921 + _t1699 = Proto.Disjunction(args=formulas920) + result922 = _t1699 + record_span!(parser, span_start921, "Disjunction") + return result922 end function parse_not(parser::ParserState)::Proto.Not - span_start923 = span_start(parser) + span_start924 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "not") - _t1698 = parse_formula(parser) - formula922 = _t1698 + _t1700 = parse_formula(parser) + formula923 = _t1700 consume_literal!(parser, ")") - _t1699 = Proto.Not(arg=formula922) - result924 = _t1699 - record_span!(parser, span_start923, "Not") - return result924 + _t1701 = Proto.Not(arg=formula923) + result925 = _t1701 + record_span!(parser, span_start924, "Not") + return result925 end function parse_ffi(parser::ParserState)::Proto.FFI - span_start928 = span_start(parser) + span_start929 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "ffi") - _t1700 = parse_name(parser) - name925 = _t1700 - _t1701 = parse_ffi_args(parser) - ffi_args926 = _t1701 - _t1702 = parse_terms(parser) - terms927 = _t1702 + _t1702 = parse_name(parser) + name926 = _t1702 + _t1703 = parse_ffi_args(parser) + ffi_args927 = _t1703 + _t1704 = parse_terms(parser) + terms928 = _t1704 consume_literal!(parser, ")") - _t1703 = Proto.FFI(name=name925, args=ffi_args926, terms=terms927) - result929 = _t1703 - record_span!(parser, span_start928, "FFI") - return result929 + _t1705 = Proto.FFI(name=name926, args=ffi_args927, terms=terms928) + result930 = _t1705 + record_span!(parser, span_start929, "FFI") + return result930 end function parse_name(parser::ParserState)::String consume_literal!(parser, ":") - symbol930 = consume_terminal!(parser, "SYMBOL") - return symbol930 + symbol931 = consume_terminal!(parser, "SYMBOL") + return symbol931 end function parse_ffi_args(parser::ParserState)::Vector{Proto.Abstraction} consume_literal!(parser, "(") consume_literal!(parser, "args") - xs931 = Proto.Abstraction[] - cond932 = match_lookahead_literal(parser, "(", 0) - while cond932 - _t1704 = parse_abstraction(parser) - item933 = _t1704 - push!(xs931, item933) - cond932 = match_lookahead_literal(parser, "(", 0) + xs932 = Proto.Abstraction[] + cond933 = match_lookahead_literal(parser, "(", 0) + while cond933 + _t1706 = parse_abstraction(parser) + item934 = _t1706 + push!(xs932, item934) + cond933 = match_lookahead_literal(parser, "(", 0) end - abstractions934 = xs931 + abstractions935 = xs932 consume_literal!(parser, ")") - return abstractions934 + return abstractions935 end function parse_atom(parser::ParserState)::Proto.Atom - span_start940 = span_start(parser) + span_start941 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "atom") - _t1705 = parse_relation_id(parser) - relation_id935 = _t1705 - xs936 = Proto.Term[] - cond937 = (((((((((((((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 cond937 - _t1706 = parse_term(parser) - item938 = _t1706 - push!(xs936, item938) - cond937 = (((((((((((((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)) + _t1707 = parse_relation_id(parser) + relation_id936 = _t1707 + xs937 = Proto.Term[] + cond938 = (((((((((((((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 cond938 + _t1708 = parse_term(parser) + item939 = _t1708 + push!(xs937, item939) + cond938 = (((((((((((((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 - terms939 = xs936 + terms940 = xs937 consume_literal!(parser, ")") - _t1707 = Proto.Atom(name=relation_id935, terms=terms939) - result941 = _t1707 - record_span!(parser, span_start940, "Atom") - return result941 + _t1709 = Proto.Atom(name=relation_id936, terms=terms940) + result942 = _t1709 + record_span!(parser, span_start941, "Atom") + return result942 end function parse_pragma(parser::ParserState)::Proto.Pragma - span_start947 = span_start(parser) + span_start948 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "pragma") - _t1708 = parse_name(parser) - name942 = _t1708 - xs943 = Proto.Term[] - cond944 = (((((((((((((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 cond944 - _t1709 = parse_term(parser) - item945 = _t1709 - push!(xs943, item945) - cond944 = (((((((((((((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)) + _t1710 = parse_name(parser) + name943 = _t1710 + xs944 = Proto.Term[] + cond945 = (((((((((((((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 cond945 + _t1711 = parse_term(parser) + item946 = _t1711 + push!(xs944, item946) + cond945 = (((((((((((((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 - terms946 = xs943 + terms947 = xs944 consume_literal!(parser, ")") - _t1710 = Proto.Pragma(name=name942, terms=terms946) - result948 = _t1710 - record_span!(parser, span_start947, "Pragma") - return result948 + _t1712 = Proto.Pragma(name=name943, terms=terms947) + result949 = _t1712 + record_span!(parser, span_start948, "Pragma") + return result949 end function parse_primitive(parser::ParserState)::Proto.Primitive - span_start964 = span_start(parser) + span_start965 = span_start(parser) if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "primitive", 1) - _t1712 = 9 + _t1714 = 9 else if match_lookahead_literal(parser, ">=", 1) - _t1713 = 4 + _t1715 = 4 else if match_lookahead_literal(parser, ">", 1) - _t1714 = 3 + _t1716 = 3 else if match_lookahead_literal(parser, "=", 1) - _t1715 = 0 + _t1717 = 0 else if match_lookahead_literal(parser, "<=", 1) - _t1716 = 2 + _t1718 = 2 else if match_lookahead_literal(parser, "<", 1) - _t1717 = 1 + _t1719 = 1 else if match_lookahead_literal(parser, "/", 1) - _t1718 = 8 + _t1720 = 8 else if match_lookahead_literal(parser, "-", 1) - _t1719 = 6 + _t1721 = 6 else if match_lookahead_literal(parser, "+", 1) - _t1720 = 5 + _t1722 = 5 else if match_lookahead_literal(parser, "*", 1) - _t1721 = 7 + _t1723 = 7 else - _t1721 = -1 + _t1723 = -1 end - _t1720 = _t1721 + _t1722 = _t1723 end - _t1719 = _t1720 + _t1721 = _t1722 end - _t1718 = _t1719 + _t1720 = _t1721 end - _t1717 = _t1718 + _t1719 = _t1720 end - _t1716 = _t1717 + _t1718 = _t1719 end - _t1715 = _t1716 + _t1717 = _t1718 end - _t1714 = _t1715 + _t1716 = _t1717 end - _t1713 = _t1714 + _t1715 = _t1716 end - _t1712 = _t1713 + _t1714 = _t1715 end - _t1711 = _t1712 + _t1713 = _t1714 else - _t1711 = -1 + _t1713 = -1 end - prediction949 = _t1711 - if prediction949 == 9 + prediction950 = _t1713 + if prediction950 == 9 consume_literal!(parser, "(") consume_literal!(parser, "primitive") - _t1723 = parse_name(parser) - name959 = _t1723 - xs960 = Proto.RelTerm[] - cond961 = ((((((((((((((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 cond961 - _t1724 = parse_rel_term(parser) - item962 = _t1724 - push!(xs960, item962) - cond961 = ((((((((((((((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)) + _t1725 = parse_name(parser) + name960 = _t1725 + xs961 = Proto.RelTerm[] + cond962 = ((((((((((((((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 cond962 + _t1726 = parse_rel_term(parser) + item963 = _t1726 + push!(xs961, item963) + cond962 = ((((((((((((((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_terms963 = xs960 + rel_terms964 = xs961 consume_literal!(parser, ")") - _t1725 = Proto.Primitive(name=name959, terms=rel_terms963) - _t1722 = _t1725 + _t1727 = Proto.Primitive(name=name960, terms=rel_terms964) + _t1724 = _t1727 else - if prediction949 == 8 - _t1727 = parse_divide(parser) - divide958 = _t1727 - _t1726 = divide958 + if prediction950 == 8 + _t1729 = parse_divide(parser) + divide959 = _t1729 + _t1728 = divide959 else - if prediction949 == 7 - _t1729 = parse_multiply(parser) - multiply957 = _t1729 - _t1728 = multiply957 + if prediction950 == 7 + _t1731 = parse_multiply(parser) + multiply958 = _t1731 + _t1730 = multiply958 else - if prediction949 == 6 - _t1731 = parse_minus(parser) - minus956 = _t1731 - _t1730 = minus956 + if prediction950 == 6 + _t1733 = parse_minus(parser) + minus957 = _t1733 + _t1732 = minus957 else - if prediction949 == 5 - _t1733 = parse_add(parser) - add955 = _t1733 - _t1732 = add955 + if prediction950 == 5 + _t1735 = parse_add(parser) + add956 = _t1735 + _t1734 = add956 else - if prediction949 == 4 - _t1735 = parse_gt_eq(parser) - gt_eq954 = _t1735 - _t1734 = gt_eq954 + if prediction950 == 4 + _t1737 = parse_gt_eq(parser) + gt_eq955 = _t1737 + _t1736 = gt_eq955 else - if prediction949 == 3 - _t1737 = parse_gt(parser) - gt953 = _t1737 - _t1736 = gt953 + if prediction950 == 3 + _t1739 = parse_gt(parser) + gt954 = _t1739 + _t1738 = gt954 else - if prediction949 == 2 - _t1739 = parse_lt_eq(parser) - lt_eq952 = _t1739 - _t1738 = lt_eq952 + if prediction950 == 2 + _t1741 = parse_lt_eq(parser) + lt_eq953 = _t1741 + _t1740 = lt_eq953 else - if prediction949 == 1 - _t1741 = parse_lt(parser) - lt951 = _t1741 - _t1740 = lt951 + if prediction950 == 1 + _t1743 = parse_lt(parser) + lt952 = _t1743 + _t1742 = lt952 else - if prediction949 == 0 - _t1743 = parse_eq(parser) - eq950 = _t1743 - _t1742 = eq950 + if prediction950 == 0 + _t1745 = parse_eq(parser) + eq951 = _t1745 + _t1744 = eq951 else throw(ParseError("Unexpected token in primitive" * ": " * string(lookahead(parser, 0)))) end - _t1740 = _t1742 + _t1742 = _t1744 end - _t1738 = _t1740 + _t1740 = _t1742 end - _t1736 = _t1738 + _t1738 = _t1740 end - _t1734 = _t1736 + _t1736 = _t1738 end - _t1732 = _t1734 + _t1734 = _t1736 end - _t1730 = _t1732 + _t1732 = _t1734 end - _t1728 = _t1730 + _t1730 = _t1732 end - _t1726 = _t1728 + _t1728 = _t1730 end - _t1722 = _t1726 + _t1724 = _t1728 end - result965 = _t1722 - record_span!(parser, span_start964, "Primitive") - return result965 + result966 = _t1724 + record_span!(parser, span_start965, "Primitive") + return result966 end function parse_eq(parser::ParserState)::Proto.Primitive - span_start968 = span_start(parser) + span_start969 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "=") - _t1744 = parse_term(parser) - term966 = _t1744 - _t1745 = parse_term(parser) - term_3967 = _t1745 + _t1746 = parse_term(parser) + term967 = _t1746 + _t1747 = parse_term(parser) + term_3968 = _t1747 consume_literal!(parser, ")") - _t1746 = Proto.RelTerm(rel_term_type=OneOf(:term, term966)) - _t1747 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3967)) - _t1748 = Proto.Primitive(name="rel_primitive_eq", terms=Proto.RelTerm[_t1746, _t1747]) - result969 = _t1748 - record_span!(parser, span_start968, "Primitive") - return result969 + _t1748 = Proto.RelTerm(rel_term_type=OneOf(:term, term967)) + _t1749 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3968)) + _t1750 = Proto.Primitive(name="rel_primitive_eq", terms=Proto.RelTerm[_t1748, _t1749]) + result970 = _t1750 + record_span!(parser, span_start969, "Primitive") + return result970 end function parse_lt(parser::ParserState)::Proto.Primitive - span_start972 = span_start(parser) + span_start973 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "<") - _t1749 = parse_term(parser) - term970 = _t1749 - _t1750 = parse_term(parser) - term_3971 = _t1750 + _t1751 = parse_term(parser) + term971 = _t1751 + _t1752 = parse_term(parser) + term_3972 = _t1752 consume_literal!(parser, ")") - _t1751 = Proto.RelTerm(rel_term_type=OneOf(:term, term970)) - _t1752 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3971)) - _t1753 = Proto.Primitive(name="rel_primitive_lt_monotype", terms=Proto.RelTerm[_t1751, _t1752]) - result973 = _t1753 - record_span!(parser, span_start972, "Primitive") - return result973 + _t1753 = Proto.RelTerm(rel_term_type=OneOf(:term, term971)) + _t1754 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3972)) + _t1755 = Proto.Primitive(name="rel_primitive_lt_monotype", terms=Proto.RelTerm[_t1753, _t1754]) + result974 = _t1755 + record_span!(parser, span_start973, "Primitive") + return result974 end function parse_lt_eq(parser::ParserState)::Proto.Primitive - span_start976 = span_start(parser) + span_start977 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "<=") - _t1754 = parse_term(parser) - term974 = _t1754 - _t1755 = parse_term(parser) - term_3975 = _t1755 + _t1756 = parse_term(parser) + term975 = _t1756 + _t1757 = parse_term(parser) + term_3976 = _t1757 consume_literal!(parser, ")") - _t1756 = Proto.RelTerm(rel_term_type=OneOf(:term, term974)) - _t1757 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3975)) - _t1758 = Proto.Primitive(name="rel_primitive_lt_eq_monotype", terms=Proto.RelTerm[_t1756, _t1757]) - result977 = _t1758 - record_span!(parser, span_start976, "Primitive") - return result977 + _t1758 = Proto.RelTerm(rel_term_type=OneOf(:term, term975)) + _t1759 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3976)) + _t1760 = Proto.Primitive(name="rel_primitive_lt_eq_monotype", terms=Proto.RelTerm[_t1758, _t1759]) + result978 = _t1760 + record_span!(parser, span_start977, "Primitive") + return result978 end function parse_gt(parser::ParserState)::Proto.Primitive - span_start980 = span_start(parser) + span_start981 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, ">") - _t1759 = parse_term(parser) - term978 = _t1759 - _t1760 = parse_term(parser) - term_3979 = _t1760 + _t1761 = parse_term(parser) + term979 = _t1761 + _t1762 = parse_term(parser) + term_3980 = _t1762 consume_literal!(parser, ")") - _t1761 = Proto.RelTerm(rel_term_type=OneOf(:term, term978)) - _t1762 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3979)) - _t1763 = Proto.Primitive(name="rel_primitive_gt_monotype", terms=Proto.RelTerm[_t1761, _t1762]) - result981 = _t1763 - record_span!(parser, span_start980, "Primitive") - return result981 + _t1763 = Proto.RelTerm(rel_term_type=OneOf(:term, term979)) + _t1764 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3980)) + _t1765 = Proto.Primitive(name="rel_primitive_gt_monotype", terms=Proto.RelTerm[_t1763, _t1764]) + result982 = _t1765 + record_span!(parser, span_start981, "Primitive") + return result982 end function parse_gt_eq(parser::ParserState)::Proto.Primitive - span_start984 = span_start(parser) + span_start985 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, ">=") - _t1764 = parse_term(parser) - term982 = _t1764 - _t1765 = parse_term(parser) - term_3983 = _t1765 + _t1766 = parse_term(parser) + term983 = _t1766 + _t1767 = parse_term(parser) + term_3984 = _t1767 consume_literal!(parser, ")") - _t1766 = Proto.RelTerm(rel_term_type=OneOf(:term, term982)) - _t1767 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3983)) - _t1768 = Proto.Primitive(name="rel_primitive_gt_eq_monotype", terms=Proto.RelTerm[_t1766, _t1767]) - result985 = _t1768 - record_span!(parser, span_start984, "Primitive") - return result985 + _t1768 = Proto.RelTerm(rel_term_type=OneOf(:term, term983)) + _t1769 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3984)) + _t1770 = Proto.Primitive(name="rel_primitive_gt_eq_monotype", terms=Proto.RelTerm[_t1768, _t1769]) + result986 = _t1770 + record_span!(parser, span_start985, "Primitive") + return result986 end function parse_add(parser::ParserState)::Proto.Primitive - span_start989 = span_start(parser) + span_start990 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "+") - _t1769 = parse_term(parser) - term986 = _t1769 - _t1770 = parse_term(parser) - term_3987 = _t1770 _t1771 = parse_term(parser) - term_4988 = _t1771 + term987 = _t1771 + _t1772 = parse_term(parser) + term_3988 = _t1772 + _t1773 = parse_term(parser) + term_4989 = _t1773 consume_literal!(parser, ")") - _t1772 = Proto.RelTerm(rel_term_type=OneOf(:term, term986)) - _t1773 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3987)) - _t1774 = Proto.RelTerm(rel_term_type=OneOf(:term, term_4988)) - _t1775 = Proto.Primitive(name="rel_primitive_add_monotype", terms=Proto.RelTerm[_t1772, _t1773, _t1774]) - result990 = _t1775 - record_span!(parser, span_start989, "Primitive") - return result990 + _t1774 = Proto.RelTerm(rel_term_type=OneOf(:term, term987)) + _t1775 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3988)) + _t1776 = Proto.RelTerm(rel_term_type=OneOf(:term, term_4989)) + _t1777 = Proto.Primitive(name="rel_primitive_add_monotype", terms=Proto.RelTerm[_t1774, _t1775, _t1776]) + result991 = _t1777 + record_span!(parser, span_start990, "Primitive") + return result991 end function parse_minus(parser::ParserState)::Proto.Primitive - span_start994 = span_start(parser) + span_start995 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "-") - _t1776 = parse_term(parser) - term991 = _t1776 - _t1777 = parse_term(parser) - term_3992 = _t1777 _t1778 = parse_term(parser) - term_4993 = _t1778 + term992 = _t1778 + _t1779 = parse_term(parser) + term_3993 = _t1779 + _t1780 = parse_term(parser) + term_4994 = _t1780 consume_literal!(parser, ")") - _t1779 = Proto.RelTerm(rel_term_type=OneOf(:term, term991)) - _t1780 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3992)) - _t1781 = Proto.RelTerm(rel_term_type=OneOf(:term, term_4993)) - _t1782 = Proto.Primitive(name="rel_primitive_subtract_monotype", terms=Proto.RelTerm[_t1779, _t1780, _t1781]) - result995 = _t1782 - record_span!(parser, span_start994, "Primitive") - return result995 + _t1781 = Proto.RelTerm(rel_term_type=OneOf(:term, term992)) + _t1782 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3993)) + _t1783 = Proto.RelTerm(rel_term_type=OneOf(:term, term_4994)) + _t1784 = Proto.Primitive(name="rel_primitive_subtract_monotype", terms=Proto.RelTerm[_t1781, _t1782, _t1783]) + result996 = _t1784 + record_span!(parser, span_start995, "Primitive") + return result996 end function parse_multiply(parser::ParserState)::Proto.Primitive - span_start999 = span_start(parser) + span_start1000 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "*") - _t1783 = parse_term(parser) - term996 = _t1783 - _t1784 = parse_term(parser) - term_3997 = _t1784 _t1785 = parse_term(parser) - term_4998 = _t1785 + term997 = _t1785 + _t1786 = parse_term(parser) + term_3998 = _t1786 + _t1787 = parse_term(parser) + term_4999 = _t1787 consume_literal!(parser, ")") - _t1786 = Proto.RelTerm(rel_term_type=OneOf(:term, term996)) - _t1787 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3997)) - _t1788 = Proto.RelTerm(rel_term_type=OneOf(:term, term_4998)) - _t1789 = Proto.Primitive(name="rel_primitive_multiply_monotype", terms=Proto.RelTerm[_t1786, _t1787, _t1788]) - result1000 = _t1789 - record_span!(parser, span_start999, "Primitive") - return result1000 + _t1788 = Proto.RelTerm(rel_term_type=OneOf(:term, term997)) + _t1789 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3998)) + _t1790 = Proto.RelTerm(rel_term_type=OneOf(:term, term_4999)) + _t1791 = Proto.Primitive(name="rel_primitive_multiply_monotype", terms=Proto.RelTerm[_t1788, _t1789, _t1790]) + result1001 = _t1791 + record_span!(parser, span_start1000, "Primitive") + return result1001 end function parse_divide(parser::ParserState)::Proto.Primitive - span_start1004 = span_start(parser) + span_start1005 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "/") - _t1790 = parse_term(parser) - term1001 = _t1790 - _t1791 = parse_term(parser) - term_31002 = _t1791 _t1792 = parse_term(parser) - term_41003 = _t1792 + term1002 = _t1792 + _t1793 = parse_term(parser) + term_31003 = _t1793 + _t1794 = parse_term(parser) + term_41004 = _t1794 consume_literal!(parser, ")") - _t1793 = Proto.RelTerm(rel_term_type=OneOf(:term, term1001)) - _t1794 = Proto.RelTerm(rel_term_type=OneOf(:term, term_31002)) - _t1795 = Proto.RelTerm(rel_term_type=OneOf(:term, term_41003)) - _t1796 = Proto.Primitive(name="rel_primitive_divide_monotype", terms=Proto.RelTerm[_t1793, _t1794, _t1795]) - result1005 = _t1796 - record_span!(parser, span_start1004, "Primitive") - return result1005 + _t1795 = Proto.RelTerm(rel_term_type=OneOf(:term, term1002)) + _t1796 = Proto.RelTerm(rel_term_type=OneOf(:term, term_31003)) + _t1797 = Proto.RelTerm(rel_term_type=OneOf(:term, term_41004)) + _t1798 = Proto.Primitive(name="rel_primitive_divide_monotype", terms=Proto.RelTerm[_t1795, _t1796, _t1797]) + result1006 = _t1798 + record_span!(parser, span_start1005, "Primitive") + return result1006 end function parse_rel_term(parser::ParserState)::Proto.RelTerm - span_start1009 = span_start(parser) + span_start1010 = span_start(parser) if match_lookahead_literal(parser, "true", 0) - _t1797 = 1 + _t1799 = 1 else if match_lookahead_literal(parser, "missing", 0) - _t1798 = 1 + _t1800 = 1 else if match_lookahead_literal(parser, "false", 0) - _t1799 = 1 + _t1801 = 1 else if match_lookahead_literal(parser, "(", 0) - _t1800 = 1 + _t1802 = 1 else if match_lookahead_literal(parser, "#", 0) - _t1801 = 0 + _t1803 = 0 else if match_lookahead_terminal(parser, "SYMBOL", 0) - _t1802 = 1 + _t1804 = 1 else if match_lookahead_terminal(parser, "UINT32", 0) - _t1803 = 1 + _t1805 = 1 else if match_lookahead_terminal(parser, "UINT128", 0) - _t1804 = 1 + _t1806 = 1 else if match_lookahead_terminal(parser, "STRING", 0) - _t1805 = 1 + _t1807 = 1 else if match_lookahead_terminal(parser, "INT32", 0) - _t1806 = 1 + _t1808 = 1 else if match_lookahead_terminal(parser, "INT128", 0) - _t1807 = 1 + _t1809 = 1 else if match_lookahead_terminal(parser, "INT", 0) - _t1808 = 1 + _t1810 = 1 else if match_lookahead_terminal(parser, "FLOAT32", 0) - _t1809 = 1 + _t1811 = 1 else if match_lookahead_terminal(parser, "FLOAT", 0) - _t1810 = 1 + _t1812 = 1 else if match_lookahead_terminal(parser, "DECIMAL", 0) - _t1811 = 1 + _t1813 = 1 else - _t1811 = -1 + _t1813 = -1 end - _t1810 = _t1811 + _t1812 = _t1813 end - _t1809 = _t1810 + _t1811 = _t1812 end - _t1808 = _t1809 + _t1810 = _t1811 end - _t1807 = _t1808 + _t1809 = _t1810 end - _t1806 = _t1807 + _t1808 = _t1809 end - _t1805 = _t1806 + _t1807 = _t1808 end - _t1804 = _t1805 + _t1806 = _t1807 end - _t1803 = _t1804 + _t1805 = _t1806 end - _t1802 = _t1803 + _t1804 = _t1805 end - _t1801 = _t1802 + _t1803 = _t1804 end - _t1800 = _t1801 + _t1802 = _t1803 end - _t1799 = _t1800 + _t1801 = _t1802 end - _t1798 = _t1799 + _t1800 = _t1801 end - _t1797 = _t1798 + _t1799 = _t1800 end - prediction1006 = _t1797 - if prediction1006 == 1 - _t1813 = parse_term(parser) - term1008 = _t1813 - _t1814 = Proto.RelTerm(rel_term_type=OneOf(:term, term1008)) - _t1812 = _t1814 + prediction1007 = _t1799 + if prediction1007 == 1 + _t1815 = parse_term(parser) + term1009 = _t1815 + _t1816 = Proto.RelTerm(rel_term_type=OneOf(:term, term1009)) + _t1814 = _t1816 else - if prediction1006 == 0 - _t1816 = parse_specialized_value(parser) - specialized_value1007 = _t1816 - _t1817 = Proto.RelTerm(rel_term_type=OneOf(:specialized_value, specialized_value1007)) - _t1815 = _t1817 + if prediction1007 == 0 + _t1818 = parse_specialized_value(parser) + specialized_value1008 = _t1818 + _t1819 = Proto.RelTerm(rel_term_type=OneOf(:specialized_value, specialized_value1008)) + _t1817 = _t1819 else throw(ParseError("Unexpected token in rel_term" * ": " * string(lookahead(parser, 0)))) end - _t1812 = _t1815 + _t1814 = _t1817 end - result1010 = _t1812 - record_span!(parser, span_start1009, "RelTerm") - return result1010 + result1011 = _t1814 + record_span!(parser, span_start1010, "RelTerm") + return result1011 end function parse_specialized_value(parser::ParserState)::Proto.Value - span_start1012 = span_start(parser) + span_start1013 = span_start(parser) consume_literal!(parser, "#") - _t1818 = parse_raw_value(parser) - raw_value1011 = _t1818 - result1013 = raw_value1011 - record_span!(parser, span_start1012, "Value") - return result1013 + _t1820 = parse_raw_value(parser) + raw_value1012 = _t1820 + result1014 = raw_value1012 + record_span!(parser, span_start1013, "Value") + return result1014 end function parse_rel_atom(parser::ParserState)::Proto.RelAtom - span_start1019 = span_start(parser) + span_start1020 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "relatom") - _t1819 = parse_name(parser) - name1014 = _t1819 - xs1015 = Proto.RelTerm[] - cond1016 = ((((((((((((((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 cond1016 - _t1820 = parse_rel_term(parser) - item1017 = _t1820 - push!(xs1015, item1017) - cond1016 = ((((((((((((((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)) + _t1821 = parse_name(parser) + name1015 = _t1821 + xs1016 = Proto.RelTerm[] + cond1017 = ((((((((((((((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 cond1017 + _t1822 = parse_rel_term(parser) + item1018 = _t1822 + push!(xs1016, item1018) + cond1017 = ((((((((((((((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_terms1018 = xs1015 + rel_terms1019 = xs1016 consume_literal!(parser, ")") - _t1821 = Proto.RelAtom(name=name1014, terms=rel_terms1018) - result1020 = _t1821 - record_span!(parser, span_start1019, "RelAtom") - return result1020 + _t1823 = Proto.RelAtom(name=name1015, terms=rel_terms1019) + result1021 = _t1823 + record_span!(parser, span_start1020, "RelAtom") + return result1021 end function parse_cast(parser::ParserState)::Proto.Cast - span_start1023 = span_start(parser) + span_start1024 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "cast") - _t1822 = parse_term(parser) - term1021 = _t1822 - _t1823 = parse_term(parser) - term_31022 = _t1823 + _t1824 = parse_term(parser) + term1022 = _t1824 + _t1825 = parse_term(parser) + term_31023 = _t1825 consume_literal!(parser, ")") - _t1824 = Proto.Cast(input=term1021, result=term_31022) - result1024 = _t1824 - record_span!(parser, span_start1023, "Cast") - return result1024 + _t1826 = Proto.Cast(input=term1022, result=term_31023) + result1025 = _t1826 + record_span!(parser, span_start1024, "Cast") + return result1025 end function parse_attrs(parser::ParserState)::Vector{Proto.Attribute} consume_literal!(parser, "(") consume_literal!(parser, "attrs") - xs1025 = Proto.Attribute[] - cond1026 = match_lookahead_literal(parser, "(", 0) - while cond1026 - _t1825 = parse_attribute(parser) - item1027 = _t1825 - push!(xs1025, item1027) - cond1026 = match_lookahead_literal(parser, "(", 0) + xs1026 = Proto.Attribute[] + cond1027 = match_lookahead_literal(parser, "(", 0) + while cond1027 + _t1827 = parse_attribute(parser) + item1028 = _t1827 + push!(xs1026, item1028) + cond1027 = match_lookahead_literal(parser, "(", 0) end - attributes1028 = xs1025 + attributes1029 = xs1026 consume_literal!(parser, ")") - return attributes1028 + return attributes1029 end function parse_attribute(parser::ParserState)::Proto.Attribute - span_start1034 = span_start(parser) + span_start1035 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "attribute") - _t1826 = parse_name(parser) - name1029 = _t1826 - xs1030 = Proto.Value[] - cond1031 = ((((((((((((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 cond1031 - _t1827 = parse_raw_value(parser) - item1032 = _t1827 - push!(xs1030, item1032) - cond1031 = ((((((((((((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)) + _t1828 = parse_name(parser) + name1030 = _t1828 + xs1031 = Proto.Value[] + cond1032 = ((((((((((((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 cond1032 + _t1829 = parse_raw_value(parser) + item1033 = _t1829 + push!(xs1031, item1033) + cond1032 = ((((((((((((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_values1033 = xs1030 + raw_values1034 = xs1031 consume_literal!(parser, ")") - _t1828 = Proto.Attribute(name=name1029, args=raw_values1033) - result1035 = _t1828 - record_span!(parser, span_start1034, "Attribute") - return result1035 + _t1830 = Proto.Attribute(name=name1030, args=raw_values1034) + result1036 = _t1830 + record_span!(parser, span_start1035, "Attribute") + return result1036 end function parse_algorithm(parser::ParserState)::Proto.Algorithm - span_start1042 = span_start(parser) + span_start1043 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "algorithm") - xs1036 = Proto.RelationId[] - cond1037 = (match_lookahead_literal(parser, ":", 0) || match_lookahead_terminal(parser, "UINT128", 0)) - while cond1037 - _t1829 = parse_relation_id(parser) - item1038 = _t1829 - push!(xs1036, item1038) - cond1037 = (match_lookahead_literal(parser, ":", 0) || match_lookahead_terminal(parser, "UINT128", 0)) + xs1037 = Proto.RelationId[] + cond1038 = (match_lookahead_literal(parser, ":", 0) || match_lookahead_terminal(parser, "UINT128", 0)) + while cond1038 + _t1831 = parse_relation_id(parser) + item1039 = _t1831 + push!(xs1037, item1039) + cond1038 = (match_lookahead_literal(parser, ":", 0) || match_lookahead_terminal(parser, "UINT128", 0)) end - relation_ids1039 = xs1036 - _t1830 = parse_script(parser) - script1040 = _t1830 + relation_ids1040 = xs1037 + _t1832 = parse_script(parser) + script1041 = _t1832 if match_lookahead_literal(parser, "(", 0) - _t1832 = parse_attrs(parser) - _t1831 = _t1832 + _t1834 = parse_attrs(parser) + _t1833 = _t1834 else - _t1831 = nothing + _t1833 = nothing end - attrs1041 = _t1831 + attrs1042 = _t1833 consume_literal!(parser, ")") - _t1833 = Proto.Algorithm(var"#global"=relation_ids1039, body=script1040, attrs=(!isnothing(attrs1041) ? attrs1041 : Proto.Attribute[])) - result1043 = _t1833 - record_span!(parser, span_start1042, "Algorithm") - return result1043 + _t1835 = Proto.Algorithm(var"#global"=relation_ids1040, body=script1041, attrs=(!isnothing(attrs1042) ? attrs1042 : Proto.Attribute[])) + result1044 = _t1835 + record_span!(parser, span_start1043, "Algorithm") + return result1044 end function parse_script(parser::ParserState)::Proto.Script - span_start1048 = span_start(parser) + span_start1049 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "script") - xs1044 = Proto.Construct[] - cond1045 = match_lookahead_literal(parser, "(", 0) - while cond1045 - _t1834 = parse_construct(parser) - item1046 = _t1834 - push!(xs1044, item1046) - cond1045 = match_lookahead_literal(parser, "(", 0) + xs1045 = Proto.Construct[] + cond1046 = match_lookahead_literal(parser, "(", 0) + while cond1046 + _t1836 = parse_construct(parser) + item1047 = _t1836 + push!(xs1045, item1047) + cond1046 = match_lookahead_literal(parser, "(", 0) end - constructs1047 = xs1044 + constructs1048 = xs1045 consume_literal!(parser, ")") - _t1835 = Proto.Script(constructs=constructs1047) - result1049 = _t1835 - record_span!(parser, span_start1048, "Script") - return result1049 + _t1837 = Proto.Script(constructs=constructs1048) + result1050 = _t1837 + record_span!(parser, span_start1049, "Script") + return result1050 end function parse_construct(parser::ParserState)::Proto.Construct - span_start1053 = span_start(parser) + span_start1054 = span_start(parser) if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "upsert", 1) - _t1837 = 1 + _t1839 = 1 else if match_lookahead_literal(parser, "monus", 1) - _t1838 = 1 + _t1840 = 1 else if match_lookahead_literal(parser, "monoid", 1) - _t1839 = 1 + _t1841 = 1 else if match_lookahead_literal(parser, "loop", 1) - _t1840 = 0 + _t1842 = 0 else if match_lookahead_literal(parser, "break", 1) - _t1841 = 1 + _t1843 = 1 else if match_lookahead_literal(parser, "assign", 1) - _t1842 = 1 + _t1844 = 1 else - _t1842 = -1 + _t1844 = -1 end - _t1841 = _t1842 + _t1843 = _t1844 end - _t1840 = _t1841 + _t1842 = _t1843 end - _t1839 = _t1840 + _t1841 = _t1842 end - _t1838 = _t1839 + _t1840 = _t1841 end - _t1837 = _t1838 + _t1839 = _t1840 end - _t1836 = _t1837 + _t1838 = _t1839 else - _t1836 = -1 + _t1838 = -1 end - prediction1050 = _t1836 - if prediction1050 == 1 - _t1844 = parse_instruction(parser) - instruction1052 = _t1844 - _t1845 = Proto.Construct(construct_type=OneOf(:instruction, instruction1052)) - _t1843 = _t1845 + prediction1051 = _t1838 + if prediction1051 == 1 + _t1846 = parse_instruction(parser) + instruction1053 = _t1846 + _t1847 = Proto.Construct(construct_type=OneOf(:instruction, instruction1053)) + _t1845 = _t1847 else - if prediction1050 == 0 - _t1847 = parse_loop(parser) - loop1051 = _t1847 - _t1848 = Proto.Construct(construct_type=OneOf(:loop, loop1051)) - _t1846 = _t1848 + if prediction1051 == 0 + _t1849 = parse_loop(parser) + loop1052 = _t1849 + _t1850 = Proto.Construct(construct_type=OneOf(:loop, loop1052)) + _t1848 = _t1850 else throw(ParseError("Unexpected token in construct" * ": " * string(lookahead(parser, 0)))) end - _t1843 = _t1846 + _t1845 = _t1848 end - result1054 = _t1843 - record_span!(parser, span_start1053, "Construct") - return result1054 + result1055 = _t1845 + record_span!(parser, span_start1054, "Construct") + return result1055 end function parse_loop(parser::ParserState)::Proto.Loop - span_start1058 = span_start(parser) + span_start1059 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "loop") - _t1849 = parse_init(parser) - init1055 = _t1849 - _t1850 = parse_script(parser) - script1056 = _t1850 + _t1851 = parse_init(parser) + init1056 = _t1851 + _t1852 = parse_script(parser) + script1057 = _t1852 if match_lookahead_literal(parser, "(", 0) - _t1852 = parse_attrs(parser) - _t1851 = _t1852 + _t1854 = parse_attrs(parser) + _t1853 = _t1854 else - _t1851 = nothing + _t1853 = nothing end - attrs1057 = _t1851 + attrs1058 = _t1853 consume_literal!(parser, ")") - _t1853 = Proto.Loop(init=init1055, body=script1056, attrs=(!isnothing(attrs1057) ? attrs1057 : Proto.Attribute[])) - result1059 = _t1853 - record_span!(parser, span_start1058, "Loop") - return result1059 + _t1855 = Proto.Loop(init=init1056, body=script1057, attrs=(!isnothing(attrs1058) ? attrs1058 : Proto.Attribute[])) + result1060 = _t1855 + record_span!(parser, span_start1059, "Loop") + return result1060 end function parse_init(parser::ParserState)::Vector{Proto.Instruction} consume_literal!(parser, "(") consume_literal!(parser, "init") - xs1060 = Proto.Instruction[] - cond1061 = match_lookahead_literal(parser, "(", 0) - while cond1061 - _t1854 = parse_instruction(parser) - item1062 = _t1854 - push!(xs1060, item1062) - cond1061 = match_lookahead_literal(parser, "(", 0) + xs1061 = Proto.Instruction[] + cond1062 = match_lookahead_literal(parser, "(", 0) + while cond1062 + _t1856 = parse_instruction(parser) + item1063 = _t1856 + push!(xs1061, item1063) + cond1062 = match_lookahead_literal(parser, "(", 0) end - instructions1063 = xs1060 + instructions1064 = xs1061 consume_literal!(parser, ")") - return instructions1063 + return instructions1064 end function parse_instruction(parser::ParserState)::Proto.Instruction - span_start1070 = span_start(parser) + span_start1071 = span_start(parser) if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "upsert", 1) - _t1856 = 1 + _t1858 = 1 else if match_lookahead_literal(parser, "monus", 1) - _t1857 = 4 + _t1859 = 4 else if match_lookahead_literal(parser, "monoid", 1) - _t1858 = 3 + _t1860 = 3 else if match_lookahead_literal(parser, "break", 1) - _t1859 = 2 + _t1861 = 2 else if match_lookahead_literal(parser, "assign", 1) - _t1860 = 0 + _t1862 = 0 else - _t1860 = -1 + _t1862 = -1 end - _t1859 = _t1860 + _t1861 = _t1862 end - _t1858 = _t1859 + _t1860 = _t1861 end - _t1857 = _t1858 + _t1859 = _t1860 end - _t1856 = _t1857 + _t1858 = _t1859 end - _t1855 = _t1856 + _t1857 = _t1858 else - _t1855 = -1 + _t1857 = -1 end - prediction1064 = _t1855 - if prediction1064 == 4 - _t1862 = parse_monus_def(parser) - monus_def1069 = _t1862 - _t1863 = Proto.Instruction(instr_type=OneOf(:monus_def, monus_def1069)) - _t1861 = _t1863 + prediction1065 = _t1857 + if prediction1065 == 4 + _t1864 = parse_monus_def(parser) + monus_def1070 = _t1864 + _t1865 = Proto.Instruction(instr_type=OneOf(:monus_def, monus_def1070)) + _t1863 = _t1865 else - if prediction1064 == 3 - _t1865 = parse_monoid_def(parser) - monoid_def1068 = _t1865 - _t1866 = Proto.Instruction(instr_type=OneOf(:monoid_def, monoid_def1068)) - _t1864 = _t1866 + if prediction1065 == 3 + _t1867 = parse_monoid_def(parser) + monoid_def1069 = _t1867 + _t1868 = Proto.Instruction(instr_type=OneOf(:monoid_def, monoid_def1069)) + _t1866 = _t1868 else - if prediction1064 == 2 - _t1868 = parse_break(parser) - break1067 = _t1868 - _t1869 = Proto.Instruction(instr_type=OneOf(:var"#break", break1067)) - _t1867 = _t1869 + if prediction1065 == 2 + _t1870 = parse_break(parser) + break1068 = _t1870 + _t1871 = Proto.Instruction(instr_type=OneOf(:var"#break", break1068)) + _t1869 = _t1871 else - if prediction1064 == 1 - _t1871 = parse_upsert(parser) - upsert1066 = _t1871 - _t1872 = Proto.Instruction(instr_type=OneOf(:upsert, upsert1066)) - _t1870 = _t1872 + if prediction1065 == 1 + _t1873 = parse_upsert(parser) + upsert1067 = _t1873 + _t1874 = Proto.Instruction(instr_type=OneOf(:upsert, upsert1067)) + _t1872 = _t1874 else - if prediction1064 == 0 - _t1874 = parse_assign(parser) - assign1065 = _t1874 - _t1875 = Proto.Instruction(instr_type=OneOf(:assign, assign1065)) - _t1873 = _t1875 + if prediction1065 == 0 + _t1876 = parse_assign(parser) + assign1066 = _t1876 + _t1877 = Proto.Instruction(instr_type=OneOf(:assign, assign1066)) + _t1875 = _t1877 else throw(ParseError("Unexpected token in instruction" * ": " * string(lookahead(parser, 0)))) end - _t1870 = _t1873 + _t1872 = _t1875 end - _t1867 = _t1870 + _t1869 = _t1872 end - _t1864 = _t1867 + _t1866 = _t1869 end - _t1861 = _t1864 + _t1863 = _t1866 end - result1071 = _t1861 - record_span!(parser, span_start1070, "Instruction") - return result1071 + result1072 = _t1863 + record_span!(parser, span_start1071, "Instruction") + return result1072 end function parse_assign(parser::ParserState)::Proto.Assign - span_start1075 = span_start(parser) + span_start1076 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "assign") - _t1876 = parse_relation_id(parser) - relation_id1072 = _t1876 - _t1877 = parse_abstraction(parser) - abstraction1073 = _t1877 + _t1878 = parse_relation_id(parser) + relation_id1073 = _t1878 + _t1879 = parse_abstraction(parser) + abstraction1074 = _t1879 if match_lookahead_literal(parser, "(", 0) - _t1879 = parse_attrs(parser) - _t1878 = _t1879 + _t1881 = parse_attrs(parser) + _t1880 = _t1881 else - _t1878 = nothing + _t1880 = nothing end - attrs1074 = _t1878 + attrs1075 = _t1880 consume_literal!(parser, ")") - _t1880 = Proto.Assign(name=relation_id1072, body=abstraction1073, attrs=(!isnothing(attrs1074) ? attrs1074 : Proto.Attribute[])) - result1076 = _t1880 - record_span!(parser, span_start1075, "Assign") - return result1076 + _t1882 = Proto.Assign(name=relation_id1073, body=abstraction1074, attrs=(!isnothing(attrs1075) ? attrs1075 : Proto.Attribute[])) + result1077 = _t1882 + record_span!(parser, span_start1076, "Assign") + return result1077 end function parse_upsert(parser::ParserState)::Proto.Upsert - span_start1080 = span_start(parser) + span_start1081 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "upsert") - _t1881 = parse_relation_id(parser) - relation_id1077 = _t1881 - _t1882 = parse_abstraction_with_arity(parser) - abstraction_with_arity1078 = _t1882 + _t1883 = parse_relation_id(parser) + relation_id1078 = _t1883 + _t1884 = parse_abstraction_with_arity(parser) + abstraction_with_arity1079 = _t1884 if match_lookahead_literal(parser, "(", 0) - _t1884 = parse_attrs(parser) - _t1883 = _t1884 + _t1886 = parse_attrs(parser) + _t1885 = _t1886 else - _t1883 = nothing + _t1885 = nothing end - attrs1079 = _t1883 + attrs1080 = _t1885 consume_literal!(parser, ")") - _t1885 = Proto.Upsert(name=relation_id1077, body=abstraction_with_arity1078[1], attrs=(!isnothing(attrs1079) ? attrs1079 : Proto.Attribute[]), value_arity=abstraction_with_arity1078[2]) - result1081 = _t1885 - record_span!(parser, span_start1080, "Upsert") - return result1081 + _t1887 = Proto.Upsert(name=relation_id1078, body=abstraction_with_arity1079[1], attrs=(!isnothing(attrs1080) ? attrs1080 : Proto.Attribute[]), value_arity=abstraction_with_arity1079[2]) + result1082 = _t1887 + record_span!(parser, span_start1081, "Upsert") + return result1082 end function parse_abstraction_with_arity(parser::ParserState)::Tuple{Proto.Abstraction, Int64} consume_literal!(parser, "(") - _t1886 = parse_bindings(parser) - bindings1082 = _t1886 - _t1887 = parse_formula(parser) - formula1083 = _t1887 + _t1888 = parse_bindings(parser) + bindings1083 = _t1888 + _t1889 = parse_formula(parser) + formula1084 = _t1889 consume_literal!(parser, ")") - _t1888 = Proto.Abstraction(vars=vcat(bindings1082[1], !isnothing(bindings1082[2]) ? bindings1082[2] : []), value=formula1083) - return (_t1888, length(bindings1082[2]),) + _t1890 = Proto.Abstraction(vars=vcat(bindings1083[1], !isnothing(bindings1083[2]) ? bindings1083[2] : []), value=formula1084) + return (_t1890, length(bindings1083[2]),) end function parse_break(parser::ParserState)::Proto.Break - span_start1087 = span_start(parser) + span_start1088 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "break") - _t1889 = parse_relation_id(parser) - relation_id1084 = _t1889 - _t1890 = parse_abstraction(parser) - abstraction1085 = _t1890 + _t1891 = parse_relation_id(parser) + relation_id1085 = _t1891 + _t1892 = parse_abstraction(parser) + abstraction1086 = _t1892 if match_lookahead_literal(parser, "(", 0) - _t1892 = parse_attrs(parser) - _t1891 = _t1892 + _t1894 = parse_attrs(parser) + _t1893 = _t1894 else - _t1891 = nothing + _t1893 = nothing end - attrs1086 = _t1891 + attrs1087 = _t1893 consume_literal!(parser, ")") - _t1893 = Proto.Break(name=relation_id1084, body=abstraction1085, attrs=(!isnothing(attrs1086) ? attrs1086 : Proto.Attribute[])) - result1088 = _t1893 - record_span!(parser, span_start1087, "Break") - return result1088 + _t1895 = Proto.Break(name=relation_id1085, body=abstraction1086, attrs=(!isnothing(attrs1087) ? attrs1087 : Proto.Attribute[])) + result1089 = _t1895 + record_span!(parser, span_start1088, "Break") + return result1089 end function parse_monoid_def(parser::ParserState)::Proto.MonoidDef - span_start1093 = span_start(parser) + span_start1094 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "monoid") - _t1894 = parse_monoid(parser) - monoid1089 = _t1894 - _t1895 = parse_relation_id(parser) - relation_id1090 = _t1895 - _t1896 = parse_abstraction_with_arity(parser) - abstraction_with_arity1091 = _t1896 + _t1896 = parse_monoid(parser) + monoid1090 = _t1896 + _t1897 = parse_relation_id(parser) + relation_id1091 = _t1897 + _t1898 = parse_abstraction_with_arity(parser) + abstraction_with_arity1092 = _t1898 if match_lookahead_literal(parser, "(", 0) - _t1898 = parse_attrs(parser) - _t1897 = _t1898 + _t1900 = parse_attrs(parser) + _t1899 = _t1900 else - _t1897 = nothing + _t1899 = nothing end - attrs1092 = _t1897 + attrs1093 = _t1899 consume_literal!(parser, ")") - _t1899 = Proto.MonoidDef(monoid=monoid1089, name=relation_id1090, body=abstraction_with_arity1091[1], attrs=(!isnothing(attrs1092) ? attrs1092 : Proto.Attribute[]), value_arity=abstraction_with_arity1091[2]) - result1094 = _t1899 - record_span!(parser, span_start1093, "MonoidDef") - return result1094 + _t1901 = Proto.MonoidDef(monoid=monoid1090, name=relation_id1091, body=abstraction_with_arity1092[1], attrs=(!isnothing(attrs1093) ? attrs1093 : Proto.Attribute[]), value_arity=abstraction_with_arity1092[2]) + result1095 = _t1901 + record_span!(parser, span_start1094, "MonoidDef") + return result1095 end function parse_monoid(parser::ParserState)::Proto.Monoid - span_start1100 = span_start(parser) + span_start1101 = span_start(parser) if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "sum", 1) - _t1901 = 3 + _t1903 = 3 else if match_lookahead_literal(parser, "or", 1) - _t1902 = 0 + _t1904 = 0 else if match_lookahead_literal(parser, "min", 1) - _t1903 = 1 + _t1905 = 1 else if match_lookahead_literal(parser, "max", 1) - _t1904 = 2 + _t1906 = 2 else - _t1904 = -1 + _t1906 = -1 end - _t1903 = _t1904 + _t1905 = _t1906 end - _t1902 = _t1903 + _t1904 = _t1905 end - _t1901 = _t1902 + _t1903 = _t1904 end - _t1900 = _t1901 + _t1902 = _t1903 else - _t1900 = -1 + _t1902 = -1 end - prediction1095 = _t1900 - if prediction1095 == 3 - _t1906 = parse_sum_monoid(parser) - sum_monoid1099 = _t1906 - _t1907 = Proto.Monoid(value=OneOf(:sum_monoid, sum_monoid1099)) - _t1905 = _t1907 + prediction1096 = _t1902 + if prediction1096 == 3 + _t1908 = parse_sum_monoid(parser) + sum_monoid1100 = _t1908 + _t1909 = Proto.Monoid(value=OneOf(:sum_monoid, sum_monoid1100)) + _t1907 = _t1909 else - if prediction1095 == 2 - _t1909 = parse_max_monoid(parser) - max_monoid1098 = _t1909 - _t1910 = Proto.Monoid(value=OneOf(:max_monoid, max_monoid1098)) - _t1908 = _t1910 + if prediction1096 == 2 + _t1911 = parse_max_monoid(parser) + max_monoid1099 = _t1911 + _t1912 = Proto.Monoid(value=OneOf(:max_monoid, max_monoid1099)) + _t1910 = _t1912 else - if prediction1095 == 1 - _t1912 = parse_min_monoid(parser) - min_monoid1097 = _t1912 - _t1913 = Proto.Monoid(value=OneOf(:min_monoid, min_monoid1097)) - _t1911 = _t1913 + if prediction1096 == 1 + _t1914 = parse_min_monoid(parser) + min_monoid1098 = _t1914 + _t1915 = Proto.Monoid(value=OneOf(:min_monoid, min_monoid1098)) + _t1913 = _t1915 else - if prediction1095 == 0 - _t1915 = parse_or_monoid(parser) - or_monoid1096 = _t1915 - _t1916 = Proto.Monoid(value=OneOf(:or_monoid, or_monoid1096)) - _t1914 = _t1916 + if prediction1096 == 0 + _t1917 = parse_or_monoid(parser) + or_monoid1097 = _t1917 + _t1918 = Proto.Monoid(value=OneOf(:or_monoid, or_monoid1097)) + _t1916 = _t1918 else throw(ParseError("Unexpected token in monoid" * ": " * string(lookahead(parser, 0)))) end - _t1911 = _t1914 + _t1913 = _t1916 end - _t1908 = _t1911 + _t1910 = _t1913 end - _t1905 = _t1908 + _t1907 = _t1910 end - result1101 = _t1905 - record_span!(parser, span_start1100, "Monoid") - return result1101 + result1102 = _t1907 + record_span!(parser, span_start1101, "Monoid") + return result1102 end function parse_or_monoid(parser::ParserState)::Proto.OrMonoid - span_start1102 = span_start(parser) + span_start1103 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "or") consume_literal!(parser, ")") - _t1917 = Proto.OrMonoid() - result1103 = _t1917 - record_span!(parser, span_start1102, "OrMonoid") - return result1103 + _t1919 = Proto.OrMonoid() + result1104 = _t1919 + record_span!(parser, span_start1103, "OrMonoid") + return result1104 end function parse_min_monoid(parser::ParserState)::Proto.MinMonoid - span_start1105 = span_start(parser) + span_start1106 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "min") - _t1918 = parse_type(parser) - type1104 = _t1918 + _t1920 = parse_type(parser) + type1105 = _t1920 consume_literal!(parser, ")") - _t1919 = Proto.MinMonoid(var"#type"=type1104) - result1106 = _t1919 - record_span!(parser, span_start1105, "MinMonoid") - return result1106 + _t1921 = Proto.MinMonoid(var"#type"=type1105) + result1107 = _t1921 + record_span!(parser, span_start1106, "MinMonoid") + return result1107 end function parse_max_monoid(parser::ParserState)::Proto.MaxMonoid - span_start1108 = span_start(parser) + span_start1109 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "max") - _t1920 = parse_type(parser) - type1107 = _t1920 + _t1922 = parse_type(parser) + type1108 = _t1922 consume_literal!(parser, ")") - _t1921 = Proto.MaxMonoid(var"#type"=type1107) - result1109 = _t1921 - record_span!(parser, span_start1108, "MaxMonoid") - return result1109 + _t1923 = Proto.MaxMonoid(var"#type"=type1108) + result1110 = _t1923 + record_span!(parser, span_start1109, "MaxMonoid") + return result1110 end function parse_sum_monoid(parser::ParserState)::Proto.SumMonoid - span_start1111 = span_start(parser) + span_start1112 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "sum") - _t1922 = parse_type(parser) - type1110 = _t1922 + _t1924 = parse_type(parser) + type1111 = _t1924 consume_literal!(parser, ")") - _t1923 = Proto.SumMonoid(var"#type"=type1110) - result1112 = _t1923 - record_span!(parser, span_start1111, "SumMonoid") - return result1112 + _t1925 = Proto.SumMonoid(var"#type"=type1111) + result1113 = _t1925 + record_span!(parser, span_start1112, "SumMonoid") + return result1113 end function parse_monus_def(parser::ParserState)::Proto.MonusDef - span_start1117 = span_start(parser) + span_start1118 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "monus") - _t1924 = parse_monoid(parser) - monoid1113 = _t1924 - _t1925 = parse_relation_id(parser) - relation_id1114 = _t1925 - _t1926 = parse_abstraction_with_arity(parser) - abstraction_with_arity1115 = _t1926 + _t1926 = parse_monoid(parser) + monoid1114 = _t1926 + _t1927 = parse_relation_id(parser) + relation_id1115 = _t1927 + _t1928 = parse_abstraction_with_arity(parser) + abstraction_with_arity1116 = _t1928 if match_lookahead_literal(parser, "(", 0) - _t1928 = parse_attrs(parser) - _t1927 = _t1928 + _t1930 = parse_attrs(parser) + _t1929 = _t1930 else - _t1927 = nothing + _t1929 = nothing end - attrs1116 = _t1927 + attrs1117 = _t1929 consume_literal!(parser, ")") - _t1929 = Proto.MonusDef(monoid=monoid1113, name=relation_id1114, body=abstraction_with_arity1115[1], attrs=(!isnothing(attrs1116) ? attrs1116 : Proto.Attribute[]), value_arity=abstraction_with_arity1115[2]) - result1118 = _t1929 - record_span!(parser, span_start1117, "MonusDef") - return result1118 + _t1931 = Proto.MonusDef(monoid=monoid1114, name=relation_id1115, body=abstraction_with_arity1116[1], attrs=(!isnothing(attrs1117) ? attrs1117 : Proto.Attribute[]), value_arity=abstraction_with_arity1116[2]) + result1119 = _t1931 + record_span!(parser, span_start1118, "MonusDef") + return result1119 end function parse_constraint(parser::ParserState)::Proto.Constraint - span_start1123 = span_start(parser) + span_start1124 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "functional_dependency") - _t1930 = parse_relation_id(parser) - relation_id1119 = _t1930 - _t1931 = parse_abstraction(parser) - abstraction1120 = _t1931 - _t1932 = parse_functional_dependency_keys(parser) - functional_dependency_keys1121 = _t1932 - _t1933 = parse_functional_dependency_values(parser) - functional_dependency_values1122 = _t1933 + _t1932 = parse_relation_id(parser) + relation_id1120 = _t1932 + _t1933 = parse_abstraction(parser) + abstraction1121 = _t1933 + _t1934 = parse_functional_dependency_keys(parser) + functional_dependency_keys1122 = _t1934 + _t1935 = parse_functional_dependency_values(parser) + functional_dependency_values1123 = _t1935 consume_literal!(parser, ")") - _t1934 = Proto.FunctionalDependency(guard=abstraction1120, keys=functional_dependency_keys1121, values=functional_dependency_values1122) - _t1935 = Proto.Constraint(constraint_type=OneOf(:functional_dependency, _t1934), name=relation_id1119) - result1124 = _t1935 - record_span!(parser, span_start1123, "Constraint") - return result1124 + _t1936 = Proto.FunctionalDependency(guard=abstraction1121, keys=functional_dependency_keys1122, values=functional_dependency_values1123) + _t1937 = Proto.Constraint(constraint_type=OneOf(:functional_dependency, _t1936), name=relation_id1120) + result1125 = _t1937 + record_span!(parser, span_start1124, "Constraint") + return result1125 end function parse_functional_dependency_keys(parser::ParserState)::Vector{Proto.Var} consume_literal!(parser, "(") consume_literal!(parser, "keys") - xs1125 = Proto.Var[] - cond1126 = match_lookahead_terminal(parser, "SYMBOL", 0) - while cond1126 - _t1936 = parse_var(parser) - item1127 = _t1936 - push!(xs1125, item1127) - cond1126 = match_lookahead_terminal(parser, "SYMBOL", 0) + xs1126 = Proto.Var[] + cond1127 = match_lookahead_terminal(parser, "SYMBOL", 0) + while cond1127 + _t1938 = parse_var(parser) + item1128 = _t1938 + push!(xs1126, item1128) + cond1127 = match_lookahead_terminal(parser, "SYMBOL", 0) end - vars1128 = xs1125 + vars1129 = xs1126 consume_literal!(parser, ")") - return vars1128 + return vars1129 end function parse_functional_dependency_values(parser::ParserState)::Vector{Proto.Var} consume_literal!(parser, "(") consume_literal!(parser, "values") - xs1129 = Proto.Var[] - cond1130 = match_lookahead_terminal(parser, "SYMBOL", 0) - while cond1130 - _t1937 = parse_var(parser) - item1131 = _t1937 - push!(xs1129, item1131) - cond1130 = match_lookahead_terminal(parser, "SYMBOL", 0) + xs1130 = Proto.Var[] + cond1131 = match_lookahead_terminal(parser, "SYMBOL", 0) + while cond1131 + _t1939 = parse_var(parser) + item1132 = _t1939 + push!(xs1130, item1132) + cond1131 = match_lookahead_terminal(parser, "SYMBOL", 0) end - vars1132 = xs1129 + vars1133 = xs1130 consume_literal!(parser, ")") - return vars1132 + return vars1133 end function parse_data(parser::ParserState)::Proto.Data - span_start1138 = span_start(parser) + span_start1139 = span_start(parser) if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "iceberg_data", 1) - _t1939 = 3 + _t1941 = 3 else if match_lookahead_literal(parser, "edb", 1) - _t1940 = 0 + _t1942 = 0 else if match_lookahead_literal(parser, "csv_data", 1) - _t1941 = 2 + _t1943 = 2 else if match_lookahead_literal(parser, "betree_relation", 1) - _t1942 = 1 + _t1944 = 1 else - _t1942 = -1 + _t1944 = -1 end - _t1941 = _t1942 + _t1943 = _t1944 end - _t1940 = _t1941 + _t1942 = _t1943 end - _t1939 = _t1940 + _t1941 = _t1942 end - _t1938 = _t1939 + _t1940 = _t1941 else - _t1938 = -1 + _t1940 = -1 end - prediction1133 = _t1938 - if prediction1133 == 3 - _t1944 = parse_iceberg_data(parser) - iceberg_data1137 = _t1944 - _t1945 = Proto.Data(data_type=OneOf(:iceberg_data, iceberg_data1137)) - _t1943 = _t1945 + prediction1134 = _t1940 + if prediction1134 == 3 + _t1946 = parse_iceberg_data(parser) + iceberg_data1138 = _t1946 + _t1947 = Proto.Data(data_type=OneOf(:iceberg_data, iceberg_data1138)) + _t1945 = _t1947 else - if prediction1133 == 2 - _t1947 = parse_csv_data(parser) - csv_data1136 = _t1947 - _t1948 = Proto.Data(data_type=OneOf(:csv_data, csv_data1136)) - _t1946 = _t1948 + if prediction1134 == 2 + _t1949 = parse_csv_data(parser) + csv_data1137 = _t1949 + _t1950 = Proto.Data(data_type=OneOf(:csv_data, csv_data1137)) + _t1948 = _t1950 else - if prediction1133 == 1 - _t1950 = parse_betree_relation(parser) - betree_relation1135 = _t1950 - _t1951 = Proto.Data(data_type=OneOf(:betree_relation, betree_relation1135)) - _t1949 = _t1951 + if prediction1134 == 1 + _t1952 = parse_betree_relation(parser) + betree_relation1136 = _t1952 + _t1953 = Proto.Data(data_type=OneOf(:betree_relation, betree_relation1136)) + _t1951 = _t1953 else - if prediction1133 == 0 - _t1953 = parse_edb(parser) - edb1134 = _t1953 - _t1954 = Proto.Data(data_type=OneOf(:edb, edb1134)) - _t1952 = _t1954 + if prediction1134 == 0 + _t1955 = parse_edb(parser) + edb1135 = _t1955 + _t1956 = Proto.Data(data_type=OneOf(:edb, edb1135)) + _t1954 = _t1956 else throw(ParseError("Unexpected token in data" * ": " * string(lookahead(parser, 0)))) end - _t1949 = _t1952 + _t1951 = _t1954 end - _t1946 = _t1949 + _t1948 = _t1951 end - _t1943 = _t1946 + _t1945 = _t1948 end - result1139 = _t1943 - record_span!(parser, span_start1138, "Data") - return result1139 + result1140 = _t1945 + record_span!(parser, span_start1139, "Data") + return result1140 end function parse_edb(parser::ParserState)::Proto.EDB - span_start1143 = span_start(parser) + span_start1144 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "edb") - _t1955 = parse_relation_id(parser) - relation_id1140 = _t1955 - _t1956 = parse_edb_path(parser) - edb_path1141 = _t1956 - _t1957 = parse_edb_types(parser) - edb_types1142 = _t1957 + _t1957 = parse_relation_id(parser) + relation_id1141 = _t1957 + _t1958 = parse_edb_path(parser) + edb_path1142 = _t1958 + _t1959 = parse_edb_types(parser) + edb_types1143 = _t1959 consume_literal!(parser, ")") - _t1958 = Proto.EDB(target_id=relation_id1140, path=edb_path1141, types=edb_types1142) - result1144 = _t1958 - record_span!(parser, span_start1143, "EDB") - return result1144 + _t1960 = Proto.EDB(target_id=relation_id1141, path=edb_path1142, types=edb_types1143) + result1145 = _t1960 + record_span!(parser, span_start1144, "EDB") + return result1145 end function parse_edb_path(parser::ParserState)::Vector{String} consume_literal!(parser, "[") - xs1145 = String[] - cond1146 = match_lookahead_terminal(parser, "STRING", 0) - while cond1146 - item1147 = consume_terminal!(parser, "STRING") - push!(xs1145, item1147) - cond1146 = match_lookahead_terminal(parser, "STRING", 0) + xs1146 = String[] + cond1147 = match_lookahead_terminal(parser, "STRING", 0) + while cond1147 + item1148 = consume_terminal!(parser, "STRING") + push!(xs1146, item1148) + cond1147 = match_lookahead_terminal(parser, "STRING", 0) end - strings1148 = xs1145 + strings1149 = xs1146 consume_literal!(parser, "]") - return strings1148 + return strings1149 end function parse_edb_types(parser::ParserState)::Vector{Proto.var"#Type"} consume_literal!(parser, "[") - xs1149 = Proto.var"#Type"[] - cond1150 = (((((((((((((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 cond1150 - _t1959 = parse_type(parser) - item1151 = _t1959 - push!(xs1149, item1151) - cond1150 = (((((((((((((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)) + xs1150 = Proto.var"#Type"[] + cond1151 = (((((((((((((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 cond1151 + _t1961 = parse_type(parser) + item1152 = _t1961 + push!(xs1150, item1152) + cond1151 = (((((((((((((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 - types1152 = xs1149 + types1153 = xs1150 consume_literal!(parser, "]") - return types1152 + return types1153 end function parse_betree_relation(parser::ParserState)::Proto.BeTreeRelation - span_start1155 = span_start(parser) + span_start1156 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "betree_relation") - _t1960 = parse_relation_id(parser) - relation_id1153 = _t1960 - _t1961 = parse_betree_info(parser) - betree_info1154 = _t1961 + _t1962 = parse_relation_id(parser) + relation_id1154 = _t1962 + _t1963 = parse_betree_info(parser) + betree_info1155 = _t1963 consume_literal!(parser, ")") - _t1962 = Proto.BeTreeRelation(name=relation_id1153, relation_info=betree_info1154) - result1156 = _t1962 - record_span!(parser, span_start1155, "BeTreeRelation") - return result1156 + _t1964 = Proto.BeTreeRelation(name=relation_id1154, relation_info=betree_info1155) + result1157 = _t1964 + record_span!(parser, span_start1156, "BeTreeRelation") + return result1157 end function parse_betree_info(parser::ParserState)::Proto.BeTreeInfo - span_start1160 = span_start(parser) + span_start1161 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "betree_info") - _t1963 = parse_betree_info_key_types(parser) - betree_info_key_types1157 = _t1963 - _t1964 = parse_betree_info_value_types(parser) - betree_info_value_types1158 = _t1964 - _t1965 = parse_config_dict(parser) - config_dict1159 = _t1965 + _t1965 = parse_betree_info_key_types(parser) + betree_info_key_types1158 = _t1965 + _t1966 = parse_betree_info_value_types(parser) + betree_info_value_types1159 = _t1966 + _t1967 = parse_config_dict(parser) + config_dict1160 = _t1967 consume_literal!(parser, ")") - _t1966 = construct_betree_info(parser, betree_info_key_types1157, betree_info_value_types1158, config_dict1159) - result1161 = _t1966 - record_span!(parser, span_start1160, "BeTreeInfo") - return result1161 + _t1968 = construct_betree_info(parser, betree_info_key_types1158, betree_info_value_types1159, config_dict1160) + result1162 = _t1968 + record_span!(parser, span_start1161, "BeTreeInfo") + return result1162 end function parse_betree_info_key_types(parser::ParserState)::Vector{Proto.var"#Type"} consume_literal!(parser, "(") consume_literal!(parser, "key_types") - xs1162 = Proto.var"#Type"[] - cond1163 = (((((((((((((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 cond1163 - _t1967 = parse_type(parser) - item1164 = _t1967 - push!(xs1162, item1164) - cond1163 = (((((((((((((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)) + xs1163 = Proto.var"#Type"[] + cond1164 = (((((((((((((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 cond1164 + _t1969 = parse_type(parser) + item1165 = _t1969 + push!(xs1163, item1165) + cond1164 = (((((((((((((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 - types1165 = xs1162 + types1166 = xs1163 consume_literal!(parser, ")") - return types1165 + return types1166 end function parse_betree_info_value_types(parser::ParserState)::Vector{Proto.var"#Type"} consume_literal!(parser, "(") consume_literal!(parser, "value_types") - xs1166 = Proto.var"#Type"[] - cond1167 = (((((((((((((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 cond1167 - _t1968 = parse_type(parser) - item1168 = _t1968 - push!(xs1166, item1168) - cond1167 = (((((((((((((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)) + xs1167 = Proto.var"#Type"[] + cond1168 = (((((((((((((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 cond1168 + _t1970 = parse_type(parser) + item1169 = _t1970 + push!(xs1167, item1169) + cond1168 = (((((((((((((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 - types1169 = xs1166 + types1170 = xs1167 consume_literal!(parser, ")") - return types1169 + return types1170 end function parse_csv_data(parser::ParserState)::Proto.CSVData - span_start1174 = span_start(parser) + span_start1175 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "csv_data") - _t1969 = parse_csvlocator(parser) - csvlocator1170 = _t1969 - _t1970 = parse_csv_config(parser) - csv_config1171 = _t1970 - _t1971 = parse_gnf_columns(parser) - gnf_columns1172 = _t1971 - _t1972 = parse_csv_asof(parser) - csv_asof1173 = _t1972 + _t1971 = parse_csvlocator(parser) + csvlocator1171 = _t1971 + _t1972 = parse_csv_config(parser) + csv_config1172 = _t1972 + _t1973 = parse_gnf_columns(parser) + gnf_columns1173 = _t1973 + _t1974 = parse_csv_asof(parser) + csv_asof1174 = _t1974 consume_literal!(parser, ")") - _t1973 = Proto.CSVData(locator=csvlocator1170, config=csv_config1171, columns=gnf_columns1172, asof=csv_asof1173) - result1175 = _t1973 - record_span!(parser, span_start1174, "CSVData") - return result1175 + _t1975 = Proto.CSVData(locator=csvlocator1171, config=csv_config1172, columns=gnf_columns1173, asof=csv_asof1174) + result1176 = _t1975 + record_span!(parser, span_start1175, "CSVData") + return result1176 end function parse_csvlocator(parser::ParserState)::Proto.CSVLocator - span_start1178 = span_start(parser) + span_start1179 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "csv_locator") if (match_lookahead_literal(parser, "(", 0) && match_lookahead_literal(parser, "paths", 1)) - _t1975 = parse_csv_locator_paths(parser) - _t1974 = _t1975 + _t1977 = parse_csv_locator_paths(parser) + _t1976 = _t1977 else - _t1974 = nothing + _t1976 = nothing end - csv_locator_paths1176 = _t1974 + csv_locator_paths1177 = _t1976 if match_lookahead_literal(parser, "(", 0) - _t1977 = parse_csv_locator_inline_data(parser) - _t1976 = _t1977 + _t1979 = parse_csv_locator_inline_data(parser) + _t1978 = _t1979 else - _t1976 = nothing + _t1978 = nothing end - csv_locator_inline_data1177 = _t1976 + csv_locator_inline_data1178 = _t1978 consume_literal!(parser, ")") - _t1978 = Proto.CSVLocator(paths=(!isnothing(csv_locator_paths1176) ? csv_locator_paths1176 : String[]), inline_data=Vector{UInt8}((!isnothing(csv_locator_inline_data1177) ? csv_locator_inline_data1177 : ""))) - result1179 = _t1978 - record_span!(parser, span_start1178, "CSVLocator") - return result1179 + _t1980 = Proto.CSVLocator(paths=(!isnothing(csv_locator_paths1177) ? csv_locator_paths1177 : String[]), inline_data=Vector{UInt8}((!isnothing(csv_locator_inline_data1178) ? csv_locator_inline_data1178 : ""))) + result1180 = _t1980 + record_span!(parser, span_start1179, "CSVLocator") + return result1180 end function parse_csv_locator_paths(parser::ParserState)::Vector{String} consume_literal!(parser, "(") consume_literal!(parser, "paths") - xs1180 = String[] - cond1181 = match_lookahead_terminal(parser, "STRING", 0) - while cond1181 - item1182 = consume_terminal!(parser, "STRING") - push!(xs1180, item1182) - cond1181 = match_lookahead_terminal(parser, "STRING", 0) + xs1181 = String[] + cond1182 = match_lookahead_terminal(parser, "STRING", 0) + while cond1182 + item1183 = consume_terminal!(parser, "STRING") + push!(xs1181, item1183) + cond1182 = match_lookahead_terminal(parser, "STRING", 0) end - strings1183 = xs1180 + strings1184 = xs1181 consume_literal!(parser, ")") - return strings1183 + return strings1184 end function parse_csv_locator_inline_data(parser::ParserState)::String consume_literal!(parser, "(") consume_literal!(parser, "inline_data") - formatted_string1184 = consume_terminal!(parser, "STRING") + formatted_string1185 = consume_terminal!(parser, "STRING") consume_literal!(parser, ")") - return formatted_string1184 + return formatted_string1185 end function parse_csv_config(parser::ParserState)::Proto.CSVConfig - span_start1187 = span_start(parser) + span_start1188 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "csv_config") - _t1979 = parse_config_dict(parser) - config_dict1185 = _t1979 + _t1981 = parse_config_dict(parser) + config_dict1186 = _t1981 if match_lookahead_literal(parser, "(", 0) - _t1981 = parse__storage_integration(parser) - _t1980 = _t1981 + _t1983 = parse__storage_integration(parser) + _t1982 = _t1983 else - _t1980 = nothing + _t1982 = nothing end - _storage_integration1186 = _t1980 + _storage_integration1187 = _t1982 consume_literal!(parser, ")") - _t1982 = construct_csv_config(parser, config_dict1185, _storage_integration1186) - result1188 = _t1982 - record_span!(parser, span_start1187, "CSVConfig") - return result1188 + _t1984 = construct_csv_config(parser, config_dict1186, _storage_integration1187) + result1189 = _t1984 + record_span!(parser, span_start1188, "CSVConfig") + return result1189 end function parse__storage_integration(parser::ParserState)::Vector{Tuple{String, Proto.Value}} consume_literal!(parser, "(") consume_literal!(parser, "storage_integration") - _t1983 = parse_config_dict(parser) - config_dict1189 = _t1983 + _t1985 = parse_config_dict(parser) + config_dict1190 = _t1985 consume_literal!(parser, ")") - return config_dict1189 + return config_dict1190 end function parse_gnf_columns(parser::ParserState)::Vector{Proto.GNFColumn} consume_literal!(parser, "(") consume_literal!(parser, "columns") - xs1190 = Proto.GNFColumn[] - cond1191 = match_lookahead_literal(parser, "(", 0) - while cond1191 - _t1984 = parse_gnf_column(parser) - item1192 = _t1984 - push!(xs1190, item1192) - cond1191 = match_lookahead_literal(parser, "(", 0) + xs1191 = Proto.GNFColumn[] + cond1192 = match_lookahead_literal(parser, "(", 0) + while cond1192 + _t1986 = parse_gnf_column(parser) + item1193 = _t1986 + push!(xs1191, item1193) + cond1192 = match_lookahead_literal(parser, "(", 0) end - gnf_columns1193 = xs1190 + gnf_columns1194 = xs1191 consume_literal!(parser, ")") - return gnf_columns1193 + return gnf_columns1194 end function parse_gnf_column(parser::ParserState)::Proto.GNFColumn - span_start1200 = span_start(parser) + span_start1201 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "column") - _t1985 = parse_gnf_column_path(parser) - gnf_column_path1194 = _t1985 + _t1987 = parse_gnf_column_path(parser) + gnf_column_path1195 = _t1987 if (match_lookahead_literal(parser, ":", 0) || match_lookahead_terminal(parser, "UINT128", 0)) - _t1987 = parse_relation_id(parser) - _t1986 = _t1987 + _t1989 = parse_relation_id(parser) + _t1988 = _t1989 else - _t1986 = nothing + _t1988 = nothing end - relation_id1195 = _t1986 + relation_id1196 = _t1988 consume_literal!(parser, "[") - xs1196 = Proto.var"#Type"[] - cond1197 = (((((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "BOOLEAN", 0)) || match_lookahead_literal(parser, "DATE", 0)) || match_lookahead_literal(parser, "DATETIME", 0)) || match_lookahead_literal(parser, "FLOAT", 0)) || match_lookahead_literal(parser, "FLOAT32", 0)) || match_lookahead_literal(parser, "INT", 0)) || match_lookahead_literal(parser, "INT128", 0)) || match_lookahead_literal(parser, "INT32", 0)) || match_lookahead_literal(parser, "MISSING", 0)) || match_lookahead_literal(parser, "STRING", 0)) || match_lookahead_literal(parser, "UINT128", 0)) || match_lookahead_literal(parser, "UINT32", 0)) || match_lookahead_literal(parser, "UNKNOWN", 0)) - while cond1197 - _t1988 = parse_type(parser) - item1198 = _t1988 - push!(xs1196, item1198) - cond1197 = (((((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "BOOLEAN", 0)) || match_lookahead_literal(parser, "DATE", 0)) || match_lookahead_literal(parser, "DATETIME", 0)) || match_lookahead_literal(parser, "FLOAT", 0)) || match_lookahead_literal(parser, "FLOAT32", 0)) || match_lookahead_literal(parser, "INT", 0)) || match_lookahead_literal(parser, "INT128", 0)) || match_lookahead_literal(parser, "INT32", 0)) || match_lookahead_literal(parser, "MISSING", 0)) || match_lookahead_literal(parser, "STRING", 0)) || match_lookahead_literal(parser, "UINT128", 0)) || match_lookahead_literal(parser, "UINT32", 0)) || match_lookahead_literal(parser, "UNKNOWN", 0)) + xs1197 = Proto.var"#Type"[] + cond1198 = (((((((((((((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 cond1198 + _t1990 = parse_type(parser) + item1199 = _t1990 + push!(xs1197, item1199) + cond1198 = (((((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "BOOLEAN", 0)) || match_lookahead_literal(parser, "DATE", 0)) || match_lookahead_literal(parser, "DATETIME", 0)) || match_lookahead_literal(parser, "FLOAT", 0)) || match_lookahead_literal(parser, "FLOAT32", 0)) || match_lookahead_literal(parser, "INT", 0)) || match_lookahead_literal(parser, "INT128", 0)) || match_lookahead_literal(parser, "INT32", 0)) || match_lookahead_literal(parser, "MISSING", 0)) || match_lookahead_literal(parser, "STRING", 0)) || match_lookahead_literal(parser, "UINT128", 0)) || match_lookahead_literal(parser, "UINT32", 0)) || match_lookahead_literal(parser, "UNKNOWN", 0)) end - types1199 = xs1196 + types1200 = xs1197 consume_literal!(parser, "]") consume_literal!(parser, ")") - _t1989 = Proto.GNFColumn(column_path=gnf_column_path1194, target_id=relation_id1195, types=types1199) - result1201 = _t1989 - record_span!(parser, span_start1200, "GNFColumn") - return result1201 + _t1991 = Proto.GNFColumn(column_path=gnf_column_path1195, target_id=relation_id1196, types=types1200) + result1202 = _t1991 + record_span!(parser, span_start1201, "GNFColumn") + return result1202 end function parse_gnf_column_path(parser::ParserState)::Vector{String} if match_lookahead_literal(parser, "[", 0) - _t1990 = 1 + _t1992 = 1 else if match_lookahead_terminal(parser, "STRING", 0) - _t1991 = 0 + _t1993 = 0 else - _t1991 = -1 + _t1993 = -1 end - _t1990 = _t1991 + _t1992 = _t1993 end - prediction1202 = _t1990 - if prediction1202 == 1 + prediction1203 = _t1992 + if prediction1203 == 1 consume_literal!(parser, "[") - xs1204 = String[] - cond1205 = match_lookahead_terminal(parser, "STRING", 0) - while cond1205 - item1206 = consume_terminal!(parser, "STRING") - push!(xs1204, item1206) - cond1205 = match_lookahead_terminal(parser, "STRING", 0) + xs1205 = String[] + cond1206 = match_lookahead_terminal(parser, "STRING", 0) + while cond1206 + item1207 = consume_terminal!(parser, "STRING") + push!(xs1205, item1207) + cond1206 = match_lookahead_terminal(parser, "STRING", 0) end - strings1207 = xs1204 + strings1208 = xs1205 consume_literal!(parser, "]") - _t1992 = strings1207 + _t1994 = strings1208 else - if prediction1202 == 0 - string1203 = consume_terminal!(parser, "STRING") - _t1993 = String[string1203] + if prediction1203 == 0 + string1204 = consume_terminal!(parser, "STRING") + _t1995 = String[string1204] else throw(ParseError("Unexpected token in gnf_column_path" * ": " * string(lookahead(parser, 0)))) end - _t1992 = _t1993 + _t1994 = _t1995 end - return _t1992 + return _t1994 end function parse_csv_asof(parser::ParserState)::String consume_literal!(parser, "(") consume_literal!(parser, "asof") - string1208 = consume_terminal!(parser, "STRING") + string1209 = consume_terminal!(parser, "STRING") consume_literal!(parser, ")") - return string1208 + return string1209 end function parse_iceberg_data(parser::ParserState)::Proto.IcebergData - span_start1215 = span_start(parser) + span_start1216 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "iceberg_data") - _t1994 = parse_iceberg_locator(parser) - iceberg_locator1209 = _t1994 - _t1995 = parse_iceberg_catalog_config(parser) - iceberg_catalog_config1210 = _t1995 - _t1996 = parse_gnf_columns(parser) - gnf_columns1211 = _t1996 + _t1996 = parse_iceberg_locator(parser) + iceberg_locator1210 = _t1996 + _t1997 = parse_iceberg_catalog_config(parser) + iceberg_catalog_config1211 = _t1997 + _t1998 = parse_gnf_columns(parser) + gnf_columns1212 = _t1998 if (match_lookahead_literal(parser, "(", 0) && match_lookahead_literal(parser, "from_snapshot", 1)) - _t1998 = parse_iceberg_from_snapshot(parser) - _t1997 = _t1998 + _t2000 = parse_iceberg_from_snapshot(parser) + _t1999 = _t2000 else - _t1997 = nothing + _t1999 = nothing end - iceberg_from_snapshot1212 = _t1997 + iceberg_from_snapshot1213 = _t1999 if match_lookahead_literal(parser, "(", 0) - _t2000 = parse_iceberg_to_snapshot(parser) - _t1999 = _t2000 + _t2002 = parse_iceberg_to_snapshot(parser) + _t2001 = _t2002 else - _t1999 = nothing + _t2001 = nothing end - iceberg_to_snapshot1213 = _t1999 - _t2001 = parse_boolean_value(parser) - boolean_value1214 = _t2001 + iceberg_to_snapshot1214 = _t2001 + _t2003 = parse_boolean_value(parser) + boolean_value1215 = _t2003 consume_literal!(parser, ")") - _t2002 = construct_iceberg_data(parser, iceberg_locator1209, iceberg_catalog_config1210, gnf_columns1211, iceberg_from_snapshot1212, iceberg_to_snapshot1213, boolean_value1214) - result1216 = _t2002 - record_span!(parser, span_start1215, "IcebergData") - return result1216 + _t2004 = construct_iceberg_data(parser, iceberg_locator1210, iceberg_catalog_config1211, gnf_columns1212, iceberg_from_snapshot1213, iceberg_to_snapshot1214, boolean_value1215) + result1217 = _t2004 + record_span!(parser, span_start1216, "IcebergData") + return result1217 end function parse_iceberg_locator(parser::ParserState)::Proto.IcebergLocator - span_start1220 = span_start(parser) + span_start1221 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "iceberg_locator") - _t2003 = parse_iceberg_locator_table_name(parser) - iceberg_locator_table_name1217 = _t2003 - _t2004 = parse_iceberg_locator_namespace(parser) - iceberg_locator_namespace1218 = _t2004 - _t2005 = parse_iceberg_locator_warehouse(parser) - iceberg_locator_warehouse1219 = _t2005 + _t2005 = parse_iceberg_locator_table_name(parser) + iceberg_locator_table_name1218 = _t2005 + _t2006 = parse_iceberg_locator_namespace(parser) + iceberg_locator_namespace1219 = _t2006 + _t2007 = parse_iceberg_locator_warehouse(parser) + iceberg_locator_warehouse1220 = _t2007 consume_literal!(parser, ")") - _t2006 = Proto.IcebergLocator(table_name=iceberg_locator_table_name1217, namespace=iceberg_locator_namespace1218, warehouse=iceberg_locator_warehouse1219) - result1221 = _t2006 - record_span!(parser, span_start1220, "IcebergLocator") - return result1221 + _t2008 = Proto.IcebergLocator(table_name=iceberg_locator_table_name1218, namespace=iceberg_locator_namespace1219, warehouse=iceberg_locator_warehouse1220) + result1222 = _t2008 + record_span!(parser, span_start1221, "IcebergLocator") + return result1222 end function parse_iceberg_locator_table_name(parser::ParserState)::String consume_literal!(parser, "(") consume_literal!(parser, "table_name") - string1222 = consume_terminal!(parser, "STRING") + string1223 = consume_terminal!(parser, "STRING") consume_literal!(parser, ")") - return string1222 + return string1223 end function parse_iceberg_locator_namespace(parser::ParserState)::Vector{String} consume_literal!(parser, "(") consume_literal!(parser, "namespace") - xs1223 = String[] - cond1224 = match_lookahead_terminal(parser, "STRING", 0) - while cond1224 - item1225 = consume_terminal!(parser, "STRING") - push!(xs1223, item1225) - cond1224 = match_lookahead_terminal(parser, "STRING", 0) + xs1224 = String[] + cond1225 = match_lookahead_terminal(parser, "STRING", 0) + while cond1225 + item1226 = consume_terminal!(parser, "STRING") + push!(xs1224, item1226) + cond1225 = match_lookahead_terminal(parser, "STRING", 0) end - strings1226 = xs1223 + strings1227 = xs1224 consume_literal!(parser, ")") - return strings1226 + return strings1227 end function parse_iceberg_locator_warehouse(parser::ParserState)::String consume_literal!(parser, "(") consume_literal!(parser, "warehouse") - string1227 = consume_terminal!(parser, "STRING") + string1228 = consume_terminal!(parser, "STRING") consume_literal!(parser, ")") - return string1227 + return string1228 end function parse_iceberg_catalog_config(parser::ParserState)::Proto.IcebergCatalogConfig - span_start1232 = span_start(parser) + span_start1233 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "iceberg_catalog_config") - _t2007 = parse_iceberg_catalog_uri(parser) - iceberg_catalog_uri1228 = _t2007 + _t2009 = parse_iceberg_catalog_uri(parser) + iceberg_catalog_uri1229 = _t2009 if (match_lookahead_literal(parser, "(", 0) && match_lookahead_literal(parser, "scope", 1)) - _t2009 = parse_iceberg_catalog_config_scope(parser) - _t2008 = _t2009 + _t2011 = parse_iceberg_catalog_config_scope(parser) + _t2010 = _t2011 else - _t2008 = nothing + _t2010 = nothing end - iceberg_catalog_config_scope1229 = _t2008 - _t2010 = parse_iceberg_properties(parser) - iceberg_properties1230 = _t2010 - _t2011 = parse_iceberg_auth_properties(parser) - iceberg_auth_properties1231 = _t2011 + iceberg_catalog_config_scope1230 = _t2010 + _t2012 = parse_iceberg_properties(parser) + iceberg_properties1231 = _t2012 + _t2013 = parse_iceberg_auth_properties(parser) + iceberg_auth_properties1232 = _t2013 consume_literal!(parser, ")") - _t2012 = construct_iceberg_catalog_config(parser, iceberg_catalog_uri1228, iceberg_catalog_config_scope1229, iceberg_properties1230, iceberg_auth_properties1231) - result1233 = _t2012 - record_span!(parser, span_start1232, "IcebergCatalogConfig") - return result1233 + _t2014 = construct_iceberg_catalog_config(parser, iceberg_catalog_uri1229, iceberg_catalog_config_scope1230, iceberg_properties1231, iceberg_auth_properties1232) + result1234 = _t2014 + record_span!(parser, span_start1233, "IcebergCatalogConfig") + return result1234 end function parse_iceberg_catalog_uri(parser::ParserState)::String consume_literal!(parser, "(") consume_literal!(parser, "catalog_uri") - string1234 = consume_terminal!(parser, "STRING") + string1235 = consume_terminal!(parser, "STRING") consume_literal!(parser, ")") - return string1234 + return string1235 end function parse_iceberg_catalog_config_scope(parser::ParserState)::String consume_literal!(parser, "(") consume_literal!(parser, "scope") - string1235 = consume_terminal!(parser, "STRING") + string1236 = consume_terminal!(parser, "STRING") consume_literal!(parser, ")") - return string1235 + return string1236 end function parse_iceberg_properties(parser::ParserState)::Vector{Tuple{String, String}} consume_literal!(parser, "(") consume_literal!(parser, "properties") - xs1236 = Tuple{String, String}[] - cond1237 = match_lookahead_literal(parser, "(", 0) - while cond1237 - _t2013 = parse_iceberg_property_entry(parser) - item1238 = _t2013 - push!(xs1236, item1238) - cond1237 = match_lookahead_literal(parser, "(", 0) + xs1237 = Tuple{String, String}[] + cond1238 = match_lookahead_literal(parser, "(", 0) + while cond1238 + _t2015 = parse_iceberg_property_entry(parser) + item1239 = _t2015 + push!(xs1237, item1239) + cond1238 = match_lookahead_literal(parser, "(", 0) end - iceberg_property_entrys1239 = xs1236 + iceberg_property_entrys1240 = xs1237 consume_literal!(parser, ")") - return iceberg_property_entrys1239 + return iceberg_property_entrys1240 end function parse_iceberg_property_entry(parser::ParserState)::Tuple{String, String} consume_literal!(parser, "(") consume_literal!(parser, "prop") - string1240 = consume_terminal!(parser, "STRING") - string_31241 = consume_terminal!(parser, "STRING") + string1241 = consume_terminal!(parser, "STRING") + string_31242 = consume_terminal!(parser, "STRING") consume_literal!(parser, ")") - return (string1240, string_31241,) + return (string1241, string_31242,) end function parse_iceberg_auth_properties(parser::ParserState)::Vector{Tuple{String, String}} consume_literal!(parser, "(") consume_literal!(parser, "auth_properties") - xs1242 = Tuple{String, String}[] - cond1243 = match_lookahead_literal(parser, "(", 0) - while cond1243 - _t2014 = parse_iceberg_masked_property_entry(parser) - item1244 = _t2014 - push!(xs1242, item1244) - cond1243 = match_lookahead_literal(parser, "(", 0) + xs1243 = Tuple{String, String}[] + cond1244 = match_lookahead_literal(parser, "(", 0) + while cond1244 + _t2016 = parse_iceberg_masked_property_entry(parser) + item1245 = _t2016 + push!(xs1243, item1245) + cond1244 = match_lookahead_literal(parser, "(", 0) end - iceberg_masked_property_entrys1245 = xs1242 + iceberg_masked_property_entrys1246 = xs1243 consume_literal!(parser, ")") - return iceberg_masked_property_entrys1245 + return iceberg_masked_property_entrys1246 end function parse_iceberg_masked_property_entry(parser::ParserState)::Tuple{String, String} consume_literal!(parser, "(") consume_literal!(parser, "prop") - string1246 = consume_terminal!(parser, "STRING") - string_31247 = consume_terminal!(parser, "STRING") + string1247 = consume_terminal!(parser, "STRING") + string_31248 = consume_terminal!(parser, "STRING") consume_literal!(parser, ")") - return (string1246, string_31247,) + return (string1247, string_31248,) end function parse_iceberg_from_snapshot(parser::ParserState)::String consume_literal!(parser, "(") consume_literal!(parser, "from_snapshot") - string1248 = consume_terminal!(parser, "STRING") + string1249 = consume_terminal!(parser, "STRING") consume_literal!(parser, ")") - return string1248 + return string1249 end function parse_iceberg_to_snapshot(parser::ParserState)::String consume_literal!(parser, "(") consume_literal!(parser, "to_snapshot") - string1249 = consume_terminal!(parser, "STRING") + string1250 = consume_terminal!(parser, "STRING") consume_literal!(parser, ")") - return string1249 + return string1250 end function parse_undefine(parser::ParserState)::Proto.Undefine - span_start1251 = span_start(parser) + span_start1252 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "undefine") - _t2015 = parse_fragment_id(parser) - fragment_id1250 = _t2015 + _t2017 = parse_fragment_id(parser) + fragment_id1251 = _t2017 consume_literal!(parser, ")") - _t2016 = Proto.Undefine(fragment_id=fragment_id1250) - result1252 = _t2016 - record_span!(parser, span_start1251, "Undefine") - return result1252 + _t2018 = Proto.Undefine(fragment_id=fragment_id1251) + result1253 = _t2018 + record_span!(parser, span_start1252, "Undefine") + return result1253 end function parse_context(parser::ParserState)::Proto.Context - span_start1257 = span_start(parser) + span_start1258 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "context") - xs1253 = Proto.RelationId[] - cond1254 = (match_lookahead_literal(parser, ":", 0) || match_lookahead_terminal(parser, "UINT128", 0)) - while cond1254 - _t2017 = parse_relation_id(parser) - item1255 = _t2017 - push!(xs1253, item1255) - cond1254 = (match_lookahead_literal(parser, ":", 0) || match_lookahead_terminal(parser, "UINT128", 0)) + xs1254 = Proto.RelationId[] + cond1255 = (match_lookahead_literal(parser, ":", 0) || match_lookahead_terminal(parser, "UINT128", 0)) + while cond1255 + _t2019 = parse_relation_id(parser) + item1256 = _t2019 + push!(xs1254, item1256) + cond1255 = (match_lookahead_literal(parser, ":", 0) || match_lookahead_terminal(parser, "UINT128", 0)) end - relation_ids1256 = xs1253 + relation_ids1257 = xs1254 consume_literal!(parser, ")") - _t2018 = Proto.Context(relations=relation_ids1256) - result1258 = _t2018 - record_span!(parser, span_start1257, "Context") - return result1258 + _t2020 = Proto.Context(relations=relation_ids1257) + result1259 = _t2020 + record_span!(parser, span_start1258, "Context") + return result1259 end function parse_snapshot(parser::ParserState)::Proto.Snapshot - span_start1264 = span_start(parser) + span_start1265 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "snapshot") - _t2019 = parse_edb_path(parser) - edb_path1259 = _t2019 - xs1260 = Proto.SnapshotMapping[] - cond1261 = match_lookahead_literal(parser, "[", 0) - while cond1261 - _t2020 = parse_snapshot_mapping(parser) - item1262 = _t2020 - push!(xs1260, item1262) - cond1261 = match_lookahead_literal(parser, "[", 0) + _t2021 = parse_edb_path(parser) + edb_path1260 = _t2021 + xs1261 = Proto.SnapshotMapping[] + cond1262 = match_lookahead_literal(parser, "[", 0) + while cond1262 + _t2022 = parse_snapshot_mapping(parser) + item1263 = _t2022 + push!(xs1261, item1263) + cond1262 = match_lookahead_literal(parser, "[", 0) end - snapshot_mappings1263 = xs1260 + snapshot_mappings1264 = xs1261 consume_literal!(parser, ")") - _t2021 = Proto.Snapshot(mappings=snapshot_mappings1263, prefix=edb_path1259) - result1265 = _t2021 - record_span!(parser, span_start1264, "Snapshot") - return result1265 + _t2023 = Proto.Snapshot(mappings=snapshot_mappings1264, prefix=edb_path1260) + result1266 = _t2023 + record_span!(parser, span_start1265, "Snapshot") + return result1266 end function parse_snapshot_mapping(parser::ParserState)::Proto.SnapshotMapping - span_start1268 = span_start(parser) - _t2022 = parse_edb_path(parser) - edb_path1266 = _t2022 - _t2023 = parse_relation_id(parser) - relation_id1267 = _t2023 - _t2024 = Proto.SnapshotMapping(destination_path=edb_path1266, source_relation=relation_id1267) - result1269 = _t2024 - record_span!(parser, span_start1268, "SnapshotMapping") - return result1269 + span_start1269 = span_start(parser) + _t2024 = parse_edb_path(parser) + edb_path1267 = _t2024 + _t2025 = parse_relation_id(parser) + relation_id1268 = _t2025 + _t2026 = Proto.SnapshotMapping(destination_path=edb_path1267, source_relation=relation_id1268) + result1270 = _t2026 + record_span!(parser, span_start1269, "SnapshotMapping") + return result1270 end function parse_epoch_reads(parser::ParserState)::Vector{Proto.Read} consume_literal!(parser, "(") consume_literal!(parser, "reads") - xs1270 = Proto.Read[] - cond1271 = match_lookahead_literal(parser, "(", 0) - while cond1271 - _t2025 = parse_read(parser) - item1272 = _t2025 - push!(xs1270, item1272) - cond1271 = match_lookahead_literal(parser, "(", 0) + xs1271 = Proto.Read[] + cond1272 = match_lookahead_literal(parser, "(", 0) + while cond1272 + _t2027 = parse_read(parser) + item1273 = _t2027 + push!(xs1271, item1273) + cond1272 = match_lookahead_literal(parser, "(", 0) end - reads1273 = xs1270 + reads1274 = xs1271 consume_literal!(parser, ")") - return reads1273 + return reads1274 end function parse_read(parser::ParserState)::Proto.Read - span_start1281 = span_start(parser) + span_start1282 = span_start(parser) if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "what_if", 1) - _t2027 = 2 + _t2029 = 2 else if match_lookahead_literal(parser, "output", 1) - _t2028 = 1 + _t2030 = 1 else if match_lookahead_literal(parser, "export_output", 1) - _t2029 = 5 + _t2031 = 5 else if match_lookahead_literal(parser, "export_iceberg", 1) - _t2030 = 4 + _t2032 = 4 else if match_lookahead_literal(parser, "export", 1) - _t2031 = 4 + _t2033 = 4 else if match_lookahead_literal(parser, "demand", 1) - _t2032 = 0 + _t2034 = 0 else if match_lookahead_literal(parser, "abort", 1) - _t2033 = 3 + _t2035 = 3 else - _t2033 = -1 + _t2035 = -1 end - _t2032 = _t2033 + _t2034 = _t2035 end - _t2031 = _t2032 + _t2033 = _t2034 end - _t2030 = _t2031 + _t2032 = _t2033 end - _t2029 = _t2030 + _t2031 = _t2032 end - _t2028 = _t2029 + _t2030 = _t2031 end - _t2027 = _t2028 + _t2029 = _t2030 end - _t2026 = _t2027 + _t2028 = _t2029 else - _t2026 = -1 + _t2028 = -1 end - prediction1274 = _t2026 - if prediction1274 == 5 - _t2035 = parse_export_output(parser) - export_output1280 = _t2035 - _t2036 = Proto.Read(read_type=OneOf(:export_output, export_output1280)) - _t2034 = _t2036 + prediction1275 = _t2028 + if prediction1275 == 5 + _t2037 = parse_export_output(parser) + export_output1281 = _t2037 + _t2038 = Proto.Read(read_type=OneOf(:export_output, export_output1281)) + _t2036 = _t2038 else - if prediction1274 == 4 - _t2038 = parse_export(parser) - export1279 = _t2038 - _t2039 = Proto.Read(read_type=OneOf(:var"#export", export1279)) - _t2037 = _t2039 + if prediction1275 == 4 + _t2040 = parse_export(parser) + export1280 = _t2040 + _t2041 = Proto.Read(read_type=OneOf(:var"#export", export1280)) + _t2039 = _t2041 else - if prediction1274 == 3 - _t2041 = parse_abort(parser) - abort1278 = _t2041 - _t2042 = Proto.Read(read_type=OneOf(:abort, abort1278)) - _t2040 = _t2042 + if prediction1275 == 3 + _t2043 = parse_abort(parser) + abort1279 = _t2043 + _t2044 = Proto.Read(read_type=OneOf(:abort, abort1279)) + _t2042 = _t2044 else - if prediction1274 == 2 - _t2044 = parse_what_if(parser) - what_if1277 = _t2044 - _t2045 = Proto.Read(read_type=OneOf(:what_if, what_if1277)) - _t2043 = _t2045 + if prediction1275 == 2 + _t2046 = parse_what_if(parser) + what_if1278 = _t2046 + _t2047 = Proto.Read(read_type=OneOf(:what_if, what_if1278)) + _t2045 = _t2047 else - if prediction1274 == 1 - _t2047 = parse_output(parser) - output1276 = _t2047 - _t2048 = Proto.Read(read_type=OneOf(:output, output1276)) - _t2046 = _t2048 + if prediction1275 == 1 + _t2049 = parse_output(parser) + output1277 = _t2049 + _t2050 = Proto.Read(read_type=OneOf(:output, output1277)) + _t2048 = _t2050 else - if prediction1274 == 0 - _t2050 = parse_demand(parser) - demand1275 = _t2050 - _t2051 = Proto.Read(read_type=OneOf(:demand, demand1275)) - _t2049 = _t2051 + if prediction1275 == 0 + _t2052 = parse_demand(parser) + demand1276 = _t2052 + _t2053 = Proto.Read(read_type=OneOf(:demand, demand1276)) + _t2051 = _t2053 else throw(ParseError("Unexpected token in read" * ": " * string(lookahead(parser, 0)))) end - _t2046 = _t2049 + _t2048 = _t2051 end - _t2043 = _t2046 + _t2045 = _t2048 end - _t2040 = _t2043 + _t2042 = _t2045 end - _t2037 = _t2040 + _t2039 = _t2042 end - _t2034 = _t2037 + _t2036 = _t2039 end - result1282 = _t2034 - record_span!(parser, span_start1281, "Read") - return result1282 + result1283 = _t2036 + record_span!(parser, span_start1282, "Read") + return result1283 end function parse_demand(parser::ParserState)::Proto.Demand - span_start1284 = span_start(parser) + span_start1285 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "demand") - _t2052 = parse_relation_id(parser) - relation_id1283 = _t2052 + _t2054 = parse_relation_id(parser) + relation_id1284 = _t2054 consume_literal!(parser, ")") - _t2053 = Proto.Demand(relation_id=relation_id1283) - result1285 = _t2053 - record_span!(parser, span_start1284, "Demand") - return result1285 + _t2055 = Proto.Demand(relation_id=relation_id1284) + result1286 = _t2055 + record_span!(parser, span_start1285, "Demand") + return result1286 end function parse_output(parser::ParserState)::Proto.Output - span_start1288 = span_start(parser) + span_start1289 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "output") - _t2054 = parse_name(parser) - name1286 = _t2054 - _t2055 = parse_relation_id(parser) - relation_id1287 = _t2055 + _t2056 = parse_name(parser) + name1287 = _t2056 + _t2057 = parse_relation_id(parser) + relation_id1288 = _t2057 consume_literal!(parser, ")") - _t2056 = Proto.Output(name=name1286, relation_id=relation_id1287) - result1289 = _t2056 - record_span!(parser, span_start1288, "Output") - return result1289 + _t2058 = Proto.Output(name=name1287, relation_id=relation_id1288) + result1290 = _t2058 + record_span!(parser, span_start1289, "Output") + return result1290 end function parse_what_if(parser::ParserState)::Proto.WhatIf - span_start1292 = span_start(parser) + span_start1293 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "what_if") - _t2057 = parse_name(parser) - name1290 = _t2057 - _t2058 = parse_epoch(parser) - epoch1291 = _t2058 + _t2059 = parse_name(parser) + name1291 = _t2059 + _t2060 = parse_epoch(parser) + epoch1292 = _t2060 consume_literal!(parser, ")") - _t2059 = Proto.WhatIf(branch=name1290, epoch=epoch1291) - result1293 = _t2059 - record_span!(parser, span_start1292, "WhatIf") - return result1293 + _t2061 = Proto.WhatIf(branch=name1291, epoch=epoch1292) + result1294 = _t2061 + record_span!(parser, span_start1293, "WhatIf") + return result1294 end function parse_abort(parser::ParserState)::Proto.Abort - span_start1296 = span_start(parser) + span_start1297 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "abort") if (match_lookahead_literal(parser, ":", 0) && match_lookahead_terminal(parser, "SYMBOL", 1)) - _t2061 = parse_name(parser) - _t2060 = _t2061 + _t2063 = parse_name(parser) + _t2062 = _t2063 else - _t2060 = nothing + _t2062 = nothing end - name1294 = _t2060 - _t2062 = parse_relation_id(parser) - relation_id1295 = _t2062 + name1295 = _t2062 + _t2064 = parse_relation_id(parser) + relation_id1296 = _t2064 consume_literal!(parser, ")") - _t2063 = Proto.Abort(name=(!isnothing(name1294) ? name1294 : "abort"), relation_id=relation_id1295) - result1297 = _t2063 - record_span!(parser, span_start1296, "Abort") - return result1297 + _t2065 = Proto.Abort(name=(!isnothing(name1295) ? name1295 : "abort"), relation_id=relation_id1296) + result1298 = _t2065 + record_span!(parser, span_start1297, "Abort") + return result1298 end function parse_export(parser::ParserState)::Proto.Export - span_start1301 = span_start(parser) + span_start1302 = span_start(parser) if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "export_iceberg", 1) - _t2065 = 1 + _t2067 = 1 else if match_lookahead_literal(parser, "export", 1) - _t2066 = 0 + _t2068 = 0 else - _t2066 = -1 + _t2068 = -1 end - _t2065 = _t2066 + _t2067 = _t2068 end - _t2064 = _t2065 + _t2066 = _t2067 else - _t2064 = -1 + _t2066 = -1 end - prediction1298 = _t2064 - if prediction1298 == 1 + prediction1299 = _t2066 + if prediction1299 == 1 consume_literal!(parser, "(") consume_literal!(parser, "export_iceberg") - _t2068 = parse_export_iceberg_config(parser) - export_iceberg_config1300 = _t2068 + _t2070 = parse_export_iceberg_config(parser) + export_iceberg_config1301 = _t2070 consume_literal!(parser, ")") - _t2069 = Proto.Export(export_config=OneOf(:iceberg_config, export_iceberg_config1300)) - _t2067 = _t2069 + _t2071 = Proto.Export(export_config=OneOf(:iceberg_config, export_iceberg_config1301)) + _t2069 = _t2071 else - if prediction1298 == 0 + if prediction1299 == 0 consume_literal!(parser, "(") consume_literal!(parser, "export") - _t2071 = parse_export_csv_config(parser) - export_csv_config1299 = _t2071 + _t2073 = parse_export_csv_config(parser) + export_csv_config1300 = _t2073 consume_literal!(parser, ")") - _t2072 = Proto.Export(export_config=OneOf(:csv_config, export_csv_config1299)) - _t2070 = _t2072 + _t2074 = Proto.Export(export_config=OneOf(:csv_config, export_csv_config1300)) + _t2072 = _t2074 else throw(ParseError("Unexpected token in export" * ": " * string(lookahead(parser, 0)))) end - _t2067 = _t2070 + _t2069 = _t2072 end - result1302 = _t2067 - record_span!(parser, span_start1301, "Export") - return result1302 + result1303 = _t2069 + record_span!(parser, span_start1302, "Export") + return result1303 end function parse_export_csv_config(parser::ParserState)::Proto.ExportCSVConfig - span_start1310 = span_start(parser) + span_start1311 = span_start(parser) if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "export_csv_config_v2", 1) - _t2074 = 0 + _t2076 = 0 else if match_lookahead_literal(parser, "export_csv_config", 1) - _t2075 = 1 + _t2077 = 1 else - _t2075 = -1 + _t2077 = -1 end - _t2074 = _t2075 + _t2076 = _t2077 end - _t2073 = _t2074 + _t2075 = _t2076 else - _t2073 = -1 + _t2075 = -1 end - prediction1303 = _t2073 - if prediction1303 == 1 + prediction1304 = _t2075 + if prediction1304 == 1 consume_literal!(parser, "(") consume_literal!(parser, "export_csv_config") - _t2077 = parse_export_csv_path(parser) - export_csv_path1307 = _t2077 - _t2078 = parse_export_csv_columns_list(parser) - export_csv_columns_list1308 = _t2078 - _t2079 = parse_config_dict(parser) - config_dict1309 = _t2079 + _t2079 = parse_export_csv_path(parser) + export_csv_path1308 = _t2079 + _t2080 = parse_export_csv_columns_list(parser) + export_csv_columns_list1309 = _t2080 + _t2081 = parse_config_dict(parser) + config_dict1310 = _t2081 consume_literal!(parser, ")") - _t2080 = construct_export_csv_config(parser, export_csv_path1307, export_csv_columns_list1308, config_dict1309) - _t2076 = _t2080 + _t2082 = construct_export_csv_config(parser, export_csv_path1308, export_csv_columns_list1309, config_dict1310) + _t2078 = _t2082 else - if prediction1303 == 0 + if prediction1304 == 0 consume_literal!(parser, "(") consume_literal!(parser, "export_csv_config_v2") - _t2082 = parse_export_csv_path(parser) - export_csv_path1304 = _t2082 - _t2083 = parse_export_csv_source(parser) - export_csv_source1305 = _t2083 - _t2084 = parse_csv_config(parser) - csv_config1306 = _t2084 + _t2084 = parse_export_csv_path(parser) + export_csv_path1305 = _t2084 + _t2085 = parse_export_csv_source(parser) + export_csv_source1306 = _t2085 + _t2086 = parse_csv_config(parser) + csv_config1307 = _t2086 consume_literal!(parser, ")") - _t2085 = construct_export_csv_config_with_source(parser, export_csv_path1304, export_csv_source1305, csv_config1306) - _t2081 = _t2085 + _t2087 = construct_export_csv_config_with_source(parser, export_csv_path1305, export_csv_source1306, csv_config1307) + _t2083 = _t2087 else throw(ParseError("Unexpected token in export_csv_config" * ": " * string(lookahead(parser, 0)))) end - _t2076 = _t2081 + _t2078 = _t2083 end - result1311 = _t2076 - record_span!(parser, span_start1310, "ExportCSVConfig") - return result1311 + result1312 = _t2078 + record_span!(parser, span_start1311, "ExportCSVConfig") + return result1312 end function parse_export_csv_path(parser::ParserState)::String consume_literal!(parser, "(") consume_literal!(parser, "path") - string1312 = consume_terminal!(parser, "STRING") + string1313 = consume_terminal!(parser, "STRING") consume_literal!(parser, ")") - return string1312 + return string1313 end function parse_export_csv_source(parser::ParserState)::Proto.ExportCSVSource - span_start1319 = span_start(parser) + span_start1320 = span_start(parser) if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "table_def", 1) - _t2087 = 1 + _t2089 = 1 else if match_lookahead_literal(parser, "gnf_columns", 1) - _t2088 = 0 + _t2090 = 0 else - _t2088 = -1 + _t2090 = -1 end - _t2087 = _t2088 + _t2089 = _t2090 end - _t2086 = _t2087 + _t2088 = _t2089 else - _t2086 = -1 + _t2088 = -1 end - prediction1313 = _t2086 - if prediction1313 == 1 + prediction1314 = _t2088 + if prediction1314 == 1 consume_literal!(parser, "(") consume_literal!(parser, "table_def") - _t2090 = parse_relation_id(parser) - relation_id1318 = _t2090 + _t2092 = parse_relation_id(parser) + relation_id1319 = _t2092 consume_literal!(parser, ")") - _t2091 = Proto.ExportCSVSource(csv_source=OneOf(:table_def, relation_id1318)) - _t2089 = _t2091 + _t2093 = Proto.ExportCSVSource(csv_source=OneOf(:table_def, relation_id1319)) + _t2091 = _t2093 else - if prediction1313 == 0 + if prediction1314 == 0 consume_literal!(parser, "(") consume_literal!(parser, "gnf_columns") - xs1314 = Proto.ExportCSVColumn[] - cond1315 = match_lookahead_literal(parser, "(", 0) - while cond1315 - _t2093 = parse_export_csv_column(parser) - item1316 = _t2093 - push!(xs1314, item1316) - cond1315 = match_lookahead_literal(parser, "(", 0) + xs1315 = Proto.ExportCSVColumn[] + cond1316 = match_lookahead_literal(parser, "(", 0) + while cond1316 + _t2095 = parse_export_csv_column(parser) + item1317 = _t2095 + push!(xs1315, item1317) + cond1316 = match_lookahead_literal(parser, "(", 0) end - export_csv_columns1317 = xs1314 + export_csv_columns1318 = xs1315 consume_literal!(parser, ")") - _t2094 = Proto.ExportCSVColumns(columns=export_csv_columns1317) - _t2095 = Proto.ExportCSVSource(csv_source=OneOf(:gnf_columns, _t2094)) - _t2092 = _t2095 + _t2096 = Proto.ExportCSVColumns(columns=export_csv_columns1318) + _t2097 = Proto.ExportCSVSource(csv_source=OneOf(:gnf_columns, _t2096)) + _t2094 = _t2097 else throw(ParseError("Unexpected token in export_csv_source" * ": " * string(lookahead(parser, 0)))) end - _t2089 = _t2092 + _t2091 = _t2094 end - result1320 = _t2089 - record_span!(parser, span_start1319, "ExportCSVSource") - return result1320 + result1321 = _t2091 + record_span!(parser, span_start1320, "ExportCSVSource") + return result1321 end function parse_export_csv_column(parser::ParserState)::Proto.ExportCSVColumn - span_start1323 = span_start(parser) + span_start1324 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "column") - string1321 = consume_terminal!(parser, "STRING") - _t2096 = parse_relation_id(parser) - relation_id1322 = _t2096 + string1322 = consume_terminal!(parser, "STRING") + _t2098 = parse_relation_id(parser) + relation_id1323 = _t2098 consume_literal!(parser, ")") - _t2097 = Proto.ExportCSVColumn(column_name=string1321, column_data=relation_id1322) - result1324 = _t2097 - record_span!(parser, span_start1323, "ExportCSVColumn") - return result1324 + _t2099 = Proto.ExportCSVColumn(column_name=string1322, column_data=relation_id1323) + result1325 = _t2099 + record_span!(parser, span_start1324, "ExportCSVColumn") + return result1325 end function parse_export_csv_columns_list(parser::ParserState)::Vector{Proto.ExportCSVColumn} consume_literal!(parser, "(") consume_literal!(parser, "columns") - xs1325 = Proto.ExportCSVColumn[] - cond1326 = match_lookahead_literal(parser, "(", 0) - while cond1326 - _t2098 = parse_export_csv_column(parser) - item1327 = _t2098 - push!(xs1325, item1327) - cond1326 = match_lookahead_literal(parser, "(", 0) + xs1326 = Proto.ExportCSVColumn[] + cond1327 = match_lookahead_literal(parser, "(", 0) + while cond1327 + _t2100 = parse_export_csv_column(parser) + item1328 = _t2100 + push!(xs1326, item1328) + cond1327 = match_lookahead_literal(parser, "(", 0) end - export_csv_columns1328 = xs1325 + export_csv_columns1329 = xs1326 consume_literal!(parser, ")") - return export_csv_columns1328 + return export_csv_columns1329 end function parse_export_iceberg_config(parser::ParserState)::Proto.ExportIcebergConfig - span_start1334 = span_start(parser) + span_start1335 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "export_iceberg_config") - _t2099 = parse_iceberg_locator(parser) - iceberg_locator1329 = _t2099 - _t2100 = parse_iceberg_catalog_config(parser) - iceberg_catalog_config1330 = _t2100 - _t2101 = parse_export_iceberg_table_def(parser) - export_iceberg_table_def1331 = _t2101 - _t2102 = parse_iceberg_table_properties(parser) - iceberg_table_properties1332 = _t2102 + _t2101 = parse_iceberg_locator(parser) + iceberg_locator1330 = _t2101 + _t2102 = parse_iceberg_catalog_config(parser) + iceberg_catalog_config1331 = _t2102 + _t2103 = parse_export_iceberg_table_def(parser) + export_iceberg_table_def1332 = _t2103 + _t2104 = parse_iceberg_table_properties(parser) + iceberg_table_properties1333 = _t2104 if match_lookahead_literal(parser, "{", 0) - _t2104 = parse_config_dict(parser) - _t2103 = _t2104 + _t2106 = parse_config_dict(parser) + _t2105 = _t2106 else - _t2103 = nothing + _t2105 = nothing end - config_dict1333 = _t2103 + config_dict1334 = _t2105 consume_literal!(parser, ")") - _t2105 = construct_export_iceberg_config_full(parser, iceberg_locator1329, iceberg_catalog_config1330, export_iceberg_table_def1331, iceberg_table_properties1332, config_dict1333) - result1335 = _t2105 - record_span!(parser, span_start1334, "ExportIcebergConfig") - return result1335 + _t2107 = construct_export_iceberg_config_full(parser, iceberg_locator1330, iceberg_catalog_config1331, export_iceberg_table_def1332, iceberg_table_properties1333, config_dict1334) + result1336 = _t2107 + record_span!(parser, span_start1335, "ExportIcebergConfig") + return result1336 end function parse_export_iceberg_table_def(parser::ParserState)::Proto.RelationId - span_start1337 = span_start(parser) + span_start1338 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "table_def") - _t2106 = parse_relation_id(parser) - relation_id1336 = _t2106 + _t2108 = parse_relation_id(parser) + relation_id1337 = _t2108 consume_literal!(parser, ")") - result1338 = relation_id1336 - record_span!(parser, span_start1337, "RelationId") - return result1338 + result1339 = relation_id1337 + record_span!(parser, span_start1338, "RelationId") + return result1339 end function parse_iceberg_table_properties(parser::ParserState)::Vector{Tuple{String, String}} consume_literal!(parser, "(") consume_literal!(parser, "table_properties") - xs1339 = Tuple{String, String}[] - cond1340 = match_lookahead_literal(parser, "(", 0) - while cond1340 - _t2107 = parse_iceberg_property_entry(parser) - item1341 = _t2107 - push!(xs1339, item1341) - cond1340 = match_lookahead_literal(parser, "(", 0) + xs1340 = Tuple{String, String}[] + cond1341 = match_lookahead_literal(parser, "(", 0) + while cond1341 + _t2109 = parse_iceberg_property_entry(parser) + item1342 = _t2109 + push!(xs1340, item1342) + cond1341 = match_lookahead_literal(parser, "(", 0) end - iceberg_property_entrys1342 = xs1339 + iceberg_property_entrys1343 = xs1340 consume_literal!(parser, ")") - return iceberg_property_entrys1342 + return iceberg_property_entrys1343 end function parse_export_output(parser::ParserState)::Proto.ExportOutput - span_start1344 = span_start(parser) + span_start1346 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "export_output") - _t2108 = parse_export_csv_output(parser) - export_csv_output1343 = _t2108 + _t2110 = parse_name(parser) + name1344 = _t2110 + _t2111 = parse_export_csv_output(parser) + export_csv_output1345 = _t2111 consume_literal!(parser, ")") - _t2109 = Proto.ExportOutput(export_output=OneOf(:csv, export_csv_output1343)) - result1345 = _t2109 - record_span!(parser, span_start1344, "ExportOutput") - return result1345 + _t2112 = Proto.ExportOutput(export_output=OneOf(:csv, export_csv_output1345), name=name1344) + result1347 = _t2112 + record_span!(parser, span_start1346, "ExportOutput") + return result1347 end function parse_export_csv_output(parser::ParserState)::Proto.ExportCSVOutput - span_start1348 = span_start(parser) + span_start1350 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "csv") - _t2110 = parse_export_csv_source(parser) - export_csv_source1346 = _t2110 - _t2111 = parse_csv_config(parser) - csv_config1347 = _t2111 + _t2113 = parse_export_csv_source(parser) + export_csv_source1348 = _t2113 + _t2114 = parse_csv_config(parser) + csv_config1349 = _t2114 consume_literal!(parser, ")") - _t2112 = Proto.ExportCSVOutput(csv_source=export_csv_source1346, csv_config=csv_config1347) - result1349 = _t2112 - record_span!(parser, span_start1348, "ExportCSVOutput") - return result1349 + _t2115 = Proto.ExportCSVOutput(csv_source=export_csv_source1348, csv_config=csv_config1349) + result1351 = _t2115 + record_span!(parser, span_start1350, "ExportCSVOutput") + return result1351 end diff --git a/sdks/julia/LogicalQueryProtocol.jl/src/pretty.jl b/sdks/julia/LogicalQueryProtocol.jl/src/pretty.jl index ffce8b41..f790d03e 100644 --- a/sdks/julia/LogicalQueryProtocol.jl/src/pretty.jl +++ b/sdks/julia/LogicalQueryProtocol.jl/src/pretty.jl @@ -377,89 +377,89 @@ end # --- Helper functions --- function _make_value_int32(pp::PrettyPrinter, v::Int32)::Proto.Value - _t1803 = Proto.Value(value=OneOf(:int32_value, v)) - return _t1803 + _t1807 = Proto.Value(value=OneOf(:int32_value, v)) + return _t1807 end function _make_value_int64(pp::PrettyPrinter, v::Int64)::Proto.Value - _t1804 = Proto.Value(value=OneOf(:int_value, v)) - return _t1804 + _t1808 = Proto.Value(value=OneOf(:int_value, v)) + return _t1808 end function _make_value_float64(pp::PrettyPrinter, v::Float64)::Proto.Value - _t1805 = Proto.Value(value=OneOf(:float_value, v)) - return _t1805 + _t1809 = Proto.Value(value=OneOf(:float_value, v)) + return _t1809 end function _make_value_string(pp::PrettyPrinter, v::String)::Proto.Value - _t1806 = Proto.Value(value=OneOf(:string_value, v)) - return _t1806 + _t1810 = Proto.Value(value=OneOf(:string_value, v)) + return _t1810 end function _make_value_boolean(pp::PrettyPrinter, v::Bool)::Proto.Value - _t1807 = Proto.Value(value=OneOf(:boolean_value, v)) - return _t1807 + _t1811 = Proto.Value(value=OneOf(:boolean_value, v)) + return _t1811 end function _make_value_uint128(pp::PrettyPrinter, v::Proto.UInt128Value)::Proto.Value - _t1808 = Proto.Value(value=OneOf(:uint128_value, v)) - return _t1808 + _t1812 = Proto.Value(value=OneOf(:uint128_value, v)) + return _t1812 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 - _t1809 = _make_value_string(pp, "auto") - push!(result, ("ivm.maintenance_level", _t1809,)) + _t1813 = _make_value_string(pp, "auto") + push!(result, ("ivm.maintenance_level", _t1813,)) else if msg.ivm_config.level == Proto.MaintenanceLevel.MAINTENANCE_LEVEL_ALL - _t1810 = _make_value_string(pp, "all") - push!(result, ("ivm.maintenance_level", _t1810,)) + _t1814 = _make_value_string(pp, "all") + push!(result, ("ivm.maintenance_level", _t1814,)) else if msg.ivm_config.level == Proto.MaintenanceLevel.MAINTENANCE_LEVEL_OFF - _t1811 = _make_value_string(pp, "off") - push!(result, ("ivm.maintenance_level", _t1811,)) + _t1815 = _make_value_string(pp, "off") + push!(result, ("ivm.maintenance_level", _t1815,)) end end end - _t1812 = _make_value_int64(pp, msg.semantics_version) - push!(result, ("semantics_version", _t1812,)) + _t1816 = _make_value_int64(pp, msg.semantics_version) + push!(result, ("semantics_version", _t1816,)) return sort(result) end function deconstruct_csv_config(pp::PrettyPrinter, msg::Proto.CSVConfig)::Vector{Tuple{String, Proto.Value}} result = Tuple{String, Proto.Value}[] - _t1813 = _make_value_int32(pp, msg.header_row) - push!(result, ("csv_header_row", _t1813,)) - _t1814 = _make_value_int64(pp, msg.skip) - push!(result, ("csv_skip", _t1814,)) + _t1817 = _make_value_int32(pp, msg.header_row) + push!(result, ("csv_header_row", _t1817,)) + _t1818 = _make_value_int64(pp, msg.skip) + push!(result, ("csv_skip", _t1818,)) if msg.new_line != "" - _t1815 = _make_value_string(pp, msg.new_line) - push!(result, ("csv_new_line", _t1815,)) - end - _t1816 = _make_value_string(pp, msg.delimiter) - push!(result, ("csv_delimiter", _t1816,)) - _t1817 = _make_value_string(pp, msg.quotechar) - push!(result, ("csv_quotechar", _t1817,)) - _t1818 = _make_value_string(pp, msg.escapechar) - push!(result, ("csv_escapechar", _t1818,)) + _t1819 = _make_value_string(pp, msg.new_line) + push!(result, ("csv_new_line", _t1819,)) + end + _t1820 = _make_value_string(pp, msg.delimiter) + push!(result, ("csv_delimiter", _t1820,)) + _t1821 = _make_value_string(pp, msg.quotechar) + push!(result, ("csv_quotechar", _t1821,)) + _t1822 = _make_value_string(pp, msg.escapechar) + push!(result, ("csv_escapechar", _t1822,)) if msg.comment != "" - _t1819 = _make_value_string(pp, msg.comment) - push!(result, ("csv_comment", _t1819,)) + _t1823 = _make_value_string(pp, msg.comment) + push!(result, ("csv_comment", _t1823,)) end for missing_string in msg.missing_strings - _t1820 = _make_value_string(pp, missing_string) - push!(result, ("csv_missing_strings", _t1820,)) - end - _t1821 = _make_value_string(pp, msg.decimal_separator) - push!(result, ("csv_decimal_separator", _t1821,)) - _t1822 = _make_value_string(pp, msg.encoding) - push!(result, ("csv_encoding", _t1822,)) - _t1823 = _make_value_string(pp, msg.compression) - push!(result, ("csv_compression", _t1823,)) + _t1824 = _make_value_string(pp, missing_string) + push!(result, ("csv_missing_strings", _t1824,)) + end + _t1825 = _make_value_string(pp, msg.decimal_separator) + push!(result, ("csv_decimal_separator", _t1825,)) + _t1826 = _make_value_string(pp, msg.encoding) + push!(result, ("csv_encoding", _t1826,)) + _t1827 = _make_value_string(pp, msg.compression) + push!(result, ("csv_compression", _t1827,)) if msg.partition_size_mb != 0 - _t1824 = _make_value_int64(pp, msg.partition_size_mb) - push!(result, ("csv_partition_size_mb", _t1824,)) + _t1828 = _make_value_int64(pp, msg.partition_size_mb) + push!(result, ("csv_partition_size_mb", _t1828,)) end return sort(result) end @@ -468,91 +468,91 @@ function deconstruct_csv_storage_integration_optional(pp::PrettyPrinter, msg::Pr if !_has_proto_field(msg, Symbol("storage_integration")) return nothing else - _t1825 = nothing + _t1829 = nothing end si = msg.storage_integration result = Tuple{String, Proto.Value}[] if si.provider != "" - _t1826 = _make_value_string(pp, si.provider) - push!(result, ("provider", _t1826,)) + _t1830 = _make_value_string(pp, si.provider) + push!(result, ("provider", _t1830,)) end if si.azure_sas_token != "" - _t1827 = _make_value_string(pp, "***") - push!(result, ("azure_sas_token", _t1827,)) + _t1831 = _make_value_string(pp, "***") + push!(result, ("azure_sas_token", _t1831,)) end if si.s3_region != "" - _t1828 = _make_value_string(pp, si.s3_region) - push!(result, ("s3_region", _t1828,)) + _t1832 = _make_value_string(pp, si.s3_region) + push!(result, ("s3_region", _t1832,)) end if si.s3_access_key_id != "" - _t1829 = _make_value_string(pp, "***") - push!(result, ("s3_access_key_id", _t1829,)) + _t1833 = _make_value_string(pp, "***") + push!(result, ("s3_access_key_id", _t1833,)) end if si.s3_secret_access_key != "" - _t1830 = _make_value_string(pp, "***") - push!(result, ("s3_secret_access_key", _t1830,)) + _t1834 = _make_value_string(pp, "***") + push!(result, ("s3_secret_access_key", _t1834,)) 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}[] - _t1831 = _make_value_float64(pp, msg.storage_config.epsilon) - push!(result, ("betree_config_epsilon", _t1831,)) - _t1832 = _make_value_int64(pp, msg.storage_config.max_pivots) - push!(result, ("betree_config_max_pivots", _t1832,)) - _t1833 = _make_value_int64(pp, msg.storage_config.max_deltas) - push!(result, ("betree_config_max_deltas", _t1833,)) - _t1834 = _make_value_int64(pp, msg.storage_config.max_leaf) - push!(result, ("betree_config_max_leaf", _t1834,)) + _t1835 = _make_value_float64(pp, msg.storage_config.epsilon) + push!(result, ("betree_config_epsilon", _t1835,)) + _t1836 = _make_value_int64(pp, msg.storage_config.max_pivots) + push!(result, ("betree_config_max_pivots", _t1836,)) + _t1837 = _make_value_int64(pp, msg.storage_config.max_deltas) + push!(result, ("betree_config_max_deltas", _t1837,)) + _t1838 = _make_value_int64(pp, msg.storage_config.max_leaf) + push!(result, ("betree_config_max_leaf", _t1838,)) if _has_proto_field(msg.relation_locator, Symbol("root_pageid")) if !isnothing(_get_oneof_field(msg.relation_locator, :root_pageid)) - _t1835 = _make_value_uint128(pp, _get_oneof_field(msg.relation_locator, :root_pageid)) - push!(result, ("betree_locator_root_pageid", _t1835,)) + _t1839 = _make_value_uint128(pp, _get_oneof_field(msg.relation_locator, :root_pageid)) + push!(result, ("betree_locator_root_pageid", _t1839,)) end end if _has_proto_field(msg.relation_locator, Symbol("inline_data")) if !isnothing(_get_oneof_field(msg.relation_locator, :inline_data)) - _t1836 = _make_value_string(pp, String(copy(_get_oneof_field(msg.relation_locator, :inline_data)))) - push!(result, ("betree_locator_inline_data", _t1836,)) + _t1840 = _make_value_string(pp, String(copy(_get_oneof_field(msg.relation_locator, :inline_data)))) + push!(result, ("betree_locator_inline_data", _t1840,)) end end - _t1837 = _make_value_int64(pp, msg.relation_locator.element_count) - push!(result, ("betree_locator_element_count", _t1837,)) - _t1838 = _make_value_int64(pp, msg.relation_locator.tree_height) - push!(result, ("betree_locator_tree_height", _t1838,)) + _t1841 = _make_value_int64(pp, msg.relation_locator.element_count) + push!(result, ("betree_locator_element_count", _t1841,)) + _t1842 = _make_value_int64(pp, msg.relation_locator.tree_height) + push!(result, ("betree_locator_tree_height", _t1842,)) 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) - _t1839 = _make_value_int64(pp, msg.partition_size) - push!(result, ("partition_size", _t1839,)) + _t1843 = _make_value_int64(pp, msg.partition_size) + push!(result, ("partition_size", _t1843,)) end if !isnothing(msg.compression) - _t1840 = _make_value_string(pp, msg.compression) - push!(result, ("compression", _t1840,)) + _t1844 = _make_value_string(pp, msg.compression) + push!(result, ("compression", _t1844,)) end if !isnothing(msg.syntax_header_row) - _t1841 = _make_value_boolean(pp, msg.syntax_header_row) - push!(result, ("syntax_header_row", _t1841,)) + _t1845 = _make_value_boolean(pp, msg.syntax_header_row) + push!(result, ("syntax_header_row", _t1845,)) end if !isnothing(msg.syntax_missing_string) - _t1842 = _make_value_string(pp, msg.syntax_missing_string) - push!(result, ("syntax_missing_string", _t1842,)) + _t1846 = _make_value_string(pp, msg.syntax_missing_string) + push!(result, ("syntax_missing_string", _t1846,)) end if !isnothing(msg.syntax_delim) - _t1843 = _make_value_string(pp, msg.syntax_delim) - push!(result, ("syntax_delim", _t1843,)) + _t1847 = _make_value_string(pp, msg.syntax_delim) + push!(result, ("syntax_delim", _t1847,)) end if !isnothing(msg.syntax_quotechar) - _t1844 = _make_value_string(pp, msg.syntax_quotechar) - push!(result, ("syntax_quotechar", _t1844,)) + _t1848 = _make_value_string(pp, msg.syntax_quotechar) + push!(result, ("syntax_quotechar", _t1848,)) end if !isnothing(msg.syntax_escapechar) - _t1845 = _make_value_string(pp, msg.syntax_escapechar) - push!(result, ("syntax_escapechar", _t1845,)) + _t1849 = _make_value_string(pp, msg.syntax_escapechar) + push!(result, ("syntax_escapechar", _t1849,)) end return sort(result) end @@ -565,7 +565,7 @@ function deconstruct_iceberg_catalog_config_scope_optional(pp::PrettyPrinter, ms if msg.scope != "" return msg.scope else - _t1846 = nothing + _t1850 = nothing end return nothing end @@ -574,7 +574,7 @@ function deconstruct_iceberg_data_from_snapshot_optional(pp::PrettyPrinter, msg: if msg.from_snapshot != "" return msg.from_snapshot else - _t1847 = nothing + _t1851 = nothing end return nothing end @@ -583,7 +583,7 @@ function deconstruct_iceberg_data_to_snapshot_optional(pp::PrettyPrinter, msg::P if msg.to_snapshot != "" return msg.to_snapshot else - _t1848 = nothing + _t1852 = nothing end return nothing end @@ -591,21 +591,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 != "" - _t1849 = _make_value_string(pp, msg.prefix) - push!(result, ("prefix", _t1849,)) + _t1853 = _make_value_string(pp, msg.prefix) + push!(result, ("prefix", _t1853,)) end if msg.target_file_size_bytes != 0 - _t1850 = _make_value_int64(pp, msg.target_file_size_bytes) - push!(result, ("target_file_size_bytes", _t1850,)) + _t1854 = _make_value_int64(pp, msg.target_file_size_bytes) + push!(result, ("target_file_size_bytes", _t1854,)) end if msg.compression != "" - _t1851 = _make_value_string(pp, msg.compression) - push!(result, ("compression", _t1851,)) + _t1855 = _make_value_string(pp, msg.compression) + push!(result, ("compression", _t1855,)) end if length(result) == 0 return nothing else - _t1852 = nothing + _t1856 = nothing end return sort(result) end @@ -620,7 +620,7 @@ function deconstruct_relation_id_uint128(pp::PrettyPrinter, msg::Proto.RelationI if isnothing(name) return relation_id_to_uint128(pp, msg) else - _t1853 = nothing + _t1857 = nothing end return nothing end @@ -639,47 +639,47 @@ end # --- Pretty-print functions --- function pretty_transaction(pp::PrettyPrinter, msg::Proto.Transaction) - flat818 = try_flat(pp, msg, pretty_transaction) - if !isnothing(flat818) - write(pp, flat818) + flat820 = try_flat(pp, msg, pretty_transaction) + if !isnothing(flat820) + write(pp, flat820) return nothing else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("configure")) - _t1618 = _dollar_dollar.configure + _t1622 = _dollar_dollar.configure else - _t1618 = nothing + _t1622 = nothing end if _has_proto_field(_dollar_dollar, Symbol("sync")) - _t1619 = _dollar_dollar.sync + _t1623 = _dollar_dollar.sync else - _t1619 = nothing + _t1623 = nothing end - fields809 = (_t1618, _t1619, _dollar_dollar.epochs,) - unwrapped_fields810 = fields809 + fields811 = (_t1622, _t1623, _dollar_dollar.epochs,) + unwrapped_fields812 = fields811 write(pp, "(transaction") indent_sexp!(pp) - field811 = unwrapped_fields810[1] - if !isnothing(field811) - newline(pp) - opt_val812 = field811 - pretty_configure(pp, opt_val812) - end - field813 = unwrapped_fields810[2] + field813 = unwrapped_fields812[1] if !isnothing(field813) newline(pp) opt_val814 = field813 - pretty_sync(pp, opt_val814) + pretty_configure(pp, opt_val814) + end + field815 = unwrapped_fields812[2] + if !isnothing(field815) + newline(pp) + opt_val816 = field815 + pretty_sync(pp, opt_val816) end - field815 = unwrapped_fields810[3] - if !isempty(field815) + field817 = unwrapped_fields812[3] + if !isempty(field817) newline(pp) - for (i1620, elem816) in enumerate(field815) - i817 = i1620 - 1 - if (i817 > 0) + for (i1624, elem818) in enumerate(field817) + i819 = i1624 - 1 + if (i819 > 0) newline(pp) end - pretty_epoch(pp, elem816) + pretty_epoch(pp, elem818) end end dedent!(pp) @@ -689,19 +689,19 @@ function pretty_transaction(pp::PrettyPrinter, msg::Proto.Transaction) end function pretty_configure(pp::PrettyPrinter, msg::Proto.Configure) - flat821 = try_flat(pp, msg, pretty_configure) - if !isnothing(flat821) - write(pp, flat821) + flat823 = try_flat(pp, msg, pretty_configure) + if !isnothing(flat823) + write(pp, flat823) return nothing else _dollar_dollar = msg - _t1621 = deconstruct_configure(pp, _dollar_dollar) - fields819 = _t1621 - unwrapped_fields820 = fields819 + _t1625 = deconstruct_configure(pp, _dollar_dollar) + fields821 = _t1625 + unwrapped_fields822 = fields821 write(pp, "(configure") indent_sexp!(pp) newline(pp) - pretty_config_dict(pp, unwrapped_fields820) + pretty_config_dict(pp, unwrapped_fields822) dedent!(pp) write(pp, ")") end @@ -709,22 +709,22 @@ function pretty_configure(pp::PrettyPrinter, msg::Proto.Configure) end function pretty_config_dict(pp::PrettyPrinter, msg::Vector{Tuple{String, Proto.Value}}) - flat825 = try_flat(pp, msg, pretty_config_dict) - if !isnothing(flat825) - write(pp, flat825) + flat827 = try_flat(pp, msg, pretty_config_dict) + if !isnothing(flat827) + write(pp, flat827) return nothing else - fields822 = msg + fields824 = msg write(pp, "{") indent!(pp) - if !isempty(fields822) + if !isempty(fields824) newline(pp) - for (i1622, elem823) in enumerate(fields822) - i824 = i1622 - 1 - if (i824 > 0) + for (i1626, elem825) in enumerate(fields824) + i826 = i1626 - 1 + if (i826 > 0) newline(pp) end - pretty_config_key_value(pp, elem823) + pretty_config_key_value(pp, elem825) end end dedent!(pp) @@ -734,163 +734,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}) - flat830 = try_flat(pp, msg, pretty_config_key_value) - if !isnothing(flat830) - write(pp, flat830) + flat832 = try_flat(pp, msg, pretty_config_key_value) + if !isnothing(flat832) + write(pp, flat832) return nothing else _dollar_dollar = msg - fields826 = (_dollar_dollar[1], _dollar_dollar[2],) - unwrapped_fields827 = fields826 + fields828 = (_dollar_dollar[1], _dollar_dollar[2],) + unwrapped_fields829 = fields828 write(pp, ":") - field828 = unwrapped_fields827[1] - write(pp, field828) + field830 = unwrapped_fields829[1] + write(pp, field830) write(pp, " ") - field829 = unwrapped_fields827[2] - pretty_raw_value(pp, field829) + field831 = unwrapped_fields829[2] + pretty_raw_value(pp, field831) end return nothing end function pretty_raw_value(pp::PrettyPrinter, msg::Proto.Value) - flat856 = try_flat(pp, msg, pretty_raw_value) - if !isnothing(flat856) - write(pp, flat856) + flat858 = try_flat(pp, msg, pretty_raw_value) + if !isnothing(flat858) + write(pp, flat858) return nothing else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("date_value")) - _t1623 = _get_oneof_field(_dollar_dollar, :date_value) + _t1627 = _get_oneof_field(_dollar_dollar, :date_value) else - _t1623 = nothing + _t1627 = nothing end - deconstruct_result854 = _t1623 - if !isnothing(deconstruct_result854) - unwrapped855 = deconstruct_result854 - pretty_raw_date(pp, unwrapped855) + deconstruct_result856 = _t1627 + if !isnothing(deconstruct_result856) + unwrapped857 = deconstruct_result856 + pretty_raw_date(pp, unwrapped857) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("datetime_value")) - _t1624 = _get_oneof_field(_dollar_dollar, :datetime_value) + _t1628 = _get_oneof_field(_dollar_dollar, :datetime_value) else - _t1624 = nothing + _t1628 = nothing end - deconstruct_result852 = _t1624 - if !isnothing(deconstruct_result852) - unwrapped853 = deconstruct_result852 - pretty_raw_datetime(pp, unwrapped853) + deconstruct_result854 = _t1628 + if !isnothing(deconstruct_result854) + unwrapped855 = deconstruct_result854 + pretty_raw_datetime(pp, unwrapped855) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("string_value")) - _t1625 = _get_oneof_field(_dollar_dollar, :string_value) + _t1629 = _get_oneof_field(_dollar_dollar, :string_value) else - _t1625 = nothing + _t1629 = nothing end - deconstruct_result850 = _t1625 - if !isnothing(deconstruct_result850) - unwrapped851 = deconstruct_result850 - write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, unwrapped851)) + deconstruct_result852 = _t1629 + if !isnothing(deconstruct_result852) + unwrapped853 = deconstruct_result852 + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, unwrapped853)) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("int32_value")) - _t1626 = _get_oneof_field(_dollar_dollar, :int32_value) + _t1630 = _get_oneof_field(_dollar_dollar, :int32_value) else - _t1626 = nothing + _t1630 = nothing end - deconstruct_result848 = _t1626 - if !isnothing(deconstruct_result848) - unwrapped849 = deconstruct_result848 - write(pp, (string(Int64(unwrapped849)) * "i32")) + deconstruct_result850 = _t1630 + if !isnothing(deconstruct_result850) + unwrapped851 = deconstruct_result850 + write(pp, (string(Int64(unwrapped851)) * "i32")) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("int_value")) - _t1627 = _get_oneof_field(_dollar_dollar, :int_value) + _t1631 = _get_oneof_field(_dollar_dollar, :int_value) else - _t1627 = nothing + _t1631 = nothing end - deconstruct_result846 = _t1627 - if !isnothing(deconstruct_result846) - unwrapped847 = deconstruct_result846 - write(pp, string(unwrapped847)) + deconstruct_result848 = _t1631 + if !isnothing(deconstruct_result848) + unwrapped849 = deconstruct_result848 + write(pp, string(unwrapped849)) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("float32_value")) - _t1628 = _get_oneof_field(_dollar_dollar, :float32_value) + _t1632 = _get_oneof_field(_dollar_dollar, :float32_value) else - _t1628 = nothing + _t1632 = nothing end - deconstruct_result844 = _t1628 - if !isnothing(deconstruct_result844) - unwrapped845 = deconstruct_result844 - write(pp, format_float32_literal(unwrapped845)) + deconstruct_result846 = _t1632 + if !isnothing(deconstruct_result846) + unwrapped847 = deconstruct_result846 + write(pp, format_float32_literal(unwrapped847)) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("float_value")) - _t1629 = _get_oneof_field(_dollar_dollar, :float_value) + _t1633 = _get_oneof_field(_dollar_dollar, :float_value) else - _t1629 = nothing + _t1633 = nothing end - deconstruct_result842 = _t1629 - if !isnothing(deconstruct_result842) - unwrapped843 = deconstruct_result842 - write(pp, lowercase(string(unwrapped843))) + deconstruct_result844 = _t1633 + if !isnothing(deconstruct_result844) + unwrapped845 = deconstruct_result844 + write(pp, lowercase(string(unwrapped845))) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("uint32_value")) - _t1630 = _get_oneof_field(_dollar_dollar, :uint32_value) + _t1634 = _get_oneof_field(_dollar_dollar, :uint32_value) else - _t1630 = nothing + _t1634 = nothing end - deconstruct_result840 = _t1630 - if !isnothing(deconstruct_result840) - unwrapped841 = deconstruct_result840 - write(pp, (string(Int64(unwrapped841)) * "u32")) + deconstruct_result842 = _t1634 + if !isnothing(deconstruct_result842) + unwrapped843 = deconstruct_result842 + write(pp, (string(Int64(unwrapped843)) * "u32")) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("uint128_value")) - _t1631 = _get_oneof_field(_dollar_dollar, :uint128_value) + _t1635 = _get_oneof_field(_dollar_dollar, :uint128_value) else - _t1631 = nothing + _t1635 = nothing end - deconstruct_result838 = _t1631 - if !isnothing(deconstruct_result838) - unwrapped839 = deconstruct_result838 - write(pp, format_uint128(DEFAULT_CONSTANT_FORMATTER, pp, unwrapped839)) + deconstruct_result840 = _t1635 + if !isnothing(deconstruct_result840) + unwrapped841 = deconstruct_result840 + write(pp, format_uint128(DEFAULT_CONSTANT_FORMATTER, pp, unwrapped841)) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("int128_value")) - _t1632 = _get_oneof_field(_dollar_dollar, :int128_value) + _t1636 = _get_oneof_field(_dollar_dollar, :int128_value) else - _t1632 = nothing + _t1636 = nothing end - deconstruct_result836 = _t1632 - if !isnothing(deconstruct_result836) - unwrapped837 = deconstruct_result836 - write(pp, format_int128(DEFAULT_CONSTANT_FORMATTER, pp, unwrapped837)) + deconstruct_result838 = _t1636 + if !isnothing(deconstruct_result838) + unwrapped839 = deconstruct_result838 + write(pp, format_int128(DEFAULT_CONSTANT_FORMATTER, pp, unwrapped839)) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("decimal_value")) - _t1633 = _get_oneof_field(_dollar_dollar, :decimal_value) + _t1637 = _get_oneof_field(_dollar_dollar, :decimal_value) else - _t1633 = nothing + _t1637 = nothing end - deconstruct_result834 = _t1633 - if !isnothing(deconstruct_result834) - unwrapped835 = deconstruct_result834 - write(pp, format_decimal(DEFAULT_CONSTANT_FORMATTER, pp, unwrapped835)) + deconstruct_result836 = _t1637 + if !isnothing(deconstruct_result836) + unwrapped837 = deconstruct_result836 + write(pp, format_decimal(DEFAULT_CONSTANT_FORMATTER, pp, unwrapped837)) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("boolean_value")) - _t1634 = _get_oneof_field(_dollar_dollar, :boolean_value) + _t1638 = _get_oneof_field(_dollar_dollar, :boolean_value) else - _t1634 = nothing + _t1638 = nothing end - deconstruct_result832 = _t1634 - if !isnothing(deconstruct_result832) - unwrapped833 = deconstruct_result832 - pretty_boolean_value(pp, unwrapped833) + deconstruct_result834 = _t1638 + if !isnothing(deconstruct_result834) + unwrapped835 = deconstruct_result834 + pretty_boolean_value(pp, unwrapped835) else - fields831 = msg + fields833 = msg write(pp, "missing") end end @@ -909,25 +909,25 @@ function pretty_raw_value(pp::PrettyPrinter, msg::Proto.Value) end function pretty_raw_date(pp::PrettyPrinter, msg::Proto.DateValue) - flat862 = try_flat(pp, msg, pretty_raw_date) - if !isnothing(flat862) - write(pp, flat862) + flat864 = try_flat(pp, msg, pretty_raw_date) + if !isnothing(flat864) + write(pp, flat864) return nothing else _dollar_dollar = msg - fields857 = (Int64(_dollar_dollar.year), Int64(_dollar_dollar.month), Int64(_dollar_dollar.day),) - unwrapped_fields858 = fields857 + fields859 = (Int64(_dollar_dollar.year), Int64(_dollar_dollar.month), Int64(_dollar_dollar.day),) + unwrapped_fields860 = fields859 write(pp, "(date") indent_sexp!(pp) newline(pp) - field859 = unwrapped_fields858[1] - write(pp, string(field859)) + field861 = unwrapped_fields860[1] + write(pp, string(field861)) newline(pp) - field860 = unwrapped_fields858[2] - write(pp, string(field860)) + field862 = unwrapped_fields860[2] + write(pp, string(field862)) newline(pp) - field861 = unwrapped_fields858[3] - write(pp, string(field861)) + field863 = unwrapped_fields860[3] + write(pp, string(field863)) dedent!(pp) write(pp, ")") end @@ -935,39 +935,39 @@ function pretty_raw_date(pp::PrettyPrinter, msg::Proto.DateValue) end function pretty_raw_datetime(pp::PrettyPrinter, msg::Proto.DateTimeValue) - flat873 = try_flat(pp, msg, pretty_raw_datetime) - if !isnothing(flat873) - write(pp, flat873) + flat875 = try_flat(pp, msg, pretty_raw_datetime) + if !isnothing(flat875) + write(pp, flat875) return nothing else _dollar_dollar = msg - fields863 = (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_fields864 = fields863 + fields865 = (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_fields866 = fields865 write(pp, "(datetime") indent_sexp!(pp) newline(pp) - field865 = unwrapped_fields864[1] - write(pp, string(field865)) - newline(pp) - field866 = unwrapped_fields864[2] - write(pp, string(field866)) - newline(pp) - field867 = unwrapped_fields864[3] + field867 = unwrapped_fields866[1] write(pp, string(field867)) newline(pp) - field868 = unwrapped_fields864[4] + field868 = unwrapped_fields866[2] write(pp, string(field868)) newline(pp) - field869 = unwrapped_fields864[5] + field869 = unwrapped_fields866[3] write(pp, string(field869)) newline(pp) - field870 = unwrapped_fields864[6] + field870 = unwrapped_fields866[4] write(pp, string(field870)) - field871 = unwrapped_fields864[7] - if !isnothing(field871) + newline(pp) + field871 = unwrapped_fields866[5] + write(pp, string(field871)) + newline(pp) + field872 = unwrapped_fields866[6] + write(pp, string(field872)) + field873 = unwrapped_fields866[7] + if !isnothing(field873) newline(pp) - opt_val872 = field871 - write(pp, string(opt_val872)) + opt_val874 = field873 + write(pp, string(opt_val874)) end dedent!(pp) write(pp, ")") @@ -978,24 +978,24 @@ end function pretty_boolean_value(pp::PrettyPrinter, msg::Bool) _dollar_dollar = msg if _dollar_dollar - _t1635 = () + _t1639 = () else - _t1635 = nothing + _t1639 = nothing end - deconstruct_result876 = _t1635 - if !isnothing(deconstruct_result876) - unwrapped877 = deconstruct_result876 + deconstruct_result878 = _t1639 + if !isnothing(deconstruct_result878) + unwrapped879 = deconstruct_result878 write(pp, "true") else _dollar_dollar = msg if !_dollar_dollar - _t1636 = () + _t1640 = () else - _t1636 = nothing + _t1640 = nothing end - deconstruct_result874 = _t1636 - if !isnothing(deconstruct_result874) - unwrapped875 = deconstruct_result874 + deconstruct_result876 = _t1640 + if !isnothing(deconstruct_result876) + unwrapped877 = deconstruct_result876 write(pp, "false") else throw(ParseError("No matching rule for boolean_value")) @@ -1005,24 +1005,24 @@ function pretty_boolean_value(pp::PrettyPrinter, msg::Bool) end function pretty_sync(pp::PrettyPrinter, msg::Proto.Sync) - flat882 = try_flat(pp, msg, pretty_sync) - if !isnothing(flat882) - write(pp, flat882) + flat884 = try_flat(pp, msg, pretty_sync) + if !isnothing(flat884) + write(pp, flat884) return nothing else _dollar_dollar = msg - fields878 = _dollar_dollar.fragments - unwrapped_fields879 = fields878 + fields880 = _dollar_dollar.fragments + unwrapped_fields881 = fields880 write(pp, "(sync") indent_sexp!(pp) - if !isempty(unwrapped_fields879) + if !isempty(unwrapped_fields881) newline(pp) - for (i1637, elem880) in enumerate(unwrapped_fields879) - i881 = i1637 - 1 - if (i881 > 0) + for (i1641, elem882) in enumerate(unwrapped_fields881) + i883 = i1641 - 1 + if (i883 > 0) newline(pp) end - pretty_fragment_id(pp, elem880) + pretty_fragment_id(pp, elem882) end end dedent!(pp) @@ -1032,52 +1032,52 @@ function pretty_sync(pp::PrettyPrinter, msg::Proto.Sync) end function pretty_fragment_id(pp::PrettyPrinter, msg::Proto.FragmentId) - flat885 = try_flat(pp, msg, pretty_fragment_id) - if !isnothing(flat885) - write(pp, flat885) + flat887 = try_flat(pp, msg, pretty_fragment_id) + if !isnothing(flat887) + write(pp, flat887) return nothing else _dollar_dollar = msg - fields883 = fragment_id_to_string(pp, _dollar_dollar) - unwrapped_fields884 = fields883 + fields885 = fragment_id_to_string(pp, _dollar_dollar) + unwrapped_fields886 = fields885 write(pp, ":") - write(pp, unwrapped_fields884) + write(pp, unwrapped_fields886) end return nothing end function pretty_epoch(pp::PrettyPrinter, msg::Proto.Epoch) - flat892 = try_flat(pp, msg, pretty_epoch) - if !isnothing(flat892) - write(pp, flat892) + flat894 = try_flat(pp, msg, pretty_epoch) + if !isnothing(flat894) + write(pp, flat894) return nothing else _dollar_dollar = msg if !isempty(_dollar_dollar.writes) - _t1638 = _dollar_dollar.writes + _t1642 = _dollar_dollar.writes else - _t1638 = nothing + _t1642 = nothing end if !isempty(_dollar_dollar.reads) - _t1639 = _dollar_dollar.reads + _t1643 = _dollar_dollar.reads else - _t1639 = nothing + _t1643 = nothing end - fields886 = (_t1638, _t1639,) - unwrapped_fields887 = fields886 + fields888 = (_t1642, _t1643,) + unwrapped_fields889 = fields888 write(pp, "(epoch") indent_sexp!(pp) - field888 = unwrapped_fields887[1] - if !isnothing(field888) - newline(pp) - opt_val889 = field888 - pretty_epoch_writes(pp, opt_val889) - end - field890 = unwrapped_fields887[2] + field890 = unwrapped_fields889[1] if !isnothing(field890) newline(pp) opt_val891 = field890 - pretty_epoch_reads(pp, opt_val891) + pretty_epoch_writes(pp, opt_val891) + end + field892 = unwrapped_fields889[2] + if !isnothing(field892) + newline(pp) + opt_val893 = field892 + pretty_epoch_reads(pp, opt_val893) end dedent!(pp) write(pp, ")") @@ -1086,22 +1086,22 @@ function pretty_epoch(pp::PrettyPrinter, msg::Proto.Epoch) end function pretty_epoch_writes(pp::PrettyPrinter, msg::Vector{Proto.Write}) - flat896 = try_flat(pp, msg, pretty_epoch_writes) - if !isnothing(flat896) - write(pp, flat896) + flat898 = try_flat(pp, msg, pretty_epoch_writes) + if !isnothing(flat898) + write(pp, flat898) return nothing else - fields893 = msg + fields895 = msg write(pp, "(writes") indent_sexp!(pp) - if !isempty(fields893) + if !isempty(fields895) newline(pp) - for (i1640, elem894) in enumerate(fields893) - i895 = i1640 - 1 - if (i895 > 0) + for (i1644, elem896) in enumerate(fields895) + i897 = i1644 - 1 + if (i897 > 0) newline(pp) end - pretty_write(pp, elem894) + pretty_write(pp, elem896) end end dedent!(pp) @@ -1111,54 +1111,54 @@ function pretty_epoch_writes(pp::PrettyPrinter, msg::Vector{Proto.Write}) end function pretty_write(pp::PrettyPrinter, msg::Proto.Write) - flat905 = try_flat(pp, msg, pretty_write) - if !isnothing(flat905) - write(pp, flat905) + flat907 = try_flat(pp, msg, pretty_write) + if !isnothing(flat907) + write(pp, flat907) return nothing else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("define")) - _t1641 = _get_oneof_field(_dollar_dollar, :define) + _t1645 = _get_oneof_field(_dollar_dollar, :define) else - _t1641 = nothing + _t1645 = nothing end - deconstruct_result903 = _t1641 - if !isnothing(deconstruct_result903) - unwrapped904 = deconstruct_result903 - pretty_define(pp, unwrapped904) + deconstruct_result905 = _t1645 + if !isnothing(deconstruct_result905) + unwrapped906 = deconstruct_result905 + pretty_define(pp, unwrapped906) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("undefine")) - _t1642 = _get_oneof_field(_dollar_dollar, :undefine) + _t1646 = _get_oneof_field(_dollar_dollar, :undefine) else - _t1642 = nothing + _t1646 = nothing end - deconstruct_result901 = _t1642 - if !isnothing(deconstruct_result901) - unwrapped902 = deconstruct_result901 - pretty_undefine(pp, unwrapped902) + deconstruct_result903 = _t1646 + if !isnothing(deconstruct_result903) + unwrapped904 = deconstruct_result903 + pretty_undefine(pp, unwrapped904) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("context")) - _t1643 = _get_oneof_field(_dollar_dollar, :context) + _t1647 = _get_oneof_field(_dollar_dollar, :context) else - _t1643 = nothing + _t1647 = nothing end - deconstruct_result899 = _t1643 - if !isnothing(deconstruct_result899) - unwrapped900 = deconstruct_result899 - pretty_context(pp, unwrapped900) + deconstruct_result901 = _t1647 + if !isnothing(deconstruct_result901) + unwrapped902 = deconstruct_result901 + pretty_context(pp, unwrapped902) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("snapshot")) - _t1644 = _get_oneof_field(_dollar_dollar, :snapshot) + _t1648 = _get_oneof_field(_dollar_dollar, :snapshot) else - _t1644 = nothing + _t1648 = nothing end - deconstruct_result897 = _t1644 - if !isnothing(deconstruct_result897) - unwrapped898 = deconstruct_result897 - pretty_snapshot(pp, unwrapped898) + deconstruct_result899 = _t1648 + if !isnothing(deconstruct_result899) + unwrapped900 = deconstruct_result899 + pretty_snapshot(pp, unwrapped900) else throw(ParseError("No matching rule for write")) end @@ -1170,18 +1170,18 @@ function pretty_write(pp::PrettyPrinter, msg::Proto.Write) end function pretty_define(pp::PrettyPrinter, msg::Proto.Define) - flat908 = try_flat(pp, msg, pretty_define) - if !isnothing(flat908) - write(pp, flat908) + flat910 = try_flat(pp, msg, pretty_define) + if !isnothing(flat910) + write(pp, flat910) return nothing else _dollar_dollar = msg - fields906 = _dollar_dollar.fragment - unwrapped_fields907 = fields906 + fields908 = _dollar_dollar.fragment + unwrapped_fields909 = fields908 write(pp, "(define") indent_sexp!(pp) newline(pp) - pretty_fragment(pp, unwrapped_fields907) + pretty_fragment(pp, unwrapped_fields909) dedent!(pp) write(pp, ")") end @@ -1189,29 +1189,29 @@ function pretty_define(pp::PrettyPrinter, msg::Proto.Define) end function pretty_fragment(pp::PrettyPrinter, msg::Proto.Fragment) - flat915 = try_flat(pp, msg, pretty_fragment) - if !isnothing(flat915) - write(pp, flat915) + flat917 = try_flat(pp, msg, pretty_fragment) + if !isnothing(flat917) + write(pp, flat917) return nothing else _dollar_dollar = msg start_pretty_fragment(pp, _dollar_dollar) - fields909 = (_dollar_dollar.id, _dollar_dollar.declarations,) - unwrapped_fields910 = fields909 + fields911 = (_dollar_dollar.id, _dollar_dollar.declarations,) + unwrapped_fields912 = fields911 write(pp, "(fragment") indent_sexp!(pp) newline(pp) - field911 = unwrapped_fields910[1] - pretty_new_fragment_id(pp, field911) - field912 = unwrapped_fields910[2] - if !isempty(field912) + field913 = unwrapped_fields912[1] + pretty_new_fragment_id(pp, field913) + field914 = unwrapped_fields912[2] + if !isempty(field914) newline(pp) - for (i1645, elem913) in enumerate(field912) - i914 = i1645 - 1 - if (i914 > 0) + for (i1649, elem915) in enumerate(field914) + i916 = i1649 - 1 + if (i916 > 0) newline(pp) end - pretty_declaration(pp, elem913) + pretty_declaration(pp, elem915) end end dedent!(pp) @@ -1221,66 +1221,66 @@ function pretty_fragment(pp::PrettyPrinter, msg::Proto.Fragment) end function pretty_new_fragment_id(pp::PrettyPrinter, msg::Proto.FragmentId) - flat917 = try_flat(pp, msg, pretty_new_fragment_id) - if !isnothing(flat917) - write(pp, flat917) + flat919 = try_flat(pp, msg, pretty_new_fragment_id) + if !isnothing(flat919) + write(pp, flat919) return nothing else - fields916 = msg - pretty_fragment_id(pp, fields916) + fields918 = msg + pretty_fragment_id(pp, fields918) end return nothing end function pretty_declaration(pp::PrettyPrinter, msg::Proto.Declaration) - flat926 = try_flat(pp, msg, pretty_declaration) - if !isnothing(flat926) - write(pp, flat926) + flat928 = try_flat(pp, msg, pretty_declaration) + if !isnothing(flat928) + write(pp, flat928) return nothing else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("def")) - _t1646 = _get_oneof_field(_dollar_dollar, :def) + _t1650 = _get_oneof_field(_dollar_dollar, :def) else - _t1646 = nothing + _t1650 = nothing end - deconstruct_result924 = _t1646 - if !isnothing(deconstruct_result924) - unwrapped925 = deconstruct_result924 - pretty_def(pp, unwrapped925) + deconstruct_result926 = _t1650 + if !isnothing(deconstruct_result926) + unwrapped927 = deconstruct_result926 + pretty_def(pp, unwrapped927) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("algorithm")) - _t1647 = _get_oneof_field(_dollar_dollar, :algorithm) + _t1651 = _get_oneof_field(_dollar_dollar, :algorithm) else - _t1647 = nothing + _t1651 = nothing end - deconstruct_result922 = _t1647 - if !isnothing(deconstruct_result922) - unwrapped923 = deconstruct_result922 - pretty_algorithm(pp, unwrapped923) + deconstruct_result924 = _t1651 + if !isnothing(deconstruct_result924) + unwrapped925 = deconstruct_result924 + pretty_algorithm(pp, unwrapped925) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("constraint")) - _t1648 = _get_oneof_field(_dollar_dollar, :constraint) + _t1652 = _get_oneof_field(_dollar_dollar, :constraint) else - _t1648 = nothing + _t1652 = nothing end - deconstruct_result920 = _t1648 - if !isnothing(deconstruct_result920) - unwrapped921 = deconstruct_result920 - pretty_constraint(pp, unwrapped921) + deconstruct_result922 = _t1652 + if !isnothing(deconstruct_result922) + unwrapped923 = deconstruct_result922 + pretty_constraint(pp, unwrapped923) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("data")) - _t1649 = _get_oneof_field(_dollar_dollar, :data) + _t1653 = _get_oneof_field(_dollar_dollar, :data) else - _t1649 = nothing + _t1653 = nothing end - deconstruct_result918 = _t1649 - if !isnothing(deconstruct_result918) - unwrapped919 = deconstruct_result918 - pretty_data(pp, unwrapped919) + deconstruct_result920 = _t1653 + if !isnothing(deconstruct_result920) + unwrapped921 = deconstruct_result920 + pretty_data(pp, unwrapped921) else throw(ParseError("No matching rule for declaration")) end @@ -1292,32 +1292,32 @@ function pretty_declaration(pp::PrettyPrinter, msg::Proto.Declaration) end function pretty_def(pp::PrettyPrinter, msg::Proto.Def) - flat933 = try_flat(pp, msg, pretty_def) - if !isnothing(flat933) - write(pp, flat933) + flat935 = try_flat(pp, msg, pretty_def) + if !isnothing(flat935) + write(pp, flat935) return nothing else _dollar_dollar = msg if !isempty(_dollar_dollar.attrs) - _t1650 = _dollar_dollar.attrs + _t1654 = _dollar_dollar.attrs else - _t1650 = nothing + _t1654 = nothing end - fields927 = (_dollar_dollar.name, _dollar_dollar.body, _t1650,) - unwrapped_fields928 = fields927 + fields929 = (_dollar_dollar.name, _dollar_dollar.body, _t1654,) + unwrapped_fields930 = fields929 write(pp, "(def") indent_sexp!(pp) newline(pp) - field929 = unwrapped_fields928[1] - pretty_relation_id(pp, field929) + field931 = unwrapped_fields930[1] + pretty_relation_id(pp, field931) newline(pp) - field930 = unwrapped_fields928[2] - pretty_abstraction(pp, field930) - field931 = unwrapped_fields928[3] - if !isnothing(field931) + field932 = unwrapped_fields930[2] + pretty_abstraction(pp, field932) + field933 = unwrapped_fields930[3] + if !isnothing(field933) newline(pp) - opt_val932 = field931 - pretty_attrs(pp, opt_val932) + opt_val934 = field933 + pretty_attrs(pp, opt_val934) end dedent!(pp) write(pp, ")") @@ -1326,30 +1326,30 @@ function pretty_def(pp::PrettyPrinter, msg::Proto.Def) end function pretty_relation_id(pp::PrettyPrinter, msg::Proto.RelationId) - flat938 = try_flat(pp, msg, pretty_relation_id) - if !isnothing(flat938) - write(pp, flat938) + flat940 = try_flat(pp, msg, pretty_relation_id) + if !isnothing(flat940) + write(pp, flat940) return nothing else _dollar_dollar = msg if !isnothing(relation_id_to_string(pp, _dollar_dollar)) - _t1652 = deconstruct_relation_id_string(pp, _dollar_dollar) - _t1651 = _t1652 + _t1656 = deconstruct_relation_id_string(pp, _dollar_dollar) + _t1655 = _t1656 else - _t1651 = nothing + _t1655 = nothing end - deconstruct_result936 = _t1651 - if !isnothing(deconstruct_result936) - unwrapped937 = deconstruct_result936 + deconstruct_result938 = _t1655 + if !isnothing(deconstruct_result938) + unwrapped939 = deconstruct_result938 write(pp, ":") - write(pp, unwrapped937) + write(pp, unwrapped939) else _dollar_dollar = msg - _t1653 = deconstruct_relation_id_uint128(pp, _dollar_dollar) - deconstruct_result934 = _t1653 - if !isnothing(deconstruct_result934) - unwrapped935 = deconstruct_result934 - write(pp, format_uint128(DEFAULT_CONSTANT_FORMATTER, pp, unwrapped935)) + _t1657 = deconstruct_relation_id_uint128(pp, _dollar_dollar) + deconstruct_result936 = _t1657 + if !isnothing(deconstruct_result936) + unwrapped937 = deconstruct_result936 + write(pp, format_uint128(DEFAULT_CONSTANT_FORMATTER, pp, unwrapped937)) else throw(ParseError("No matching rule for relation_id")) end @@ -1359,22 +1359,22 @@ function pretty_relation_id(pp::PrettyPrinter, msg::Proto.RelationId) end function pretty_abstraction(pp::PrettyPrinter, msg::Proto.Abstraction) - flat943 = try_flat(pp, msg, pretty_abstraction) - if !isnothing(flat943) - write(pp, flat943) + flat945 = try_flat(pp, msg, pretty_abstraction) + if !isnothing(flat945) + write(pp, flat945) return nothing else _dollar_dollar = msg - _t1654 = deconstruct_bindings(pp, _dollar_dollar) - fields939 = (_t1654, _dollar_dollar.value,) - unwrapped_fields940 = fields939 + _t1658 = deconstruct_bindings(pp, _dollar_dollar) + fields941 = (_t1658, _dollar_dollar.value,) + unwrapped_fields942 = fields941 write(pp, "(") indent!(pp) - field941 = unwrapped_fields940[1] - pretty_bindings(pp, field941) + field943 = unwrapped_fields942[1] + pretty_bindings(pp, field943) newline(pp) - field942 = unwrapped_fields940[2] - pretty_formula(pp, field942) + field944 = unwrapped_fields942[2] + pretty_formula(pp, field944) dedent!(pp) write(pp, ")") end @@ -1382,34 +1382,34 @@ function pretty_abstraction(pp::PrettyPrinter, msg::Proto.Abstraction) end function pretty_bindings(pp::PrettyPrinter, msg::Tuple{Vector{Proto.Binding}, Vector{Proto.Binding}}) - flat951 = try_flat(pp, msg, pretty_bindings) - if !isnothing(flat951) - write(pp, flat951) + flat953 = try_flat(pp, msg, pretty_bindings) + if !isnothing(flat953) + write(pp, flat953) return nothing else _dollar_dollar = msg if !isempty(_dollar_dollar[2]) - _t1655 = _dollar_dollar[2] + _t1659 = _dollar_dollar[2] else - _t1655 = nothing + _t1659 = nothing end - fields944 = (_dollar_dollar[1], _t1655,) - unwrapped_fields945 = fields944 + fields946 = (_dollar_dollar[1], _t1659,) + unwrapped_fields947 = fields946 write(pp, "[") indent!(pp) - field946 = unwrapped_fields945[1] - for (i1656, elem947) in enumerate(field946) - i948 = i1656 - 1 - if (i948 > 0) + field948 = unwrapped_fields947[1] + for (i1660, elem949) in enumerate(field948) + i950 = i1660 - 1 + if (i950 > 0) newline(pp) end - pretty_binding(pp, elem947) + pretty_binding(pp, elem949) end - field949 = unwrapped_fields945[2] - if !isnothing(field949) + field951 = unwrapped_fields947[2] + if !isnothing(field951) newline(pp) - opt_val950 = field949 - pretty_value_bindings(pp, opt_val950) + opt_val952 = field951 + pretty_value_bindings(pp, opt_val952) end dedent!(pp) write(pp, "]") @@ -1418,182 +1418,182 @@ function pretty_bindings(pp::PrettyPrinter, msg::Tuple{Vector{Proto.Binding}, Ve end function pretty_binding(pp::PrettyPrinter, msg::Proto.Binding) - flat956 = try_flat(pp, msg, pretty_binding) - if !isnothing(flat956) - write(pp, flat956) + flat958 = try_flat(pp, msg, pretty_binding) + if !isnothing(flat958) + write(pp, flat958) return nothing else _dollar_dollar = msg - fields952 = (_dollar_dollar.var.name, _dollar_dollar.var"#type",) - unwrapped_fields953 = fields952 - field954 = unwrapped_fields953[1] - write(pp, field954) + fields954 = (_dollar_dollar.var.name, _dollar_dollar.var"#type",) + unwrapped_fields955 = fields954 + field956 = unwrapped_fields955[1] + write(pp, field956) write(pp, "::") - field955 = unwrapped_fields953[2] - pretty_type(pp, field955) + field957 = unwrapped_fields955[2] + pretty_type(pp, field957) end return nothing end function pretty_type(pp::PrettyPrinter, msg::Proto.var"#Type") - flat985 = try_flat(pp, msg, pretty_type) - if !isnothing(flat985) - write(pp, flat985) + flat987 = try_flat(pp, msg, pretty_type) + if !isnothing(flat987) + write(pp, flat987) return nothing else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("unspecified_type")) - _t1657 = _get_oneof_field(_dollar_dollar, :unspecified_type) + _t1661 = _get_oneof_field(_dollar_dollar, :unspecified_type) else - _t1657 = nothing + _t1661 = nothing end - deconstruct_result983 = _t1657 - if !isnothing(deconstruct_result983) - unwrapped984 = deconstruct_result983 - pretty_unspecified_type(pp, unwrapped984) + deconstruct_result985 = _t1661 + if !isnothing(deconstruct_result985) + unwrapped986 = deconstruct_result985 + pretty_unspecified_type(pp, unwrapped986) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("string_type")) - _t1658 = _get_oneof_field(_dollar_dollar, :string_type) + _t1662 = _get_oneof_field(_dollar_dollar, :string_type) else - _t1658 = nothing + _t1662 = nothing end - deconstruct_result981 = _t1658 - if !isnothing(deconstruct_result981) - unwrapped982 = deconstruct_result981 - pretty_string_type(pp, unwrapped982) + deconstruct_result983 = _t1662 + if !isnothing(deconstruct_result983) + unwrapped984 = deconstruct_result983 + pretty_string_type(pp, unwrapped984) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("int_type")) - _t1659 = _get_oneof_field(_dollar_dollar, :int_type) + _t1663 = _get_oneof_field(_dollar_dollar, :int_type) else - _t1659 = nothing + _t1663 = nothing end - deconstruct_result979 = _t1659 - if !isnothing(deconstruct_result979) - unwrapped980 = deconstruct_result979 - pretty_int_type(pp, unwrapped980) + deconstruct_result981 = _t1663 + if !isnothing(deconstruct_result981) + unwrapped982 = deconstruct_result981 + pretty_int_type(pp, unwrapped982) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("float_type")) - _t1660 = _get_oneof_field(_dollar_dollar, :float_type) + _t1664 = _get_oneof_field(_dollar_dollar, :float_type) else - _t1660 = nothing + _t1664 = nothing end - deconstruct_result977 = _t1660 - if !isnothing(deconstruct_result977) - unwrapped978 = deconstruct_result977 - pretty_float_type(pp, unwrapped978) + deconstruct_result979 = _t1664 + if !isnothing(deconstruct_result979) + unwrapped980 = deconstruct_result979 + pretty_float_type(pp, unwrapped980) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("uint128_type")) - _t1661 = _get_oneof_field(_dollar_dollar, :uint128_type) + _t1665 = _get_oneof_field(_dollar_dollar, :uint128_type) else - _t1661 = nothing + _t1665 = nothing end - deconstruct_result975 = _t1661 - if !isnothing(deconstruct_result975) - unwrapped976 = deconstruct_result975 - pretty_uint128_type(pp, unwrapped976) + deconstruct_result977 = _t1665 + if !isnothing(deconstruct_result977) + unwrapped978 = deconstruct_result977 + pretty_uint128_type(pp, unwrapped978) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("int128_type")) - _t1662 = _get_oneof_field(_dollar_dollar, :int128_type) + _t1666 = _get_oneof_field(_dollar_dollar, :int128_type) else - _t1662 = nothing + _t1666 = nothing end - deconstruct_result973 = _t1662 - if !isnothing(deconstruct_result973) - unwrapped974 = deconstruct_result973 - pretty_int128_type(pp, unwrapped974) + deconstruct_result975 = _t1666 + if !isnothing(deconstruct_result975) + unwrapped976 = deconstruct_result975 + pretty_int128_type(pp, unwrapped976) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("date_type")) - _t1663 = _get_oneof_field(_dollar_dollar, :date_type) + _t1667 = _get_oneof_field(_dollar_dollar, :date_type) else - _t1663 = nothing + _t1667 = nothing end - deconstruct_result971 = _t1663 - if !isnothing(deconstruct_result971) - unwrapped972 = deconstruct_result971 - pretty_date_type(pp, unwrapped972) + deconstruct_result973 = _t1667 + if !isnothing(deconstruct_result973) + unwrapped974 = deconstruct_result973 + pretty_date_type(pp, unwrapped974) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("datetime_type")) - _t1664 = _get_oneof_field(_dollar_dollar, :datetime_type) + _t1668 = _get_oneof_field(_dollar_dollar, :datetime_type) else - _t1664 = nothing + _t1668 = nothing end - deconstruct_result969 = _t1664 - if !isnothing(deconstruct_result969) - unwrapped970 = deconstruct_result969 - pretty_datetime_type(pp, unwrapped970) + deconstruct_result971 = _t1668 + if !isnothing(deconstruct_result971) + unwrapped972 = deconstruct_result971 + pretty_datetime_type(pp, unwrapped972) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("missing_type")) - _t1665 = _get_oneof_field(_dollar_dollar, :missing_type) + _t1669 = _get_oneof_field(_dollar_dollar, :missing_type) else - _t1665 = nothing + _t1669 = nothing end - deconstruct_result967 = _t1665 - if !isnothing(deconstruct_result967) - unwrapped968 = deconstruct_result967 - pretty_missing_type(pp, unwrapped968) + deconstruct_result969 = _t1669 + if !isnothing(deconstruct_result969) + unwrapped970 = deconstruct_result969 + pretty_missing_type(pp, unwrapped970) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("decimal_type")) - _t1666 = _get_oneof_field(_dollar_dollar, :decimal_type) + _t1670 = _get_oneof_field(_dollar_dollar, :decimal_type) else - _t1666 = nothing + _t1670 = nothing end - deconstruct_result965 = _t1666 - if !isnothing(deconstruct_result965) - unwrapped966 = deconstruct_result965 - pretty_decimal_type(pp, unwrapped966) + deconstruct_result967 = _t1670 + if !isnothing(deconstruct_result967) + unwrapped968 = deconstruct_result967 + pretty_decimal_type(pp, unwrapped968) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("boolean_type")) - _t1667 = _get_oneof_field(_dollar_dollar, :boolean_type) + _t1671 = _get_oneof_field(_dollar_dollar, :boolean_type) else - _t1667 = nothing + _t1671 = nothing end - deconstruct_result963 = _t1667 - if !isnothing(deconstruct_result963) - unwrapped964 = deconstruct_result963 - pretty_boolean_type(pp, unwrapped964) + deconstruct_result965 = _t1671 + if !isnothing(deconstruct_result965) + unwrapped966 = deconstruct_result965 + pretty_boolean_type(pp, unwrapped966) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("int32_type")) - _t1668 = _get_oneof_field(_dollar_dollar, :int32_type) + _t1672 = _get_oneof_field(_dollar_dollar, :int32_type) else - _t1668 = nothing + _t1672 = nothing end - deconstruct_result961 = _t1668 - if !isnothing(deconstruct_result961) - unwrapped962 = deconstruct_result961 - pretty_int32_type(pp, unwrapped962) + deconstruct_result963 = _t1672 + if !isnothing(deconstruct_result963) + unwrapped964 = deconstruct_result963 + pretty_int32_type(pp, unwrapped964) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("float32_type")) - _t1669 = _get_oneof_field(_dollar_dollar, :float32_type) + _t1673 = _get_oneof_field(_dollar_dollar, :float32_type) else - _t1669 = nothing + _t1673 = nothing end - deconstruct_result959 = _t1669 - if !isnothing(deconstruct_result959) - unwrapped960 = deconstruct_result959 - pretty_float32_type(pp, unwrapped960) + deconstruct_result961 = _t1673 + if !isnothing(deconstruct_result961) + unwrapped962 = deconstruct_result961 + pretty_float32_type(pp, unwrapped962) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("uint32_type")) - _t1670 = _get_oneof_field(_dollar_dollar, :uint32_type) + _t1674 = _get_oneof_field(_dollar_dollar, :uint32_type) else - _t1670 = nothing + _t1674 = nothing end - deconstruct_result957 = _t1670 - if !isnothing(deconstruct_result957) - unwrapped958 = deconstruct_result957 - pretty_uint32_type(pp, unwrapped958) + deconstruct_result959 = _t1674 + if !isnothing(deconstruct_result959) + unwrapped960 = deconstruct_result959 + pretty_uint32_type(pp, unwrapped960) else throw(ParseError("No matching rule for type")) end @@ -1615,76 +1615,76 @@ function pretty_type(pp::PrettyPrinter, msg::Proto.var"#Type") end function pretty_unspecified_type(pp::PrettyPrinter, msg::Proto.UnspecifiedType) - fields986 = msg + fields988 = msg write(pp, "UNKNOWN") return nothing end function pretty_string_type(pp::PrettyPrinter, msg::Proto.StringType) - fields987 = msg + fields989 = msg write(pp, "STRING") return nothing end function pretty_int_type(pp::PrettyPrinter, msg::Proto.IntType) - fields988 = msg + fields990 = msg write(pp, "INT") return nothing end function pretty_float_type(pp::PrettyPrinter, msg::Proto.FloatType) - fields989 = msg + fields991 = msg write(pp, "FLOAT") return nothing end function pretty_uint128_type(pp::PrettyPrinter, msg::Proto.UInt128Type) - fields990 = msg + fields992 = msg write(pp, "UINT128") return nothing end function pretty_int128_type(pp::PrettyPrinter, msg::Proto.Int128Type) - fields991 = msg + fields993 = msg write(pp, "INT128") return nothing end function pretty_date_type(pp::PrettyPrinter, msg::Proto.DateType) - fields992 = msg + fields994 = msg write(pp, "DATE") return nothing end function pretty_datetime_type(pp::PrettyPrinter, msg::Proto.DateTimeType) - fields993 = msg + fields995 = msg write(pp, "DATETIME") return nothing end function pretty_missing_type(pp::PrettyPrinter, msg::Proto.MissingType) - fields994 = msg + fields996 = msg write(pp, "MISSING") return nothing end function pretty_decimal_type(pp::PrettyPrinter, msg::Proto.DecimalType) - flat999 = try_flat(pp, msg, pretty_decimal_type) - if !isnothing(flat999) - write(pp, flat999) + flat1001 = try_flat(pp, msg, pretty_decimal_type) + if !isnothing(flat1001) + write(pp, flat1001) return nothing else _dollar_dollar = msg - fields995 = (Int64(_dollar_dollar.precision), Int64(_dollar_dollar.scale),) - unwrapped_fields996 = fields995 + fields997 = (Int64(_dollar_dollar.precision), Int64(_dollar_dollar.scale),) + unwrapped_fields998 = fields997 write(pp, "(DECIMAL") indent_sexp!(pp) newline(pp) - field997 = unwrapped_fields996[1] - write(pp, string(field997)) + field999 = unwrapped_fields998[1] + write(pp, string(field999)) newline(pp) - field998 = unwrapped_fields996[2] - write(pp, string(field998)) + field1000 = unwrapped_fields998[2] + write(pp, string(field1000)) dedent!(pp) write(pp, ")") end @@ -1692,45 +1692,45 @@ function pretty_decimal_type(pp::PrettyPrinter, msg::Proto.DecimalType) end function pretty_boolean_type(pp::PrettyPrinter, msg::Proto.BooleanType) - fields1000 = msg + fields1002 = msg write(pp, "BOOLEAN") return nothing end function pretty_int32_type(pp::PrettyPrinter, msg::Proto.Int32Type) - fields1001 = msg + fields1003 = msg write(pp, "INT32") return nothing end function pretty_float32_type(pp::PrettyPrinter, msg::Proto.Float32Type) - fields1002 = msg + fields1004 = msg write(pp, "FLOAT32") return nothing end function pretty_uint32_type(pp::PrettyPrinter, msg::Proto.UInt32Type) - fields1003 = msg + fields1005 = msg write(pp, "UINT32") return nothing end function pretty_value_bindings(pp::PrettyPrinter, msg::Vector{Proto.Binding}) - flat1007 = try_flat(pp, msg, pretty_value_bindings) - if !isnothing(flat1007) - write(pp, flat1007) + flat1009 = try_flat(pp, msg, pretty_value_bindings) + if !isnothing(flat1009) + write(pp, flat1009) return nothing else - fields1004 = msg + fields1006 = msg write(pp, "|") - if !isempty(fields1004) + if !isempty(fields1006) write(pp, " ") - for (i1671, elem1005) in enumerate(fields1004) - i1006 = i1671 - 1 - if (i1006 > 0) + for (i1675, elem1007) in enumerate(fields1006) + i1008 = i1675 - 1 + if (i1008 > 0) newline(pp) end - pretty_binding(pp, elem1005) + pretty_binding(pp, elem1007) end end end @@ -1738,153 +1738,153 @@ function pretty_value_bindings(pp::PrettyPrinter, msg::Vector{Proto.Binding}) end function pretty_formula(pp::PrettyPrinter, msg::Proto.Formula) - flat1034 = try_flat(pp, msg, pretty_formula) - if !isnothing(flat1034) - write(pp, flat1034) + flat1036 = try_flat(pp, msg, pretty_formula) + if !isnothing(flat1036) + write(pp, flat1036) return nothing else _dollar_dollar = msg if (_has_proto_field(_dollar_dollar, Symbol("conjunction")) && isempty(_get_oneof_field(_dollar_dollar, :conjunction).args)) - _t1672 = _get_oneof_field(_dollar_dollar, :conjunction) + _t1676 = _get_oneof_field(_dollar_dollar, :conjunction) else - _t1672 = nothing + _t1676 = nothing end - deconstruct_result1032 = _t1672 - if !isnothing(deconstruct_result1032) - unwrapped1033 = deconstruct_result1032 - pretty_true(pp, unwrapped1033) + deconstruct_result1034 = _t1676 + if !isnothing(deconstruct_result1034) + unwrapped1035 = deconstruct_result1034 + pretty_true(pp, unwrapped1035) else _dollar_dollar = msg if (_has_proto_field(_dollar_dollar, Symbol("disjunction")) && isempty(_get_oneof_field(_dollar_dollar, :disjunction).args)) - _t1673 = _get_oneof_field(_dollar_dollar, :disjunction) + _t1677 = _get_oneof_field(_dollar_dollar, :disjunction) else - _t1673 = nothing + _t1677 = nothing end - deconstruct_result1030 = _t1673 - if !isnothing(deconstruct_result1030) - unwrapped1031 = deconstruct_result1030 - pretty_false(pp, unwrapped1031) + deconstruct_result1032 = _t1677 + if !isnothing(deconstruct_result1032) + unwrapped1033 = deconstruct_result1032 + pretty_false(pp, unwrapped1033) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("exists")) - _t1674 = _get_oneof_field(_dollar_dollar, :exists) + _t1678 = _get_oneof_field(_dollar_dollar, :exists) else - _t1674 = nothing + _t1678 = nothing end - deconstruct_result1028 = _t1674 - if !isnothing(deconstruct_result1028) - unwrapped1029 = deconstruct_result1028 - pretty_exists(pp, unwrapped1029) + deconstruct_result1030 = _t1678 + if !isnothing(deconstruct_result1030) + unwrapped1031 = deconstruct_result1030 + pretty_exists(pp, unwrapped1031) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("reduce")) - _t1675 = _get_oneof_field(_dollar_dollar, :reduce) + _t1679 = _get_oneof_field(_dollar_dollar, :reduce) else - _t1675 = nothing + _t1679 = nothing end - deconstruct_result1026 = _t1675 - if !isnothing(deconstruct_result1026) - unwrapped1027 = deconstruct_result1026 - pretty_reduce(pp, unwrapped1027) + deconstruct_result1028 = _t1679 + if !isnothing(deconstruct_result1028) + unwrapped1029 = deconstruct_result1028 + pretty_reduce(pp, unwrapped1029) else _dollar_dollar = msg if (_has_proto_field(_dollar_dollar, Symbol("conjunction")) && !isempty(_get_oneof_field(_dollar_dollar, :conjunction).args)) - _t1676 = _get_oneof_field(_dollar_dollar, :conjunction) + _t1680 = _get_oneof_field(_dollar_dollar, :conjunction) else - _t1676 = nothing + _t1680 = nothing end - deconstruct_result1024 = _t1676 - if !isnothing(deconstruct_result1024) - unwrapped1025 = deconstruct_result1024 - pretty_conjunction(pp, unwrapped1025) + deconstruct_result1026 = _t1680 + if !isnothing(deconstruct_result1026) + unwrapped1027 = deconstruct_result1026 + pretty_conjunction(pp, unwrapped1027) else _dollar_dollar = msg if (_has_proto_field(_dollar_dollar, Symbol("disjunction")) && !isempty(_get_oneof_field(_dollar_dollar, :disjunction).args)) - _t1677 = _get_oneof_field(_dollar_dollar, :disjunction) + _t1681 = _get_oneof_field(_dollar_dollar, :disjunction) else - _t1677 = nothing + _t1681 = nothing end - deconstruct_result1022 = _t1677 - if !isnothing(deconstruct_result1022) - unwrapped1023 = deconstruct_result1022 - pretty_disjunction(pp, unwrapped1023) + deconstruct_result1024 = _t1681 + if !isnothing(deconstruct_result1024) + unwrapped1025 = deconstruct_result1024 + pretty_disjunction(pp, unwrapped1025) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("not")) - _t1678 = _get_oneof_field(_dollar_dollar, :not) + _t1682 = _get_oneof_field(_dollar_dollar, :not) else - _t1678 = nothing + _t1682 = nothing end - deconstruct_result1020 = _t1678 - if !isnothing(deconstruct_result1020) - unwrapped1021 = deconstruct_result1020 - pretty_not(pp, unwrapped1021) + deconstruct_result1022 = _t1682 + if !isnothing(deconstruct_result1022) + unwrapped1023 = deconstruct_result1022 + pretty_not(pp, unwrapped1023) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("ffi")) - _t1679 = _get_oneof_field(_dollar_dollar, :ffi) + _t1683 = _get_oneof_field(_dollar_dollar, :ffi) else - _t1679 = nothing + _t1683 = nothing end - deconstruct_result1018 = _t1679 - if !isnothing(deconstruct_result1018) - unwrapped1019 = deconstruct_result1018 - pretty_ffi(pp, unwrapped1019) + deconstruct_result1020 = _t1683 + if !isnothing(deconstruct_result1020) + unwrapped1021 = deconstruct_result1020 + pretty_ffi(pp, unwrapped1021) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("atom")) - _t1680 = _get_oneof_field(_dollar_dollar, :atom) + _t1684 = _get_oneof_field(_dollar_dollar, :atom) else - _t1680 = nothing + _t1684 = nothing end - deconstruct_result1016 = _t1680 - if !isnothing(deconstruct_result1016) - unwrapped1017 = deconstruct_result1016 - pretty_atom(pp, unwrapped1017) + deconstruct_result1018 = _t1684 + if !isnothing(deconstruct_result1018) + unwrapped1019 = deconstruct_result1018 + pretty_atom(pp, unwrapped1019) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("pragma")) - _t1681 = _get_oneof_field(_dollar_dollar, :pragma) + _t1685 = _get_oneof_field(_dollar_dollar, :pragma) else - _t1681 = nothing + _t1685 = nothing end - deconstruct_result1014 = _t1681 - if !isnothing(deconstruct_result1014) - unwrapped1015 = deconstruct_result1014 - pretty_pragma(pp, unwrapped1015) + deconstruct_result1016 = _t1685 + if !isnothing(deconstruct_result1016) + unwrapped1017 = deconstruct_result1016 + pretty_pragma(pp, unwrapped1017) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("primitive")) - _t1682 = _get_oneof_field(_dollar_dollar, :primitive) + _t1686 = _get_oneof_field(_dollar_dollar, :primitive) else - _t1682 = nothing + _t1686 = nothing end - deconstruct_result1012 = _t1682 - if !isnothing(deconstruct_result1012) - unwrapped1013 = deconstruct_result1012 - pretty_primitive(pp, unwrapped1013) + deconstruct_result1014 = _t1686 + if !isnothing(deconstruct_result1014) + unwrapped1015 = deconstruct_result1014 + pretty_primitive(pp, unwrapped1015) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("rel_atom")) - _t1683 = _get_oneof_field(_dollar_dollar, :rel_atom) + _t1687 = _get_oneof_field(_dollar_dollar, :rel_atom) else - _t1683 = nothing + _t1687 = nothing end - deconstruct_result1010 = _t1683 - if !isnothing(deconstruct_result1010) - unwrapped1011 = deconstruct_result1010 - pretty_rel_atom(pp, unwrapped1011) + deconstruct_result1012 = _t1687 + if !isnothing(deconstruct_result1012) + unwrapped1013 = deconstruct_result1012 + pretty_rel_atom(pp, unwrapped1013) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("cast")) - _t1684 = _get_oneof_field(_dollar_dollar, :cast) + _t1688 = _get_oneof_field(_dollar_dollar, :cast) else - _t1684 = nothing + _t1688 = nothing end - deconstruct_result1008 = _t1684 - if !isnothing(deconstruct_result1008) - unwrapped1009 = deconstruct_result1008 - pretty_cast(pp, unwrapped1009) + deconstruct_result1010 = _t1688 + if !isnothing(deconstruct_result1010) + unwrapped1011 = deconstruct_result1010 + pretty_cast(pp, unwrapped1011) else throw(ParseError("No matching rule for formula")) end @@ -1905,35 +1905,35 @@ function pretty_formula(pp::PrettyPrinter, msg::Proto.Formula) end function pretty_true(pp::PrettyPrinter, msg::Proto.Conjunction) - fields1035 = msg + fields1037 = msg write(pp, "(true)") return nothing end function pretty_false(pp::PrettyPrinter, msg::Proto.Disjunction) - fields1036 = msg + fields1038 = msg write(pp, "(false)") return nothing end function pretty_exists(pp::PrettyPrinter, msg::Proto.Exists) - flat1041 = try_flat(pp, msg, pretty_exists) - if !isnothing(flat1041) - write(pp, flat1041) + flat1043 = try_flat(pp, msg, pretty_exists) + if !isnothing(flat1043) + write(pp, flat1043) return nothing else _dollar_dollar = msg - _t1685 = deconstruct_bindings(pp, _dollar_dollar.body) - fields1037 = (_t1685, _dollar_dollar.body.value,) - unwrapped_fields1038 = fields1037 + _t1689 = deconstruct_bindings(pp, _dollar_dollar.body) + fields1039 = (_t1689, _dollar_dollar.body.value,) + unwrapped_fields1040 = fields1039 write(pp, "(exists") indent_sexp!(pp) newline(pp) - field1039 = unwrapped_fields1038[1] - pretty_bindings(pp, field1039) + field1041 = unwrapped_fields1040[1] + pretty_bindings(pp, field1041) newline(pp) - field1040 = unwrapped_fields1038[2] - pretty_formula(pp, field1040) + field1042 = unwrapped_fields1040[2] + pretty_formula(pp, field1042) dedent!(pp) write(pp, ")") end @@ -1941,25 +1941,25 @@ function pretty_exists(pp::PrettyPrinter, msg::Proto.Exists) end function pretty_reduce(pp::PrettyPrinter, msg::Proto.Reduce) - flat1047 = try_flat(pp, msg, pretty_reduce) - if !isnothing(flat1047) - write(pp, flat1047) + flat1049 = try_flat(pp, msg, pretty_reduce) + if !isnothing(flat1049) + write(pp, flat1049) return nothing else _dollar_dollar = msg - fields1042 = (_dollar_dollar.op, _dollar_dollar.body, _dollar_dollar.terms,) - unwrapped_fields1043 = fields1042 + fields1044 = (_dollar_dollar.op, _dollar_dollar.body, _dollar_dollar.terms,) + unwrapped_fields1045 = fields1044 write(pp, "(reduce") indent_sexp!(pp) newline(pp) - field1044 = unwrapped_fields1043[1] - pretty_abstraction(pp, field1044) + field1046 = unwrapped_fields1045[1] + pretty_abstraction(pp, field1046) newline(pp) - field1045 = unwrapped_fields1043[2] - pretty_abstraction(pp, field1045) + field1047 = unwrapped_fields1045[2] + pretty_abstraction(pp, field1047) newline(pp) - field1046 = unwrapped_fields1043[3] - pretty_terms(pp, field1046) + field1048 = unwrapped_fields1045[3] + pretty_terms(pp, field1048) dedent!(pp) write(pp, ")") end @@ -1967,22 +1967,22 @@ function pretty_reduce(pp::PrettyPrinter, msg::Proto.Reduce) end function pretty_terms(pp::PrettyPrinter, msg::Vector{Proto.Term}) - flat1051 = try_flat(pp, msg, pretty_terms) - if !isnothing(flat1051) - write(pp, flat1051) + flat1053 = try_flat(pp, msg, pretty_terms) + if !isnothing(flat1053) + write(pp, flat1053) return nothing else - fields1048 = msg + fields1050 = msg write(pp, "(terms") indent_sexp!(pp) - if !isempty(fields1048) + if !isempty(fields1050) newline(pp) - for (i1686, elem1049) in enumerate(fields1048) - i1050 = i1686 - 1 - if (i1050 > 0) + for (i1690, elem1051) in enumerate(fields1050) + i1052 = i1690 - 1 + if (i1052 > 0) newline(pp) end - pretty_term(pp, elem1049) + pretty_term(pp, elem1051) end end dedent!(pp) @@ -1992,32 +1992,32 @@ function pretty_terms(pp::PrettyPrinter, msg::Vector{Proto.Term}) end function pretty_term(pp::PrettyPrinter, msg::Proto.Term) - flat1056 = try_flat(pp, msg, pretty_term) - if !isnothing(flat1056) - write(pp, flat1056) + flat1058 = try_flat(pp, msg, pretty_term) + if !isnothing(flat1058) + write(pp, flat1058) return nothing else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("var")) - _t1687 = _get_oneof_field(_dollar_dollar, :var) + _t1691 = _get_oneof_field(_dollar_dollar, :var) else - _t1687 = nothing + _t1691 = nothing end - deconstruct_result1054 = _t1687 - if !isnothing(deconstruct_result1054) - unwrapped1055 = deconstruct_result1054 - pretty_var(pp, unwrapped1055) + deconstruct_result1056 = _t1691 + if !isnothing(deconstruct_result1056) + unwrapped1057 = deconstruct_result1056 + pretty_var(pp, unwrapped1057) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("constant")) - _t1688 = _get_oneof_field(_dollar_dollar, :constant) + _t1692 = _get_oneof_field(_dollar_dollar, :constant) else - _t1688 = nothing + _t1692 = nothing end - deconstruct_result1052 = _t1688 - if !isnothing(deconstruct_result1052) - unwrapped1053 = deconstruct_result1052 - pretty_value(pp, unwrapped1053) + deconstruct_result1054 = _t1692 + if !isnothing(deconstruct_result1054) + unwrapped1055 = deconstruct_result1054 + pretty_value(pp, unwrapped1055) else throw(ParseError("No matching rule for term")) end @@ -2027,158 +2027,158 @@ function pretty_term(pp::PrettyPrinter, msg::Proto.Term) end function pretty_var(pp::PrettyPrinter, msg::Proto.Var) - flat1059 = try_flat(pp, msg, pretty_var) - if !isnothing(flat1059) - write(pp, flat1059) + flat1061 = try_flat(pp, msg, pretty_var) + if !isnothing(flat1061) + write(pp, flat1061) return nothing else _dollar_dollar = msg - fields1057 = _dollar_dollar.name - unwrapped_fields1058 = fields1057 - write(pp, unwrapped_fields1058) + fields1059 = _dollar_dollar.name + unwrapped_fields1060 = fields1059 + write(pp, unwrapped_fields1060) end return nothing end function pretty_value(pp::PrettyPrinter, msg::Proto.Value) - flat1085 = try_flat(pp, msg, pretty_value) - if !isnothing(flat1085) - write(pp, flat1085) + flat1087 = try_flat(pp, msg, pretty_value) + if !isnothing(flat1087) + write(pp, flat1087) return nothing else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("date_value")) - _t1689 = _get_oneof_field(_dollar_dollar, :date_value) + _t1693 = _get_oneof_field(_dollar_dollar, :date_value) else - _t1689 = nothing + _t1693 = nothing end - deconstruct_result1083 = _t1689 - if !isnothing(deconstruct_result1083) - unwrapped1084 = deconstruct_result1083 - pretty_date(pp, unwrapped1084) + deconstruct_result1085 = _t1693 + if !isnothing(deconstruct_result1085) + unwrapped1086 = deconstruct_result1085 + pretty_date(pp, unwrapped1086) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("datetime_value")) - _t1690 = _get_oneof_field(_dollar_dollar, :datetime_value) + _t1694 = _get_oneof_field(_dollar_dollar, :datetime_value) else - _t1690 = nothing + _t1694 = nothing end - deconstruct_result1081 = _t1690 - if !isnothing(deconstruct_result1081) - unwrapped1082 = deconstruct_result1081 - pretty_datetime(pp, unwrapped1082) + deconstruct_result1083 = _t1694 + if !isnothing(deconstruct_result1083) + unwrapped1084 = deconstruct_result1083 + pretty_datetime(pp, unwrapped1084) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("string_value")) - _t1691 = _get_oneof_field(_dollar_dollar, :string_value) + _t1695 = _get_oneof_field(_dollar_dollar, :string_value) else - _t1691 = nothing + _t1695 = nothing end - deconstruct_result1079 = _t1691 - if !isnothing(deconstruct_result1079) - unwrapped1080 = deconstruct_result1079 - write(pp, format_string(pp, unwrapped1080)) + deconstruct_result1081 = _t1695 + if !isnothing(deconstruct_result1081) + unwrapped1082 = deconstruct_result1081 + write(pp, format_string(pp, unwrapped1082)) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("int32_value")) - _t1692 = _get_oneof_field(_dollar_dollar, :int32_value) + _t1696 = _get_oneof_field(_dollar_dollar, :int32_value) else - _t1692 = nothing + _t1696 = nothing end - deconstruct_result1077 = _t1692 - if !isnothing(deconstruct_result1077) - unwrapped1078 = deconstruct_result1077 - write(pp, format_int32(pp, unwrapped1078)) + deconstruct_result1079 = _t1696 + if !isnothing(deconstruct_result1079) + unwrapped1080 = deconstruct_result1079 + write(pp, format_int32(pp, unwrapped1080)) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("int_value")) - _t1693 = _get_oneof_field(_dollar_dollar, :int_value) + _t1697 = _get_oneof_field(_dollar_dollar, :int_value) else - _t1693 = nothing + _t1697 = nothing end - deconstruct_result1075 = _t1693 - if !isnothing(deconstruct_result1075) - unwrapped1076 = deconstruct_result1075 - write(pp, format_int(pp, unwrapped1076)) + deconstruct_result1077 = _t1697 + if !isnothing(deconstruct_result1077) + unwrapped1078 = deconstruct_result1077 + write(pp, format_int(pp, unwrapped1078)) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("float32_value")) - _t1694 = _get_oneof_field(_dollar_dollar, :float32_value) + _t1698 = _get_oneof_field(_dollar_dollar, :float32_value) else - _t1694 = nothing + _t1698 = nothing end - deconstruct_result1073 = _t1694 - if !isnothing(deconstruct_result1073) - unwrapped1074 = deconstruct_result1073 - write(pp, format_float32(pp, unwrapped1074)) + deconstruct_result1075 = _t1698 + if !isnothing(deconstruct_result1075) + unwrapped1076 = deconstruct_result1075 + write(pp, format_float32(pp, unwrapped1076)) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("float_value")) - _t1695 = _get_oneof_field(_dollar_dollar, :float_value) + _t1699 = _get_oneof_field(_dollar_dollar, :float_value) else - _t1695 = nothing + _t1699 = nothing end - deconstruct_result1071 = _t1695 - if !isnothing(deconstruct_result1071) - unwrapped1072 = deconstruct_result1071 - write(pp, format_float(pp, unwrapped1072)) + deconstruct_result1073 = _t1699 + if !isnothing(deconstruct_result1073) + unwrapped1074 = deconstruct_result1073 + write(pp, format_float(pp, unwrapped1074)) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("uint32_value")) - _t1696 = _get_oneof_field(_dollar_dollar, :uint32_value) + _t1700 = _get_oneof_field(_dollar_dollar, :uint32_value) else - _t1696 = nothing + _t1700 = nothing end - deconstruct_result1069 = _t1696 - if !isnothing(deconstruct_result1069) - unwrapped1070 = deconstruct_result1069 - write(pp, format_uint32(pp, unwrapped1070)) + deconstruct_result1071 = _t1700 + if !isnothing(deconstruct_result1071) + unwrapped1072 = deconstruct_result1071 + write(pp, format_uint32(pp, unwrapped1072)) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("uint128_value")) - _t1697 = _get_oneof_field(_dollar_dollar, :uint128_value) + _t1701 = _get_oneof_field(_dollar_dollar, :uint128_value) else - _t1697 = nothing + _t1701 = nothing end - deconstruct_result1067 = _t1697 - if !isnothing(deconstruct_result1067) - unwrapped1068 = deconstruct_result1067 - write(pp, format_uint128(pp, unwrapped1068)) + deconstruct_result1069 = _t1701 + if !isnothing(deconstruct_result1069) + unwrapped1070 = deconstruct_result1069 + write(pp, format_uint128(pp, unwrapped1070)) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("int128_value")) - _t1698 = _get_oneof_field(_dollar_dollar, :int128_value) + _t1702 = _get_oneof_field(_dollar_dollar, :int128_value) else - _t1698 = nothing + _t1702 = nothing end - deconstruct_result1065 = _t1698 - if !isnothing(deconstruct_result1065) - unwrapped1066 = deconstruct_result1065 - write(pp, format_int128(pp, unwrapped1066)) + deconstruct_result1067 = _t1702 + if !isnothing(deconstruct_result1067) + unwrapped1068 = deconstruct_result1067 + write(pp, format_int128(pp, unwrapped1068)) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("decimal_value")) - _t1699 = _get_oneof_field(_dollar_dollar, :decimal_value) + _t1703 = _get_oneof_field(_dollar_dollar, :decimal_value) else - _t1699 = nothing + _t1703 = nothing end - deconstruct_result1063 = _t1699 - if !isnothing(deconstruct_result1063) - unwrapped1064 = deconstruct_result1063 - write(pp, format_decimal(pp, unwrapped1064)) + deconstruct_result1065 = _t1703 + if !isnothing(deconstruct_result1065) + unwrapped1066 = deconstruct_result1065 + write(pp, format_decimal(pp, unwrapped1066)) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("boolean_value")) - _t1700 = _get_oneof_field(_dollar_dollar, :boolean_value) + _t1704 = _get_oneof_field(_dollar_dollar, :boolean_value) else - _t1700 = nothing + _t1704 = nothing end - deconstruct_result1061 = _t1700 - if !isnothing(deconstruct_result1061) - unwrapped1062 = deconstruct_result1061 - pretty_boolean_value(pp, unwrapped1062) + deconstruct_result1063 = _t1704 + if !isnothing(deconstruct_result1063) + unwrapped1064 = deconstruct_result1063 + pretty_boolean_value(pp, unwrapped1064) else - fields1060 = msg + fields1062 = msg write(pp, "missing") end end @@ -2197,25 +2197,25 @@ function pretty_value(pp::PrettyPrinter, msg::Proto.Value) end function pretty_date(pp::PrettyPrinter, msg::Proto.DateValue) - flat1091 = try_flat(pp, msg, pretty_date) - if !isnothing(flat1091) - write(pp, flat1091) + flat1093 = try_flat(pp, msg, pretty_date) + if !isnothing(flat1093) + write(pp, flat1093) return nothing else _dollar_dollar = msg - fields1086 = (Int64(_dollar_dollar.year), Int64(_dollar_dollar.month), Int64(_dollar_dollar.day),) - unwrapped_fields1087 = fields1086 + fields1088 = (Int64(_dollar_dollar.year), Int64(_dollar_dollar.month), Int64(_dollar_dollar.day),) + unwrapped_fields1089 = fields1088 write(pp, "(date") indent_sexp!(pp) newline(pp) - field1088 = unwrapped_fields1087[1] - write(pp, format_int(pp, field1088)) + field1090 = unwrapped_fields1089[1] + write(pp, format_int(pp, field1090)) newline(pp) - field1089 = unwrapped_fields1087[2] - write(pp, format_int(pp, field1089)) + field1091 = unwrapped_fields1089[2] + write(pp, format_int(pp, field1091)) newline(pp) - field1090 = unwrapped_fields1087[3] - write(pp, format_int(pp, field1090)) + field1092 = unwrapped_fields1089[3] + write(pp, format_int(pp, field1092)) dedent!(pp) write(pp, ")") end @@ -2223,39 +2223,39 @@ function pretty_date(pp::PrettyPrinter, msg::Proto.DateValue) end function pretty_datetime(pp::PrettyPrinter, msg::Proto.DateTimeValue) - flat1102 = try_flat(pp, msg, pretty_datetime) - if !isnothing(flat1102) - write(pp, flat1102) + flat1104 = try_flat(pp, msg, pretty_datetime) + if !isnothing(flat1104) + write(pp, flat1104) return nothing else _dollar_dollar = msg - fields1092 = (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_fields1093 = fields1092 + fields1094 = (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_fields1095 = fields1094 write(pp, "(datetime") indent_sexp!(pp) newline(pp) - field1094 = unwrapped_fields1093[1] - write(pp, format_int(pp, field1094)) - newline(pp) - field1095 = unwrapped_fields1093[2] - write(pp, format_int(pp, field1095)) - newline(pp) - field1096 = unwrapped_fields1093[3] + field1096 = unwrapped_fields1095[1] write(pp, format_int(pp, field1096)) newline(pp) - field1097 = unwrapped_fields1093[4] + field1097 = unwrapped_fields1095[2] write(pp, format_int(pp, field1097)) newline(pp) - field1098 = unwrapped_fields1093[5] + field1098 = unwrapped_fields1095[3] write(pp, format_int(pp, field1098)) newline(pp) - field1099 = unwrapped_fields1093[6] + field1099 = unwrapped_fields1095[4] write(pp, format_int(pp, field1099)) - field1100 = unwrapped_fields1093[7] - if !isnothing(field1100) + newline(pp) + field1100 = unwrapped_fields1095[5] + write(pp, format_int(pp, field1100)) + newline(pp) + field1101 = unwrapped_fields1095[6] + write(pp, format_int(pp, field1101)) + field1102 = unwrapped_fields1095[7] + if !isnothing(field1102) newline(pp) - opt_val1101 = field1100 - write(pp, format_int(pp, opt_val1101)) + opt_val1103 = field1102 + write(pp, format_int(pp, opt_val1103)) end dedent!(pp) write(pp, ")") @@ -2264,24 +2264,24 @@ function pretty_datetime(pp::PrettyPrinter, msg::Proto.DateTimeValue) end function pretty_conjunction(pp::PrettyPrinter, msg::Proto.Conjunction) - flat1107 = try_flat(pp, msg, pretty_conjunction) - if !isnothing(flat1107) - write(pp, flat1107) + flat1109 = try_flat(pp, msg, pretty_conjunction) + if !isnothing(flat1109) + write(pp, flat1109) return nothing else _dollar_dollar = msg - fields1103 = _dollar_dollar.args - unwrapped_fields1104 = fields1103 + fields1105 = _dollar_dollar.args + unwrapped_fields1106 = fields1105 write(pp, "(and") indent_sexp!(pp) - if !isempty(unwrapped_fields1104) + if !isempty(unwrapped_fields1106) newline(pp) - for (i1701, elem1105) in enumerate(unwrapped_fields1104) - i1106 = i1701 - 1 - if (i1106 > 0) + for (i1705, elem1107) in enumerate(unwrapped_fields1106) + i1108 = i1705 - 1 + if (i1108 > 0) newline(pp) end - pretty_formula(pp, elem1105) + pretty_formula(pp, elem1107) end end dedent!(pp) @@ -2291,24 +2291,24 @@ function pretty_conjunction(pp::PrettyPrinter, msg::Proto.Conjunction) end function pretty_disjunction(pp::PrettyPrinter, msg::Proto.Disjunction) - flat1112 = try_flat(pp, msg, pretty_disjunction) - if !isnothing(flat1112) - write(pp, flat1112) + flat1114 = try_flat(pp, msg, pretty_disjunction) + if !isnothing(flat1114) + write(pp, flat1114) return nothing else _dollar_dollar = msg - fields1108 = _dollar_dollar.args - unwrapped_fields1109 = fields1108 + fields1110 = _dollar_dollar.args + unwrapped_fields1111 = fields1110 write(pp, "(or") indent_sexp!(pp) - if !isempty(unwrapped_fields1109) + if !isempty(unwrapped_fields1111) newline(pp) - for (i1702, elem1110) in enumerate(unwrapped_fields1109) - i1111 = i1702 - 1 - if (i1111 > 0) + for (i1706, elem1112) in enumerate(unwrapped_fields1111) + i1113 = i1706 - 1 + if (i1113 > 0) newline(pp) end - pretty_formula(pp, elem1110) + pretty_formula(pp, elem1112) end end dedent!(pp) @@ -2318,18 +2318,18 @@ function pretty_disjunction(pp::PrettyPrinter, msg::Proto.Disjunction) end function pretty_not(pp::PrettyPrinter, msg::Proto.Not) - flat1115 = try_flat(pp, msg, pretty_not) - if !isnothing(flat1115) - write(pp, flat1115) + flat1117 = try_flat(pp, msg, pretty_not) + if !isnothing(flat1117) + write(pp, flat1117) return nothing else _dollar_dollar = msg - fields1113 = _dollar_dollar.arg - unwrapped_fields1114 = fields1113 + fields1115 = _dollar_dollar.arg + unwrapped_fields1116 = fields1115 write(pp, "(not") indent_sexp!(pp) newline(pp) - pretty_formula(pp, unwrapped_fields1114) + pretty_formula(pp, unwrapped_fields1116) dedent!(pp) write(pp, ")") end @@ -2337,25 +2337,25 @@ function pretty_not(pp::PrettyPrinter, msg::Proto.Not) end function pretty_ffi(pp::PrettyPrinter, msg::Proto.FFI) - flat1121 = try_flat(pp, msg, pretty_ffi) - if !isnothing(flat1121) - write(pp, flat1121) + flat1123 = try_flat(pp, msg, pretty_ffi) + if !isnothing(flat1123) + write(pp, flat1123) return nothing else _dollar_dollar = msg - fields1116 = (_dollar_dollar.name, _dollar_dollar.args, _dollar_dollar.terms,) - unwrapped_fields1117 = fields1116 + fields1118 = (_dollar_dollar.name, _dollar_dollar.args, _dollar_dollar.terms,) + unwrapped_fields1119 = fields1118 write(pp, "(ffi") indent_sexp!(pp) newline(pp) - field1118 = unwrapped_fields1117[1] - pretty_name(pp, field1118) + field1120 = unwrapped_fields1119[1] + pretty_name(pp, field1120) newline(pp) - field1119 = unwrapped_fields1117[2] - pretty_ffi_args(pp, field1119) + field1121 = unwrapped_fields1119[2] + pretty_ffi_args(pp, field1121) newline(pp) - field1120 = unwrapped_fields1117[3] - pretty_terms(pp, field1120) + field1122 = unwrapped_fields1119[3] + pretty_terms(pp, field1122) dedent!(pp) write(pp, ")") end @@ -2363,35 +2363,35 @@ function pretty_ffi(pp::PrettyPrinter, msg::Proto.FFI) end function pretty_name(pp::PrettyPrinter, msg::String) - flat1123 = try_flat(pp, msg, pretty_name) - if !isnothing(flat1123) - write(pp, flat1123) + flat1125 = try_flat(pp, msg, pretty_name) + if !isnothing(flat1125) + write(pp, flat1125) return nothing else - fields1122 = msg + fields1124 = msg write(pp, ":") - write(pp, fields1122) + write(pp, fields1124) end return nothing end function pretty_ffi_args(pp::PrettyPrinter, msg::Vector{Proto.Abstraction}) - flat1127 = try_flat(pp, msg, pretty_ffi_args) - if !isnothing(flat1127) - write(pp, flat1127) + flat1129 = try_flat(pp, msg, pretty_ffi_args) + if !isnothing(flat1129) + write(pp, flat1129) return nothing else - fields1124 = msg + fields1126 = msg write(pp, "(args") indent_sexp!(pp) - if !isempty(fields1124) + if !isempty(fields1126) newline(pp) - for (i1703, elem1125) in enumerate(fields1124) - i1126 = i1703 - 1 - if (i1126 > 0) + for (i1707, elem1127) in enumerate(fields1126) + i1128 = i1707 - 1 + if (i1128 > 0) newline(pp) end - pretty_abstraction(pp, elem1125) + pretty_abstraction(pp, elem1127) end end dedent!(pp) @@ -2401,28 +2401,28 @@ function pretty_ffi_args(pp::PrettyPrinter, msg::Vector{Proto.Abstraction}) end function pretty_atom(pp::PrettyPrinter, msg::Proto.Atom) - flat1134 = try_flat(pp, msg, pretty_atom) - if !isnothing(flat1134) - write(pp, flat1134) + flat1136 = try_flat(pp, msg, pretty_atom) + if !isnothing(flat1136) + write(pp, flat1136) return nothing else _dollar_dollar = msg - fields1128 = (_dollar_dollar.name, _dollar_dollar.terms,) - unwrapped_fields1129 = fields1128 + fields1130 = (_dollar_dollar.name, _dollar_dollar.terms,) + unwrapped_fields1131 = fields1130 write(pp, "(atom") indent_sexp!(pp) newline(pp) - field1130 = unwrapped_fields1129[1] - pretty_relation_id(pp, field1130) - field1131 = unwrapped_fields1129[2] - if !isempty(field1131) + field1132 = unwrapped_fields1131[1] + pretty_relation_id(pp, field1132) + field1133 = unwrapped_fields1131[2] + if !isempty(field1133) newline(pp) - for (i1704, elem1132) in enumerate(field1131) - i1133 = i1704 - 1 - if (i1133 > 0) + for (i1708, elem1134) in enumerate(field1133) + i1135 = i1708 - 1 + if (i1135 > 0) newline(pp) end - pretty_term(pp, elem1132) + pretty_term(pp, elem1134) end end dedent!(pp) @@ -2432,28 +2432,28 @@ function pretty_atom(pp::PrettyPrinter, msg::Proto.Atom) end function pretty_pragma(pp::PrettyPrinter, msg::Proto.Pragma) - flat1141 = try_flat(pp, msg, pretty_pragma) - if !isnothing(flat1141) - write(pp, flat1141) + flat1143 = try_flat(pp, msg, pretty_pragma) + if !isnothing(flat1143) + write(pp, flat1143) return nothing else _dollar_dollar = msg - fields1135 = (_dollar_dollar.name, _dollar_dollar.terms,) - unwrapped_fields1136 = fields1135 + fields1137 = (_dollar_dollar.name, _dollar_dollar.terms,) + unwrapped_fields1138 = fields1137 write(pp, "(pragma") indent_sexp!(pp) newline(pp) - field1137 = unwrapped_fields1136[1] - pretty_name(pp, field1137) - field1138 = unwrapped_fields1136[2] - if !isempty(field1138) + field1139 = unwrapped_fields1138[1] + pretty_name(pp, field1139) + field1140 = unwrapped_fields1138[2] + if !isempty(field1140) newline(pp) - for (i1705, elem1139) in enumerate(field1138) - i1140 = i1705 - 1 - if (i1140 > 0) + for (i1709, elem1141) in enumerate(field1140) + i1142 = i1709 - 1 + if (i1142 > 0) newline(pp) end - pretty_term(pp, elem1139) + pretty_term(pp, elem1141) end end dedent!(pp) @@ -2463,118 +2463,118 @@ function pretty_pragma(pp::PrettyPrinter, msg::Proto.Pragma) end function pretty_primitive(pp::PrettyPrinter, msg::Proto.Primitive) - flat1157 = try_flat(pp, msg, pretty_primitive) - if !isnothing(flat1157) - write(pp, flat1157) + flat1159 = try_flat(pp, msg, pretty_primitive) + if !isnothing(flat1159) + write(pp, flat1159) return nothing else _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_eq" - _t1706 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) + _t1710 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) else - _t1706 = nothing + _t1710 = nothing end - guard_result1156 = _t1706 - if !isnothing(guard_result1156) + guard_result1158 = _t1710 + if !isnothing(guard_result1158) pretty_eq(pp, msg) else _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_lt_monotype" - _t1707 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) + _t1711 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) else - _t1707 = nothing + _t1711 = nothing end - guard_result1155 = _t1707 - if !isnothing(guard_result1155) + guard_result1157 = _t1711 + if !isnothing(guard_result1157) pretty_lt(pp, msg) else _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_lt_eq_monotype" - _t1708 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) + _t1712 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) else - _t1708 = nothing + _t1712 = nothing end - guard_result1154 = _t1708 - if !isnothing(guard_result1154) + guard_result1156 = _t1712 + if !isnothing(guard_result1156) pretty_lt_eq(pp, msg) else _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_gt_monotype" - _t1709 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) + _t1713 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) else - _t1709 = nothing + _t1713 = nothing end - guard_result1153 = _t1709 - if !isnothing(guard_result1153) + guard_result1155 = _t1713 + if !isnothing(guard_result1155) pretty_gt(pp, msg) else _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_gt_eq_monotype" - _t1710 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) + _t1714 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) else - _t1710 = nothing + _t1714 = nothing end - guard_result1152 = _t1710 - if !isnothing(guard_result1152) + guard_result1154 = _t1714 + if !isnothing(guard_result1154) pretty_gt_eq(pp, msg) else _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_add_monotype" - _t1711 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term), _get_oneof_field(_dollar_dollar.terms[3], :term),) + _t1715 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term), _get_oneof_field(_dollar_dollar.terms[3], :term),) else - _t1711 = nothing + _t1715 = nothing end - guard_result1151 = _t1711 - if !isnothing(guard_result1151) + guard_result1153 = _t1715 + if !isnothing(guard_result1153) pretty_add(pp, msg) else _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_subtract_monotype" - _t1712 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term), _get_oneof_field(_dollar_dollar.terms[3], :term),) + _t1716 = (_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 - _t1712 = nothing + _t1716 = nothing end - guard_result1150 = _t1712 - if !isnothing(guard_result1150) + guard_result1152 = _t1716 + if !isnothing(guard_result1152) pretty_minus(pp, msg) else _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_multiply_monotype" - _t1713 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term), _get_oneof_field(_dollar_dollar.terms[3], :term),) + _t1717 = (_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 - _t1713 = nothing + _t1717 = nothing end - guard_result1149 = _t1713 - if !isnothing(guard_result1149) + guard_result1151 = _t1717 + if !isnothing(guard_result1151) pretty_multiply(pp, msg) else _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_divide_monotype" - _t1714 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term), _get_oneof_field(_dollar_dollar.terms[3], :term),) + _t1718 = (_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 - _t1714 = nothing + _t1718 = nothing end - guard_result1148 = _t1714 - if !isnothing(guard_result1148) + guard_result1150 = _t1718 + if !isnothing(guard_result1150) pretty_divide(pp, msg) else _dollar_dollar = msg - fields1142 = (_dollar_dollar.name, _dollar_dollar.terms,) - unwrapped_fields1143 = fields1142 + fields1144 = (_dollar_dollar.name, _dollar_dollar.terms,) + unwrapped_fields1145 = fields1144 write(pp, "(primitive") indent_sexp!(pp) newline(pp) - field1144 = unwrapped_fields1143[1] - pretty_name(pp, field1144) - field1145 = unwrapped_fields1143[2] - if !isempty(field1145) + field1146 = unwrapped_fields1145[1] + pretty_name(pp, field1146) + field1147 = unwrapped_fields1145[2] + if !isempty(field1147) newline(pp) - for (i1715, elem1146) in enumerate(field1145) - i1147 = i1715 - 1 - if (i1147 > 0) + for (i1719, elem1148) in enumerate(field1147) + i1149 = i1719 - 1 + if (i1149 > 0) newline(pp) end - pretty_rel_term(pp, elem1146) + pretty_rel_term(pp, elem1148) end end dedent!(pp) @@ -2593,27 +2593,27 @@ function pretty_primitive(pp::PrettyPrinter, msg::Proto.Primitive) end function pretty_eq(pp::PrettyPrinter, msg::Proto.Primitive) - flat1162 = try_flat(pp, msg, pretty_eq) - if !isnothing(flat1162) - write(pp, flat1162) + flat1164 = try_flat(pp, msg, pretty_eq) + if !isnothing(flat1164) + write(pp, flat1164) return nothing else _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_eq" - _t1716 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) + _t1720 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) else - _t1716 = nothing + _t1720 = nothing end - fields1158 = _t1716 - unwrapped_fields1159 = fields1158 + fields1160 = _t1720 + unwrapped_fields1161 = fields1160 write(pp, "(=") indent_sexp!(pp) newline(pp) - field1160 = unwrapped_fields1159[1] - pretty_term(pp, field1160) + field1162 = unwrapped_fields1161[1] + pretty_term(pp, field1162) newline(pp) - field1161 = unwrapped_fields1159[2] - pretty_term(pp, field1161) + field1163 = unwrapped_fields1161[2] + pretty_term(pp, field1163) dedent!(pp) write(pp, ")") end @@ -2621,27 +2621,27 @@ function pretty_eq(pp::PrettyPrinter, msg::Proto.Primitive) end function pretty_lt(pp::PrettyPrinter, msg::Proto.Primitive) - flat1167 = try_flat(pp, msg, pretty_lt) - if !isnothing(flat1167) - write(pp, flat1167) + flat1169 = try_flat(pp, msg, pretty_lt) + if !isnothing(flat1169) + write(pp, flat1169) return nothing else _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_lt_monotype" - _t1717 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) + _t1721 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) else - _t1717 = nothing + _t1721 = nothing end - fields1163 = _t1717 - unwrapped_fields1164 = fields1163 + fields1165 = _t1721 + unwrapped_fields1166 = fields1165 write(pp, "(<") indent_sexp!(pp) newline(pp) - field1165 = unwrapped_fields1164[1] - pretty_term(pp, field1165) + field1167 = unwrapped_fields1166[1] + pretty_term(pp, field1167) newline(pp) - field1166 = unwrapped_fields1164[2] - pretty_term(pp, field1166) + field1168 = unwrapped_fields1166[2] + pretty_term(pp, field1168) dedent!(pp) write(pp, ")") end @@ -2649,27 +2649,27 @@ function pretty_lt(pp::PrettyPrinter, msg::Proto.Primitive) end function pretty_lt_eq(pp::PrettyPrinter, msg::Proto.Primitive) - flat1172 = try_flat(pp, msg, pretty_lt_eq) - if !isnothing(flat1172) - write(pp, flat1172) + flat1174 = try_flat(pp, msg, pretty_lt_eq) + if !isnothing(flat1174) + write(pp, flat1174) return nothing else _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_lt_eq_monotype" - _t1718 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) + _t1722 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) else - _t1718 = nothing + _t1722 = nothing end - fields1168 = _t1718 - unwrapped_fields1169 = fields1168 + fields1170 = _t1722 + unwrapped_fields1171 = fields1170 write(pp, "(<=") indent_sexp!(pp) newline(pp) - field1170 = unwrapped_fields1169[1] - pretty_term(pp, field1170) + field1172 = unwrapped_fields1171[1] + pretty_term(pp, field1172) newline(pp) - field1171 = unwrapped_fields1169[2] - pretty_term(pp, field1171) + field1173 = unwrapped_fields1171[2] + pretty_term(pp, field1173) dedent!(pp) write(pp, ")") end @@ -2677,27 +2677,27 @@ function pretty_lt_eq(pp::PrettyPrinter, msg::Proto.Primitive) end function pretty_gt(pp::PrettyPrinter, msg::Proto.Primitive) - flat1177 = try_flat(pp, msg, pretty_gt) - if !isnothing(flat1177) - write(pp, flat1177) + flat1179 = try_flat(pp, msg, pretty_gt) + if !isnothing(flat1179) + write(pp, flat1179) return nothing else _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_gt_monotype" - _t1719 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) + _t1723 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) else - _t1719 = nothing + _t1723 = nothing end - fields1173 = _t1719 - unwrapped_fields1174 = fields1173 + fields1175 = _t1723 + unwrapped_fields1176 = fields1175 write(pp, "(>") indent_sexp!(pp) newline(pp) - field1175 = unwrapped_fields1174[1] - pretty_term(pp, field1175) + field1177 = unwrapped_fields1176[1] + pretty_term(pp, field1177) newline(pp) - field1176 = unwrapped_fields1174[2] - pretty_term(pp, field1176) + field1178 = unwrapped_fields1176[2] + pretty_term(pp, field1178) dedent!(pp) write(pp, ")") end @@ -2705,27 +2705,27 @@ function pretty_gt(pp::PrettyPrinter, msg::Proto.Primitive) end function pretty_gt_eq(pp::PrettyPrinter, msg::Proto.Primitive) - flat1182 = try_flat(pp, msg, pretty_gt_eq) - if !isnothing(flat1182) - write(pp, flat1182) + flat1184 = try_flat(pp, msg, pretty_gt_eq) + if !isnothing(flat1184) + write(pp, flat1184) return nothing else _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_gt_eq_monotype" - _t1720 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) + _t1724 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) else - _t1720 = nothing + _t1724 = nothing end - fields1178 = _t1720 - unwrapped_fields1179 = fields1178 + fields1180 = _t1724 + unwrapped_fields1181 = fields1180 write(pp, "(>=") indent_sexp!(pp) newline(pp) - field1180 = unwrapped_fields1179[1] - pretty_term(pp, field1180) + field1182 = unwrapped_fields1181[1] + pretty_term(pp, field1182) newline(pp) - field1181 = unwrapped_fields1179[2] - pretty_term(pp, field1181) + field1183 = unwrapped_fields1181[2] + pretty_term(pp, field1183) dedent!(pp) write(pp, ")") end @@ -2733,30 +2733,30 @@ function pretty_gt_eq(pp::PrettyPrinter, msg::Proto.Primitive) end function pretty_add(pp::PrettyPrinter, msg::Proto.Primitive) - flat1188 = try_flat(pp, msg, pretty_add) - if !isnothing(flat1188) - write(pp, flat1188) + flat1190 = try_flat(pp, msg, pretty_add) + if !isnothing(flat1190) + write(pp, flat1190) return nothing else _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_add_monotype" - _t1721 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term), _get_oneof_field(_dollar_dollar.terms[3], :term),) + _t1725 = (_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 - _t1721 = nothing + _t1725 = nothing end - fields1183 = _t1721 - unwrapped_fields1184 = fields1183 + fields1185 = _t1725 + unwrapped_fields1186 = fields1185 write(pp, "(+") indent_sexp!(pp) newline(pp) - field1185 = unwrapped_fields1184[1] - pretty_term(pp, field1185) + field1187 = unwrapped_fields1186[1] + pretty_term(pp, field1187) newline(pp) - field1186 = unwrapped_fields1184[2] - pretty_term(pp, field1186) + field1188 = unwrapped_fields1186[2] + pretty_term(pp, field1188) newline(pp) - field1187 = unwrapped_fields1184[3] - pretty_term(pp, field1187) + field1189 = unwrapped_fields1186[3] + pretty_term(pp, field1189) dedent!(pp) write(pp, ")") end @@ -2764,30 +2764,30 @@ function pretty_add(pp::PrettyPrinter, msg::Proto.Primitive) end function pretty_minus(pp::PrettyPrinter, msg::Proto.Primitive) - flat1194 = try_flat(pp, msg, pretty_minus) - if !isnothing(flat1194) - write(pp, flat1194) + flat1196 = try_flat(pp, msg, pretty_minus) + if !isnothing(flat1196) + write(pp, flat1196) return nothing else _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_subtract_monotype" - _t1722 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term), _get_oneof_field(_dollar_dollar.terms[3], :term),) + _t1726 = (_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 - _t1722 = nothing + _t1726 = nothing end - fields1189 = _t1722 - unwrapped_fields1190 = fields1189 + fields1191 = _t1726 + unwrapped_fields1192 = fields1191 write(pp, "(-") indent_sexp!(pp) newline(pp) - field1191 = unwrapped_fields1190[1] - pretty_term(pp, field1191) + field1193 = unwrapped_fields1192[1] + pretty_term(pp, field1193) newline(pp) - field1192 = unwrapped_fields1190[2] - pretty_term(pp, field1192) + field1194 = unwrapped_fields1192[2] + pretty_term(pp, field1194) newline(pp) - field1193 = unwrapped_fields1190[3] - pretty_term(pp, field1193) + field1195 = unwrapped_fields1192[3] + pretty_term(pp, field1195) dedent!(pp) write(pp, ")") end @@ -2795,30 +2795,30 @@ function pretty_minus(pp::PrettyPrinter, msg::Proto.Primitive) end function pretty_multiply(pp::PrettyPrinter, msg::Proto.Primitive) - flat1200 = try_flat(pp, msg, pretty_multiply) - if !isnothing(flat1200) - write(pp, flat1200) + flat1202 = try_flat(pp, msg, pretty_multiply) + if !isnothing(flat1202) + write(pp, flat1202) return nothing else _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_multiply_monotype" - _t1723 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term), _get_oneof_field(_dollar_dollar.terms[3], :term),) + _t1727 = (_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 - _t1723 = nothing + _t1727 = nothing end - fields1195 = _t1723 - unwrapped_fields1196 = fields1195 + fields1197 = _t1727 + unwrapped_fields1198 = fields1197 write(pp, "(*") indent_sexp!(pp) newline(pp) - field1197 = unwrapped_fields1196[1] - pretty_term(pp, field1197) + field1199 = unwrapped_fields1198[1] + pretty_term(pp, field1199) newline(pp) - field1198 = unwrapped_fields1196[2] - pretty_term(pp, field1198) + field1200 = unwrapped_fields1198[2] + pretty_term(pp, field1200) newline(pp) - field1199 = unwrapped_fields1196[3] - pretty_term(pp, field1199) + field1201 = unwrapped_fields1198[3] + pretty_term(pp, field1201) dedent!(pp) write(pp, ")") end @@ -2826,30 +2826,30 @@ function pretty_multiply(pp::PrettyPrinter, msg::Proto.Primitive) end function pretty_divide(pp::PrettyPrinter, msg::Proto.Primitive) - flat1206 = try_flat(pp, msg, pretty_divide) - if !isnothing(flat1206) - write(pp, flat1206) + flat1208 = try_flat(pp, msg, pretty_divide) + if !isnothing(flat1208) + write(pp, flat1208) return nothing else _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_divide_monotype" - _t1724 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term), _get_oneof_field(_dollar_dollar.terms[3], :term),) + _t1728 = (_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 - _t1724 = nothing + _t1728 = nothing end - fields1201 = _t1724 - unwrapped_fields1202 = fields1201 + fields1203 = _t1728 + unwrapped_fields1204 = fields1203 write(pp, "(/") indent_sexp!(pp) newline(pp) - field1203 = unwrapped_fields1202[1] - pretty_term(pp, field1203) + field1205 = unwrapped_fields1204[1] + pretty_term(pp, field1205) newline(pp) - field1204 = unwrapped_fields1202[2] - pretty_term(pp, field1204) + field1206 = unwrapped_fields1204[2] + pretty_term(pp, field1206) newline(pp) - field1205 = unwrapped_fields1202[3] - pretty_term(pp, field1205) + field1207 = unwrapped_fields1204[3] + pretty_term(pp, field1207) dedent!(pp) write(pp, ")") end @@ -2857,32 +2857,32 @@ function pretty_divide(pp::PrettyPrinter, msg::Proto.Primitive) end function pretty_rel_term(pp::PrettyPrinter, msg::Proto.RelTerm) - flat1211 = try_flat(pp, msg, pretty_rel_term) - if !isnothing(flat1211) - write(pp, flat1211) + flat1213 = try_flat(pp, msg, pretty_rel_term) + if !isnothing(flat1213) + write(pp, flat1213) return nothing else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("specialized_value")) - _t1725 = _get_oneof_field(_dollar_dollar, :specialized_value) + _t1729 = _get_oneof_field(_dollar_dollar, :specialized_value) else - _t1725 = nothing + _t1729 = nothing end - deconstruct_result1209 = _t1725 - if !isnothing(deconstruct_result1209) - unwrapped1210 = deconstruct_result1209 - pretty_specialized_value(pp, unwrapped1210) + deconstruct_result1211 = _t1729 + if !isnothing(deconstruct_result1211) + unwrapped1212 = deconstruct_result1211 + pretty_specialized_value(pp, unwrapped1212) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("term")) - _t1726 = _get_oneof_field(_dollar_dollar, :term) + _t1730 = _get_oneof_field(_dollar_dollar, :term) else - _t1726 = nothing + _t1730 = nothing end - deconstruct_result1207 = _t1726 - if !isnothing(deconstruct_result1207) - unwrapped1208 = deconstruct_result1207 - pretty_term(pp, unwrapped1208) + deconstruct_result1209 = _t1730 + if !isnothing(deconstruct_result1209) + unwrapped1210 = deconstruct_result1209 + pretty_term(pp, unwrapped1210) else throw(ParseError("No matching rule for rel_term")) end @@ -2892,41 +2892,41 @@ function pretty_rel_term(pp::PrettyPrinter, msg::Proto.RelTerm) end function pretty_specialized_value(pp::PrettyPrinter, msg::Proto.Value) - flat1213 = try_flat(pp, msg, pretty_specialized_value) - if !isnothing(flat1213) - write(pp, flat1213) + flat1215 = try_flat(pp, msg, pretty_specialized_value) + if !isnothing(flat1215) + write(pp, flat1215) return nothing else - fields1212 = msg + fields1214 = msg write(pp, "#") - pretty_raw_value(pp, fields1212) + pretty_raw_value(pp, fields1214) end return nothing end function pretty_rel_atom(pp::PrettyPrinter, msg::Proto.RelAtom) - flat1220 = try_flat(pp, msg, pretty_rel_atom) - if !isnothing(flat1220) - write(pp, flat1220) + flat1222 = try_flat(pp, msg, pretty_rel_atom) + if !isnothing(flat1222) + write(pp, flat1222) return nothing else _dollar_dollar = msg - fields1214 = (_dollar_dollar.name, _dollar_dollar.terms,) - unwrapped_fields1215 = fields1214 + fields1216 = (_dollar_dollar.name, _dollar_dollar.terms,) + unwrapped_fields1217 = fields1216 write(pp, "(relatom") indent_sexp!(pp) newline(pp) - field1216 = unwrapped_fields1215[1] - pretty_name(pp, field1216) - field1217 = unwrapped_fields1215[2] - if !isempty(field1217) + field1218 = unwrapped_fields1217[1] + pretty_name(pp, field1218) + field1219 = unwrapped_fields1217[2] + if !isempty(field1219) newline(pp) - for (i1727, elem1218) in enumerate(field1217) - i1219 = i1727 - 1 - if (i1219 > 0) + for (i1731, elem1220) in enumerate(field1219) + i1221 = i1731 - 1 + if (i1221 > 0) newline(pp) end - pretty_rel_term(pp, elem1218) + pretty_rel_term(pp, elem1220) end end dedent!(pp) @@ -2936,22 +2936,22 @@ function pretty_rel_atom(pp::PrettyPrinter, msg::Proto.RelAtom) end function pretty_cast(pp::PrettyPrinter, msg::Proto.Cast) - flat1225 = try_flat(pp, msg, pretty_cast) - if !isnothing(flat1225) - write(pp, flat1225) + flat1227 = try_flat(pp, msg, pretty_cast) + if !isnothing(flat1227) + write(pp, flat1227) return nothing else _dollar_dollar = msg - fields1221 = (_dollar_dollar.input, _dollar_dollar.result,) - unwrapped_fields1222 = fields1221 + fields1223 = (_dollar_dollar.input, _dollar_dollar.result,) + unwrapped_fields1224 = fields1223 write(pp, "(cast") indent_sexp!(pp) newline(pp) - field1223 = unwrapped_fields1222[1] - pretty_term(pp, field1223) + field1225 = unwrapped_fields1224[1] + pretty_term(pp, field1225) newline(pp) - field1224 = unwrapped_fields1222[2] - pretty_term(pp, field1224) + field1226 = unwrapped_fields1224[2] + pretty_term(pp, field1226) dedent!(pp) write(pp, ")") end @@ -2959,22 +2959,22 @@ function pretty_cast(pp::PrettyPrinter, msg::Proto.Cast) end function pretty_attrs(pp::PrettyPrinter, msg::Vector{Proto.Attribute}) - flat1229 = try_flat(pp, msg, pretty_attrs) - if !isnothing(flat1229) - write(pp, flat1229) + flat1231 = try_flat(pp, msg, pretty_attrs) + if !isnothing(flat1231) + write(pp, flat1231) return nothing else - fields1226 = msg + fields1228 = msg write(pp, "(attrs") indent_sexp!(pp) - if !isempty(fields1226) + if !isempty(fields1228) newline(pp) - for (i1728, elem1227) in enumerate(fields1226) - i1228 = i1728 - 1 - if (i1228 > 0) + for (i1732, elem1229) in enumerate(fields1228) + i1230 = i1732 - 1 + if (i1230 > 0) newline(pp) end - pretty_attribute(pp, elem1227) + pretty_attribute(pp, elem1229) end end dedent!(pp) @@ -2984,28 +2984,28 @@ function pretty_attrs(pp::PrettyPrinter, msg::Vector{Proto.Attribute}) end function pretty_attribute(pp::PrettyPrinter, msg::Proto.Attribute) - flat1236 = try_flat(pp, msg, pretty_attribute) - if !isnothing(flat1236) - write(pp, flat1236) + flat1238 = try_flat(pp, msg, pretty_attribute) + if !isnothing(flat1238) + write(pp, flat1238) return nothing else _dollar_dollar = msg - fields1230 = (_dollar_dollar.name, _dollar_dollar.args,) - unwrapped_fields1231 = fields1230 + fields1232 = (_dollar_dollar.name, _dollar_dollar.args,) + unwrapped_fields1233 = fields1232 write(pp, "(attribute") indent_sexp!(pp) newline(pp) - field1232 = unwrapped_fields1231[1] - pretty_name(pp, field1232) - field1233 = unwrapped_fields1231[2] - if !isempty(field1233) + field1234 = unwrapped_fields1233[1] + pretty_name(pp, field1234) + field1235 = unwrapped_fields1233[2] + if !isempty(field1235) newline(pp) - for (i1729, elem1234) in enumerate(field1233) - i1235 = i1729 - 1 - if (i1235 > 0) + for (i1733, elem1236) in enumerate(field1235) + i1237 = i1733 - 1 + if (i1237 > 0) newline(pp) end - pretty_raw_value(pp, elem1234) + pretty_raw_value(pp, elem1236) end end dedent!(pp) @@ -3015,40 +3015,40 @@ function pretty_attribute(pp::PrettyPrinter, msg::Proto.Attribute) end function pretty_algorithm(pp::PrettyPrinter, msg::Proto.Algorithm) - flat1245 = try_flat(pp, msg, pretty_algorithm) - if !isnothing(flat1245) - write(pp, flat1245) + flat1247 = try_flat(pp, msg, pretty_algorithm) + if !isnothing(flat1247) + write(pp, flat1247) return nothing else _dollar_dollar = msg if !isempty(_dollar_dollar.attrs) - _t1730 = _dollar_dollar.attrs + _t1734 = _dollar_dollar.attrs else - _t1730 = nothing + _t1734 = nothing end - fields1237 = (_dollar_dollar.var"#global", _dollar_dollar.body, _t1730,) - unwrapped_fields1238 = fields1237 + fields1239 = (_dollar_dollar.var"#global", _dollar_dollar.body, _t1734,) + unwrapped_fields1240 = fields1239 write(pp, "(algorithm") indent_sexp!(pp) - field1239 = unwrapped_fields1238[1] - if !isempty(field1239) + field1241 = unwrapped_fields1240[1] + if !isempty(field1241) newline(pp) - for (i1731, elem1240) in enumerate(field1239) - i1241 = i1731 - 1 - if (i1241 > 0) + for (i1735, elem1242) in enumerate(field1241) + i1243 = i1735 - 1 + if (i1243 > 0) newline(pp) end - pretty_relation_id(pp, elem1240) + pretty_relation_id(pp, elem1242) end end newline(pp) - field1242 = unwrapped_fields1238[2] - pretty_script(pp, field1242) - field1243 = unwrapped_fields1238[3] - if !isnothing(field1243) + field1244 = unwrapped_fields1240[2] + pretty_script(pp, field1244) + field1245 = unwrapped_fields1240[3] + if !isnothing(field1245) newline(pp) - opt_val1244 = field1243 - pretty_attrs(pp, opt_val1244) + opt_val1246 = field1245 + pretty_attrs(pp, opt_val1246) end dedent!(pp) write(pp, ")") @@ -3057,24 +3057,24 @@ function pretty_algorithm(pp::PrettyPrinter, msg::Proto.Algorithm) end function pretty_script(pp::PrettyPrinter, msg::Proto.Script) - flat1250 = try_flat(pp, msg, pretty_script) - if !isnothing(flat1250) - write(pp, flat1250) + flat1252 = try_flat(pp, msg, pretty_script) + if !isnothing(flat1252) + write(pp, flat1252) return nothing else _dollar_dollar = msg - fields1246 = _dollar_dollar.constructs - unwrapped_fields1247 = fields1246 + fields1248 = _dollar_dollar.constructs + unwrapped_fields1249 = fields1248 write(pp, "(script") indent_sexp!(pp) - if !isempty(unwrapped_fields1247) + if !isempty(unwrapped_fields1249) newline(pp) - for (i1732, elem1248) in enumerate(unwrapped_fields1247) - i1249 = i1732 - 1 - if (i1249 > 0) + for (i1736, elem1250) in enumerate(unwrapped_fields1249) + i1251 = i1736 - 1 + if (i1251 > 0) newline(pp) end - pretty_construct(pp, elem1248) + pretty_construct(pp, elem1250) end end dedent!(pp) @@ -3084,32 +3084,32 @@ function pretty_script(pp::PrettyPrinter, msg::Proto.Script) end function pretty_construct(pp::PrettyPrinter, msg::Proto.Construct) - flat1255 = try_flat(pp, msg, pretty_construct) - if !isnothing(flat1255) - write(pp, flat1255) + flat1257 = try_flat(pp, msg, pretty_construct) + if !isnothing(flat1257) + write(pp, flat1257) return nothing else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("loop")) - _t1733 = _get_oneof_field(_dollar_dollar, :loop) + _t1737 = _get_oneof_field(_dollar_dollar, :loop) else - _t1733 = nothing + _t1737 = nothing end - deconstruct_result1253 = _t1733 - if !isnothing(deconstruct_result1253) - unwrapped1254 = deconstruct_result1253 - pretty_loop(pp, unwrapped1254) + deconstruct_result1255 = _t1737 + if !isnothing(deconstruct_result1255) + unwrapped1256 = deconstruct_result1255 + pretty_loop(pp, unwrapped1256) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("instruction")) - _t1734 = _get_oneof_field(_dollar_dollar, :instruction) + _t1738 = _get_oneof_field(_dollar_dollar, :instruction) else - _t1734 = nothing + _t1738 = nothing end - deconstruct_result1251 = _t1734 - if !isnothing(deconstruct_result1251) - unwrapped1252 = deconstruct_result1251 - pretty_instruction(pp, unwrapped1252) + deconstruct_result1253 = _t1738 + if !isnothing(deconstruct_result1253) + unwrapped1254 = deconstruct_result1253 + pretty_instruction(pp, unwrapped1254) else throw(ParseError("No matching rule for construct")) end @@ -3119,32 +3119,32 @@ function pretty_construct(pp::PrettyPrinter, msg::Proto.Construct) end function pretty_loop(pp::PrettyPrinter, msg::Proto.Loop) - flat1262 = try_flat(pp, msg, pretty_loop) - if !isnothing(flat1262) - write(pp, flat1262) + flat1264 = try_flat(pp, msg, pretty_loop) + if !isnothing(flat1264) + write(pp, flat1264) return nothing else _dollar_dollar = msg if !isempty(_dollar_dollar.attrs) - _t1735 = _dollar_dollar.attrs + _t1739 = _dollar_dollar.attrs else - _t1735 = nothing + _t1739 = nothing end - fields1256 = (_dollar_dollar.init, _dollar_dollar.body, _t1735,) - unwrapped_fields1257 = fields1256 + fields1258 = (_dollar_dollar.init, _dollar_dollar.body, _t1739,) + unwrapped_fields1259 = fields1258 write(pp, "(loop") indent_sexp!(pp) newline(pp) - field1258 = unwrapped_fields1257[1] - pretty_init(pp, field1258) + field1260 = unwrapped_fields1259[1] + pretty_init(pp, field1260) newline(pp) - field1259 = unwrapped_fields1257[2] - pretty_script(pp, field1259) - field1260 = unwrapped_fields1257[3] - if !isnothing(field1260) + field1261 = unwrapped_fields1259[2] + pretty_script(pp, field1261) + field1262 = unwrapped_fields1259[3] + if !isnothing(field1262) newline(pp) - opt_val1261 = field1260 - pretty_attrs(pp, opt_val1261) + opt_val1263 = field1262 + pretty_attrs(pp, opt_val1263) end dedent!(pp) write(pp, ")") @@ -3153,22 +3153,22 @@ function pretty_loop(pp::PrettyPrinter, msg::Proto.Loop) end function pretty_init(pp::PrettyPrinter, msg::Vector{Proto.Instruction}) - flat1266 = try_flat(pp, msg, pretty_init) - if !isnothing(flat1266) - write(pp, flat1266) + flat1268 = try_flat(pp, msg, pretty_init) + if !isnothing(flat1268) + write(pp, flat1268) return nothing else - fields1263 = msg + fields1265 = msg write(pp, "(init") indent_sexp!(pp) - if !isempty(fields1263) + if !isempty(fields1265) newline(pp) - for (i1736, elem1264) in enumerate(fields1263) - i1265 = i1736 - 1 - if (i1265 > 0) + for (i1740, elem1266) in enumerate(fields1265) + i1267 = i1740 - 1 + if (i1267 > 0) newline(pp) end - pretty_instruction(pp, elem1264) + pretty_instruction(pp, elem1266) end end dedent!(pp) @@ -3178,65 +3178,65 @@ function pretty_init(pp::PrettyPrinter, msg::Vector{Proto.Instruction}) end function pretty_instruction(pp::PrettyPrinter, msg::Proto.Instruction) - flat1277 = try_flat(pp, msg, pretty_instruction) - if !isnothing(flat1277) - write(pp, flat1277) + flat1279 = try_flat(pp, msg, pretty_instruction) + if !isnothing(flat1279) + write(pp, flat1279) return nothing else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("assign")) - _t1737 = _get_oneof_field(_dollar_dollar, :assign) + _t1741 = _get_oneof_field(_dollar_dollar, :assign) else - _t1737 = nothing + _t1741 = nothing end - deconstruct_result1275 = _t1737 - if !isnothing(deconstruct_result1275) - unwrapped1276 = deconstruct_result1275 - pretty_assign(pp, unwrapped1276) + deconstruct_result1277 = _t1741 + if !isnothing(deconstruct_result1277) + unwrapped1278 = deconstruct_result1277 + pretty_assign(pp, unwrapped1278) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("upsert")) - _t1738 = _get_oneof_field(_dollar_dollar, :upsert) + _t1742 = _get_oneof_field(_dollar_dollar, :upsert) else - _t1738 = nothing + _t1742 = nothing end - deconstruct_result1273 = _t1738 - if !isnothing(deconstruct_result1273) - unwrapped1274 = deconstruct_result1273 - pretty_upsert(pp, unwrapped1274) + deconstruct_result1275 = _t1742 + if !isnothing(deconstruct_result1275) + unwrapped1276 = deconstruct_result1275 + pretty_upsert(pp, unwrapped1276) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("#break")) - _t1739 = _get_oneof_field(_dollar_dollar, :var"#break") + _t1743 = _get_oneof_field(_dollar_dollar, :var"#break") else - _t1739 = nothing + _t1743 = nothing end - deconstruct_result1271 = _t1739 - if !isnothing(deconstruct_result1271) - unwrapped1272 = deconstruct_result1271 - pretty_break(pp, unwrapped1272) + deconstruct_result1273 = _t1743 + if !isnothing(deconstruct_result1273) + unwrapped1274 = deconstruct_result1273 + pretty_break(pp, unwrapped1274) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("monoid_def")) - _t1740 = _get_oneof_field(_dollar_dollar, :monoid_def) + _t1744 = _get_oneof_field(_dollar_dollar, :monoid_def) else - _t1740 = nothing + _t1744 = nothing end - deconstruct_result1269 = _t1740 - if !isnothing(deconstruct_result1269) - unwrapped1270 = deconstruct_result1269 - pretty_monoid_def(pp, unwrapped1270) + deconstruct_result1271 = _t1744 + if !isnothing(deconstruct_result1271) + unwrapped1272 = deconstruct_result1271 + pretty_monoid_def(pp, unwrapped1272) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("monus_def")) - _t1741 = _get_oneof_field(_dollar_dollar, :monus_def) + _t1745 = _get_oneof_field(_dollar_dollar, :monus_def) else - _t1741 = nothing + _t1745 = nothing end - deconstruct_result1267 = _t1741 - if !isnothing(deconstruct_result1267) - unwrapped1268 = deconstruct_result1267 - pretty_monus_def(pp, unwrapped1268) + deconstruct_result1269 = _t1745 + if !isnothing(deconstruct_result1269) + unwrapped1270 = deconstruct_result1269 + pretty_monus_def(pp, unwrapped1270) else throw(ParseError("No matching rule for instruction")) end @@ -3249,32 +3249,32 @@ function pretty_instruction(pp::PrettyPrinter, msg::Proto.Instruction) end function pretty_assign(pp::PrettyPrinter, msg::Proto.Assign) - flat1284 = try_flat(pp, msg, pretty_assign) - if !isnothing(flat1284) - write(pp, flat1284) + flat1286 = try_flat(pp, msg, pretty_assign) + if !isnothing(flat1286) + write(pp, flat1286) return nothing else _dollar_dollar = msg if !isempty(_dollar_dollar.attrs) - _t1742 = _dollar_dollar.attrs + _t1746 = _dollar_dollar.attrs else - _t1742 = nothing + _t1746 = nothing end - fields1278 = (_dollar_dollar.name, _dollar_dollar.body, _t1742,) - unwrapped_fields1279 = fields1278 + fields1280 = (_dollar_dollar.name, _dollar_dollar.body, _t1746,) + unwrapped_fields1281 = fields1280 write(pp, "(assign") indent_sexp!(pp) newline(pp) - field1280 = unwrapped_fields1279[1] - pretty_relation_id(pp, field1280) + field1282 = unwrapped_fields1281[1] + pretty_relation_id(pp, field1282) newline(pp) - field1281 = unwrapped_fields1279[2] - pretty_abstraction(pp, field1281) - field1282 = unwrapped_fields1279[3] - if !isnothing(field1282) + field1283 = unwrapped_fields1281[2] + pretty_abstraction(pp, field1283) + field1284 = unwrapped_fields1281[3] + if !isnothing(field1284) newline(pp) - opt_val1283 = field1282 - pretty_attrs(pp, opt_val1283) + opt_val1285 = field1284 + pretty_attrs(pp, opt_val1285) end dedent!(pp) write(pp, ")") @@ -3283,32 +3283,32 @@ function pretty_assign(pp::PrettyPrinter, msg::Proto.Assign) end function pretty_upsert(pp::PrettyPrinter, msg::Proto.Upsert) - flat1291 = try_flat(pp, msg, pretty_upsert) - if !isnothing(flat1291) - write(pp, flat1291) + flat1293 = try_flat(pp, msg, pretty_upsert) + if !isnothing(flat1293) + write(pp, flat1293) return nothing else _dollar_dollar = msg if !isempty(_dollar_dollar.attrs) - _t1743 = _dollar_dollar.attrs + _t1747 = _dollar_dollar.attrs else - _t1743 = nothing + _t1747 = nothing end - fields1285 = (_dollar_dollar.name, (_dollar_dollar.body, _dollar_dollar.value_arity,), _t1743,) - unwrapped_fields1286 = fields1285 + fields1287 = (_dollar_dollar.name, (_dollar_dollar.body, _dollar_dollar.value_arity,), _t1747,) + unwrapped_fields1288 = fields1287 write(pp, "(upsert") indent_sexp!(pp) newline(pp) - field1287 = unwrapped_fields1286[1] - pretty_relation_id(pp, field1287) + field1289 = unwrapped_fields1288[1] + pretty_relation_id(pp, field1289) newline(pp) - field1288 = unwrapped_fields1286[2] - pretty_abstraction_with_arity(pp, field1288) - field1289 = unwrapped_fields1286[3] - if !isnothing(field1289) + field1290 = unwrapped_fields1288[2] + pretty_abstraction_with_arity(pp, field1290) + field1291 = unwrapped_fields1288[3] + if !isnothing(field1291) newline(pp) - opt_val1290 = field1289 - pretty_attrs(pp, opt_val1290) + opt_val1292 = field1291 + pretty_attrs(pp, opt_val1292) end dedent!(pp) write(pp, ")") @@ -3317,22 +3317,22 @@ function pretty_upsert(pp::PrettyPrinter, msg::Proto.Upsert) end function pretty_abstraction_with_arity(pp::PrettyPrinter, msg::Tuple{Proto.Abstraction, Int64}) - flat1296 = try_flat(pp, msg, pretty_abstraction_with_arity) - if !isnothing(flat1296) - write(pp, flat1296) + flat1298 = try_flat(pp, msg, pretty_abstraction_with_arity) + if !isnothing(flat1298) + write(pp, flat1298) return nothing else _dollar_dollar = msg - _t1744 = deconstruct_bindings_with_arity(pp, _dollar_dollar[1], _dollar_dollar[2]) - fields1292 = (_t1744, _dollar_dollar[1].value,) - unwrapped_fields1293 = fields1292 + _t1748 = deconstruct_bindings_with_arity(pp, _dollar_dollar[1], _dollar_dollar[2]) + fields1294 = (_t1748, _dollar_dollar[1].value,) + unwrapped_fields1295 = fields1294 write(pp, "(") indent!(pp) - field1294 = unwrapped_fields1293[1] - pretty_bindings(pp, field1294) + field1296 = unwrapped_fields1295[1] + pretty_bindings(pp, field1296) newline(pp) - field1295 = unwrapped_fields1293[2] - pretty_formula(pp, field1295) + field1297 = unwrapped_fields1295[2] + pretty_formula(pp, field1297) dedent!(pp) write(pp, ")") end @@ -3340,32 +3340,32 @@ function pretty_abstraction_with_arity(pp::PrettyPrinter, msg::Tuple{Proto.Abstr end function pretty_break(pp::PrettyPrinter, msg::Proto.Break) - flat1303 = try_flat(pp, msg, pretty_break) - if !isnothing(flat1303) - write(pp, flat1303) + flat1305 = try_flat(pp, msg, pretty_break) + if !isnothing(flat1305) + write(pp, flat1305) return nothing else _dollar_dollar = msg if !isempty(_dollar_dollar.attrs) - _t1745 = _dollar_dollar.attrs + _t1749 = _dollar_dollar.attrs else - _t1745 = nothing + _t1749 = nothing end - fields1297 = (_dollar_dollar.name, _dollar_dollar.body, _t1745,) - unwrapped_fields1298 = fields1297 + fields1299 = (_dollar_dollar.name, _dollar_dollar.body, _t1749,) + unwrapped_fields1300 = fields1299 write(pp, "(break") indent_sexp!(pp) newline(pp) - field1299 = unwrapped_fields1298[1] - pretty_relation_id(pp, field1299) + field1301 = unwrapped_fields1300[1] + pretty_relation_id(pp, field1301) newline(pp) - field1300 = unwrapped_fields1298[2] - pretty_abstraction(pp, field1300) - field1301 = unwrapped_fields1298[3] - if !isnothing(field1301) + field1302 = unwrapped_fields1300[2] + pretty_abstraction(pp, field1302) + field1303 = unwrapped_fields1300[3] + if !isnothing(field1303) newline(pp) - opt_val1302 = field1301 - pretty_attrs(pp, opt_val1302) + opt_val1304 = field1303 + pretty_attrs(pp, opt_val1304) end dedent!(pp) write(pp, ")") @@ -3374,35 +3374,35 @@ function pretty_break(pp::PrettyPrinter, msg::Proto.Break) end function pretty_monoid_def(pp::PrettyPrinter, msg::Proto.MonoidDef) - flat1311 = try_flat(pp, msg, pretty_monoid_def) - if !isnothing(flat1311) - write(pp, flat1311) + flat1313 = try_flat(pp, msg, pretty_monoid_def) + if !isnothing(flat1313) + write(pp, flat1313) return nothing else _dollar_dollar = msg if !isempty(_dollar_dollar.attrs) - _t1746 = _dollar_dollar.attrs + _t1750 = _dollar_dollar.attrs else - _t1746 = nothing + _t1750 = nothing end - fields1304 = (_dollar_dollar.monoid, _dollar_dollar.name, (_dollar_dollar.body, _dollar_dollar.value_arity,), _t1746,) - unwrapped_fields1305 = fields1304 + fields1306 = (_dollar_dollar.monoid, _dollar_dollar.name, (_dollar_dollar.body, _dollar_dollar.value_arity,), _t1750,) + unwrapped_fields1307 = fields1306 write(pp, "(monoid") indent_sexp!(pp) newline(pp) - field1306 = unwrapped_fields1305[1] - pretty_monoid(pp, field1306) + field1308 = unwrapped_fields1307[1] + pretty_monoid(pp, field1308) newline(pp) - field1307 = unwrapped_fields1305[2] - pretty_relation_id(pp, field1307) + field1309 = unwrapped_fields1307[2] + pretty_relation_id(pp, field1309) newline(pp) - field1308 = unwrapped_fields1305[3] - pretty_abstraction_with_arity(pp, field1308) - field1309 = unwrapped_fields1305[4] - if !isnothing(field1309) + field1310 = unwrapped_fields1307[3] + pretty_abstraction_with_arity(pp, field1310) + field1311 = unwrapped_fields1307[4] + if !isnothing(field1311) newline(pp) - opt_val1310 = field1309 - pretty_attrs(pp, opt_val1310) + opt_val1312 = field1311 + pretty_attrs(pp, opt_val1312) end dedent!(pp) write(pp, ")") @@ -3411,54 +3411,54 @@ function pretty_monoid_def(pp::PrettyPrinter, msg::Proto.MonoidDef) end function pretty_monoid(pp::PrettyPrinter, msg::Proto.Monoid) - flat1320 = try_flat(pp, msg, pretty_monoid) - if !isnothing(flat1320) - write(pp, flat1320) + flat1322 = try_flat(pp, msg, pretty_monoid) + if !isnothing(flat1322) + write(pp, flat1322) return nothing else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("or_monoid")) - _t1747 = _get_oneof_field(_dollar_dollar, :or_monoid) + _t1751 = _get_oneof_field(_dollar_dollar, :or_monoid) else - _t1747 = nothing + _t1751 = nothing end - deconstruct_result1318 = _t1747 - if !isnothing(deconstruct_result1318) - unwrapped1319 = deconstruct_result1318 - pretty_or_monoid(pp, unwrapped1319) + deconstruct_result1320 = _t1751 + if !isnothing(deconstruct_result1320) + unwrapped1321 = deconstruct_result1320 + pretty_or_monoid(pp, unwrapped1321) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("min_monoid")) - _t1748 = _get_oneof_field(_dollar_dollar, :min_monoid) + _t1752 = _get_oneof_field(_dollar_dollar, :min_monoid) else - _t1748 = nothing + _t1752 = nothing end - deconstruct_result1316 = _t1748 - if !isnothing(deconstruct_result1316) - unwrapped1317 = deconstruct_result1316 - pretty_min_monoid(pp, unwrapped1317) + deconstruct_result1318 = _t1752 + if !isnothing(deconstruct_result1318) + unwrapped1319 = deconstruct_result1318 + pretty_min_monoid(pp, unwrapped1319) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("max_monoid")) - _t1749 = _get_oneof_field(_dollar_dollar, :max_monoid) + _t1753 = _get_oneof_field(_dollar_dollar, :max_monoid) else - _t1749 = nothing + _t1753 = nothing end - deconstruct_result1314 = _t1749 - if !isnothing(deconstruct_result1314) - unwrapped1315 = deconstruct_result1314 - pretty_max_monoid(pp, unwrapped1315) + deconstruct_result1316 = _t1753 + if !isnothing(deconstruct_result1316) + unwrapped1317 = deconstruct_result1316 + pretty_max_monoid(pp, unwrapped1317) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("sum_monoid")) - _t1750 = _get_oneof_field(_dollar_dollar, :sum_monoid) + _t1754 = _get_oneof_field(_dollar_dollar, :sum_monoid) else - _t1750 = nothing + _t1754 = nothing end - deconstruct_result1312 = _t1750 - if !isnothing(deconstruct_result1312) - unwrapped1313 = deconstruct_result1312 - pretty_sum_monoid(pp, unwrapped1313) + deconstruct_result1314 = _t1754 + if !isnothing(deconstruct_result1314) + unwrapped1315 = deconstruct_result1314 + pretty_sum_monoid(pp, unwrapped1315) else throw(ParseError("No matching rule for monoid")) end @@ -3470,24 +3470,24 @@ function pretty_monoid(pp::PrettyPrinter, msg::Proto.Monoid) end function pretty_or_monoid(pp::PrettyPrinter, msg::Proto.OrMonoid) - fields1321 = msg + fields1323 = msg write(pp, "(or)") return nothing end function pretty_min_monoid(pp::PrettyPrinter, msg::Proto.MinMonoid) - flat1324 = try_flat(pp, msg, pretty_min_monoid) - if !isnothing(flat1324) - write(pp, flat1324) + flat1326 = try_flat(pp, msg, pretty_min_monoid) + if !isnothing(flat1326) + write(pp, flat1326) return nothing else _dollar_dollar = msg - fields1322 = _dollar_dollar.var"#type" - unwrapped_fields1323 = fields1322 + fields1324 = _dollar_dollar.var"#type" + unwrapped_fields1325 = fields1324 write(pp, "(min") indent_sexp!(pp) newline(pp) - pretty_type(pp, unwrapped_fields1323) + pretty_type(pp, unwrapped_fields1325) dedent!(pp) write(pp, ")") end @@ -3495,18 +3495,18 @@ function pretty_min_monoid(pp::PrettyPrinter, msg::Proto.MinMonoid) end function pretty_max_monoid(pp::PrettyPrinter, msg::Proto.MaxMonoid) - flat1327 = try_flat(pp, msg, pretty_max_monoid) - if !isnothing(flat1327) - write(pp, flat1327) + flat1329 = try_flat(pp, msg, pretty_max_monoid) + if !isnothing(flat1329) + write(pp, flat1329) return nothing else _dollar_dollar = msg - fields1325 = _dollar_dollar.var"#type" - unwrapped_fields1326 = fields1325 + fields1327 = _dollar_dollar.var"#type" + unwrapped_fields1328 = fields1327 write(pp, "(max") indent_sexp!(pp) newline(pp) - pretty_type(pp, unwrapped_fields1326) + pretty_type(pp, unwrapped_fields1328) dedent!(pp) write(pp, ")") end @@ -3514,18 +3514,18 @@ function pretty_max_monoid(pp::PrettyPrinter, msg::Proto.MaxMonoid) end function pretty_sum_monoid(pp::PrettyPrinter, msg::Proto.SumMonoid) - flat1330 = try_flat(pp, msg, pretty_sum_monoid) - if !isnothing(flat1330) - write(pp, flat1330) + flat1332 = try_flat(pp, msg, pretty_sum_monoid) + if !isnothing(flat1332) + write(pp, flat1332) return nothing else _dollar_dollar = msg - fields1328 = _dollar_dollar.var"#type" - unwrapped_fields1329 = fields1328 + fields1330 = _dollar_dollar.var"#type" + unwrapped_fields1331 = fields1330 write(pp, "(sum") indent_sexp!(pp) newline(pp) - pretty_type(pp, unwrapped_fields1329) + pretty_type(pp, unwrapped_fields1331) dedent!(pp) write(pp, ")") end @@ -3533,35 +3533,35 @@ function pretty_sum_monoid(pp::PrettyPrinter, msg::Proto.SumMonoid) end function pretty_monus_def(pp::PrettyPrinter, msg::Proto.MonusDef) - flat1338 = try_flat(pp, msg, pretty_monus_def) - if !isnothing(flat1338) - write(pp, flat1338) + flat1340 = try_flat(pp, msg, pretty_monus_def) + if !isnothing(flat1340) + write(pp, flat1340) return nothing else _dollar_dollar = msg if !isempty(_dollar_dollar.attrs) - _t1751 = _dollar_dollar.attrs + _t1755 = _dollar_dollar.attrs else - _t1751 = nothing + _t1755 = nothing end - fields1331 = (_dollar_dollar.monoid, _dollar_dollar.name, (_dollar_dollar.body, _dollar_dollar.value_arity,), _t1751,) - unwrapped_fields1332 = fields1331 + fields1333 = (_dollar_dollar.monoid, _dollar_dollar.name, (_dollar_dollar.body, _dollar_dollar.value_arity,), _t1755,) + unwrapped_fields1334 = fields1333 write(pp, "(monus") indent_sexp!(pp) newline(pp) - field1333 = unwrapped_fields1332[1] - pretty_monoid(pp, field1333) + field1335 = unwrapped_fields1334[1] + pretty_monoid(pp, field1335) newline(pp) - field1334 = unwrapped_fields1332[2] - pretty_relation_id(pp, field1334) + field1336 = unwrapped_fields1334[2] + pretty_relation_id(pp, field1336) newline(pp) - field1335 = unwrapped_fields1332[3] - pretty_abstraction_with_arity(pp, field1335) - field1336 = unwrapped_fields1332[4] - if !isnothing(field1336) + field1337 = unwrapped_fields1334[3] + pretty_abstraction_with_arity(pp, field1337) + field1338 = unwrapped_fields1334[4] + if !isnothing(field1338) newline(pp) - opt_val1337 = field1336 - pretty_attrs(pp, opt_val1337) + opt_val1339 = field1338 + pretty_attrs(pp, opt_val1339) end dedent!(pp) write(pp, ")") @@ -3570,28 +3570,28 @@ function pretty_monus_def(pp::PrettyPrinter, msg::Proto.MonusDef) end function pretty_constraint(pp::PrettyPrinter, msg::Proto.Constraint) - flat1345 = try_flat(pp, msg, pretty_constraint) - if !isnothing(flat1345) - write(pp, flat1345) + flat1347 = try_flat(pp, msg, pretty_constraint) + if !isnothing(flat1347) + write(pp, flat1347) return nothing else _dollar_dollar = msg - fields1339 = (_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_fields1340 = fields1339 + fields1341 = (_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_fields1342 = fields1341 write(pp, "(functional_dependency") indent_sexp!(pp) newline(pp) - field1341 = unwrapped_fields1340[1] - pretty_relation_id(pp, field1341) + field1343 = unwrapped_fields1342[1] + pretty_relation_id(pp, field1343) newline(pp) - field1342 = unwrapped_fields1340[2] - pretty_abstraction(pp, field1342) + field1344 = unwrapped_fields1342[2] + pretty_abstraction(pp, field1344) newline(pp) - field1343 = unwrapped_fields1340[3] - pretty_functional_dependency_keys(pp, field1343) + field1345 = unwrapped_fields1342[3] + pretty_functional_dependency_keys(pp, field1345) newline(pp) - field1344 = unwrapped_fields1340[4] - pretty_functional_dependency_values(pp, field1344) + field1346 = unwrapped_fields1342[4] + pretty_functional_dependency_values(pp, field1346) dedent!(pp) write(pp, ")") end @@ -3599,22 +3599,22 @@ function pretty_constraint(pp::PrettyPrinter, msg::Proto.Constraint) end function pretty_functional_dependency_keys(pp::PrettyPrinter, msg::Vector{Proto.Var}) - flat1349 = try_flat(pp, msg, pretty_functional_dependency_keys) - if !isnothing(flat1349) - write(pp, flat1349) + flat1351 = try_flat(pp, msg, pretty_functional_dependency_keys) + if !isnothing(flat1351) + write(pp, flat1351) return nothing else - fields1346 = msg + fields1348 = msg write(pp, "(keys") indent_sexp!(pp) - if !isempty(fields1346) + if !isempty(fields1348) newline(pp) - for (i1752, elem1347) in enumerate(fields1346) - i1348 = i1752 - 1 - if (i1348 > 0) + for (i1756, elem1349) in enumerate(fields1348) + i1350 = i1756 - 1 + if (i1350 > 0) newline(pp) end - pretty_var(pp, elem1347) + pretty_var(pp, elem1349) end end dedent!(pp) @@ -3624,22 +3624,22 @@ function pretty_functional_dependency_keys(pp::PrettyPrinter, msg::Vector{Proto. end function pretty_functional_dependency_values(pp::PrettyPrinter, msg::Vector{Proto.Var}) - flat1353 = try_flat(pp, msg, pretty_functional_dependency_values) - if !isnothing(flat1353) - write(pp, flat1353) + flat1355 = try_flat(pp, msg, pretty_functional_dependency_values) + if !isnothing(flat1355) + write(pp, flat1355) return nothing else - fields1350 = msg + fields1352 = msg write(pp, "(values") indent_sexp!(pp) - if !isempty(fields1350) + if !isempty(fields1352) newline(pp) - for (i1753, elem1351) in enumerate(fields1350) - i1352 = i1753 - 1 - if (i1352 > 0) + for (i1757, elem1353) in enumerate(fields1352) + i1354 = i1757 - 1 + if (i1354 > 0) newline(pp) end - pretty_var(pp, elem1351) + pretty_var(pp, elem1353) end end dedent!(pp) @@ -3649,54 +3649,54 @@ function pretty_functional_dependency_values(pp::PrettyPrinter, msg::Vector{Prot end function pretty_data(pp::PrettyPrinter, msg::Proto.Data) - flat1362 = try_flat(pp, msg, pretty_data) - if !isnothing(flat1362) - write(pp, flat1362) + flat1364 = try_flat(pp, msg, pretty_data) + if !isnothing(flat1364) + write(pp, flat1364) return nothing else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("edb")) - _t1754 = _get_oneof_field(_dollar_dollar, :edb) + _t1758 = _get_oneof_field(_dollar_dollar, :edb) else - _t1754 = nothing + _t1758 = nothing end - deconstruct_result1360 = _t1754 - if !isnothing(deconstruct_result1360) - unwrapped1361 = deconstruct_result1360 - pretty_edb(pp, unwrapped1361) + deconstruct_result1362 = _t1758 + if !isnothing(deconstruct_result1362) + unwrapped1363 = deconstruct_result1362 + pretty_edb(pp, unwrapped1363) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("betree_relation")) - _t1755 = _get_oneof_field(_dollar_dollar, :betree_relation) + _t1759 = _get_oneof_field(_dollar_dollar, :betree_relation) else - _t1755 = nothing + _t1759 = nothing end - deconstruct_result1358 = _t1755 - if !isnothing(deconstruct_result1358) - unwrapped1359 = deconstruct_result1358 - pretty_betree_relation(pp, unwrapped1359) + deconstruct_result1360 = _t1759 + if !isnothing(deconstruct_result1360) + unwrapped1361 = deconstruct_result1360 + pretty_betree_relation(pp, unwrapped1361) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("csv_data")) - _t1756 = _get_oneof_field(_dollar_dollar, :csv_data) + _t1760 = _get_oneof_field(_dollar_dollar, :csv_data) else - _t1756 = nothing + _t1760 = nothing end - deconstruct_result1356 = _t1756 - if !isnothing(deconstruct_result1356) - unwrapped1357 = deconstruct_result1356 - pretty_csv_data(pp, unwrapped1357) + deconstruct_result1358 = _t1760 + if !isnothing(deconstruct_result1358) + unwrapped1359 = deconstruct_result1358 + pretty_csv_data(pp, unwrapped1359) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("iceberg_data")) - _t1757 = _get_oneof_field(_dollar_dollar, :iceberg_data) + _t1761 = _get_oneof_field(_dollar_dollar, :iceberg_data) else - _t1757 = nothing + _t1761 = nothing end - deconstruct_result1354 = _t1757 - if !isnothing(deconstruct_result1354) - unwrapped1355 = deconstruct_result1354 - pretty_iceberg_data(pp, unwrapped1355) + deconstruct_result1356 = _t1761 + if !isnothing(deconstruct_result1356) + unwrapped1357 = deconstruct_result1356 + pretty_iceberg_data(pp, unwrapped1357) else throw(ParseError("No matching rule for data")) end @@ -3708,25 +3708,25 @@ function pretty_data(pp::PrettyPrinter, msg::Proto.Data) end function pretty_edb(pp::PrettyPrinter, msg::Proto.EDB) - flat1368 = try_flat(pp, msg, pretty_edb) - if !isnothing(flat1368) - write(pp, flat1368) + flat1370 = try_flat(pp, msg, pretty_edb) + if !isnothing(flat1370) + write(pp, flat1370) return nothing else _dollar_dollar = msg - fields1363 = (_dollar_dollar.target_id, _dollar_dollar.path, _dollar_dollar.types,) - unwrapped_fields1364 = fields1363 + fields1365 = (_dollar_dollar.target_id, _dollar_dollar.path, _dollar_dollar.types,) + unwrapped_fields1366 = fields1365 write(pp, "(edb") indent_sexp!(pp) newline(pp) - field1365 = unwrapped_fields1364[1] - pretty_relation_id(pp, field1365) + field1367 = unwrapped_fields1366[1] + pretty_relation_id(pp, field1367) newline(pp) - field1366 = unwrapped_fields1364[2] - pretty_edb_path(pp, field1366) + field1368 = unwrapped_fields1366[2] + pretty_edb_path(pp, field1368) newline(pp) - field1367 = unwrapped_fields1364[3] - pretty_edb_types(pp, field1367) + field1369 = unwrapped_fields1366[3] + pretty_edb_types(pp, field1369) dedent!(pp) write(pp, ")") end @@ -3734,20 +3734,20 @@ function pretty_edb(pp::PrettyPrinter, msg::Proto.EDB) end function pretty_edb_path(pp::PrettyPrinter, msg::Vector{String}) - flat1372 = try_flat(pp, msg, pretty_edb_path) - if !isnothing(flat1372) - write(pp, flat1372) + flat1374 = try_flat(pp, msg, pretty_edb_path) + if !isnothing(flat1374) + write(pp, flat1374) return nothing else - fields1369 = msg + fields1371 = msg write(pp, "[") indent!(pp) - for (i1758, elem1370) in enumerate(fields1369) - i1371 = i1758 - 1 - if (i1371 > 0) + for (i1762, elem1372) in enumerate(fields1371) + i1373 = i1762 - 1 + if (i1373 > 0) newline(pp) end - write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, elem1370)) + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, elem1372)) end dedent!(pp) write(pp, "]") @@ -3756,20 +3756,20 @@ function pretty_edb_path(pp::PrettyPrinter, msg::Vector{String}) end function pretty_edb_types(pp::PrettyPrinter, msg::Vector{Proto.var"#Type"}) - flat1376 = try_flat(pp, msg, pretty_edb_types) - if !isnothing(flat1376) - write(pp, flat1376) + flat1378 = try_flat(pp, msg, pretty_edb_types) + if !isnothing(flat1378) + write(pp, flat1378) return nothing else - fields1373 = msg + fields1375 = msg write(pp, "[") indent!(pp) - for (i1759, elem1374) in enumerate(fields1373) - i1375 = i1759 - 1 - if (i1375 > 0) + for (i1763, elem1376) in enumerate(fields1375) + i1377 = i1763 - 1 + if (i1377 > 0) newline(pp) end - pretty_type(pp, elem1374) + pretty_type(pp, elem1376) end dedent!(pp) write(pp, "]") @@ -3778,22 +3778,22 @@ function pretty_edb_types(pp::PrettyPrinter, msg::Vector{Proto.var"#Type"}) end function pretty_betree_relation(pp::PrettyPrinter, msg::Proto.BeTreeRelation) - flat1381 = try_flat(pp, msg, pretty_betree_relation) - if !isnothing(flat1381) - write(pp, flat1381) + flat1383 = try_flat(pp, msg, pretty_betree_relation) + if !isnothing(flat1383) + write(pp, flat1383) return nothing else _dollar_dollar = msg - fields1377 = (_dollar_dollar.name, _dollar_dollar.relation_info,) - unwrapped_fields1378 = fields1377 + fields1379 = (_dollar_dollar.name, _dollar_dollar.relation_info,) + unwrapped_fields1380 = fields1379 write(pp, "(betree_relation") indent_sexp!(pp) newline(pp) - field1379 = unwrapped_fields1378[1] - pretty_relation_id(pp, field1379) + field1381 = unwrapped_fields1380[1] + pretty_relation_id(pp, field1381) newline(pp) - field1380 = unwrapped_fields1378[2] - pretty_betree_info(pp, field1380) + field1382 = unwrapped_fields1380[2] + pretty_betree_info(pp, field1382) dedent!(pp) write(pp, ")") end @@ -3801,26 +3801,26 @@ function pretty_betree_relation(pp::PrettyPrinter, msg::Proto.BeTreeRelation) end function pretty_betree_info(pp::PrettyPrinter, msg::Proto.BeTreeInfo) - flat1387 = try_flat(pp, msg, pretty_betree_info) - if !isnothing(flat1387) - write(pp, flat1387) + flat1389 = try_flat(pp, msg, pretty_betree_info) + if !isnothing(flat1389) + write(pp, flat1389) return nothing else _dollar_dollar = msg - _t1760 = deconstruct_betree_info_config(pp, _dollar_dollar) - fields1382 = (_dollar_dollar.key_types, _dollar_dollar.value_types, _t1760,) - unwrapped_fields1383 = fields1382 + _t1764 = deconstruct_betree_info_config(pp, _dollar_dollar) + fields1384 = (_dollar_dollar.key_types, _dollar_dollar.value_types, _t1764,) + unwrapped_fields1385 = fields1384 write(pp, "(betree_info") indent_sexp!(pp) newline(pp) - field1384 = unwrapped_fields1383[1] - pretty_betree_info_key_types(pp, field1384) + field1386 = unwrapped_fields1385[1] + pretty_betree_info_key_types(pp, field1386) newline(pp) - field1385 = unwrapped_fields1383[2] - pretty_betree_info_value_types(pp, field1385) + field1387 = unwrapped_fields1385[2] + pretty_betree_info_value_types(pp, field1387) newline(pp) - field1386 = unwrapped_fields1383[3] - pretty_config_dict(pp, field1386) + field1388 = unwrapped_fields1385[3] + pretty_config_dict(pp, field1388) dedent!(pp) write(pp, ")") end @@ -3828,22 +3828,22 @@ function pretty_betree_info(pp::PrettyPrinter, msg::Proto.BeTreeInfo) end function pretty_betree_info_key_types(pp::PrettyPrinter, msg::Vector{Proto.var"#Type"}) - flat1391 = try_flat(pp, msg, pretty_betree_info_key_types) - if !isnothing(flat1391) - write(pp, flat1391) + flat1393 = try_flat(pp, msg, pretty_betree_info_key_types) + if !isnothing(flat1393) + write(pp, flat1393) return nothing else - fields1388 = msg + fields1390 = msg write(pp, "(key_types") indent_sexp!(pp) - if !isempty(fields1388) + if !isempty(fields1390) newline(pp) - for (i1761, elem1389) in enumerate(fields1388) - i1390 = i1761 - 1 - if (i1390 > 0) + for (i1765, elem1391) in enumerate(fields1390) + i1392 = i1765 - 1 + if (i1392 > 0) newline(pp) end - pretty_type(pp, elem1389) + pretty_type(pp, elem1391) end end dedent!(pp) @@ -3853,22 +3853,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"}) - flat1395 = try_flat(pp, msg, pretty_betree_info_value_types) - if !isnothing(flat1395) - write(pp, flat1395) + flat1397 = try_flat(pp, msg, pretty_betree_info_value_types) + if !isnothing(flat1397) + write(pp, flat1397) return nothing else - fields1392 = msg + fields1394 = msg write(pp, "(value_types") indent_sexp!(pp) - if !isempty(fields1392) + if !isempty(fields1394) newline(pp) - for (i1762, elem1393) in enumerate(fields1392) - i1394 = i1762 - 1 - if (i1394 > 0) + for (i1766, elem1395) in enumerate(fields1394) + i1396 = i1766 - 1 + if (i1396 > 0) newline(pp) end - pretty_type(pp, elem1393) + pretty_type(pp, elem1395) end end dedent!(pp) @@ -3878,28 +3878,28 @@ function pretty_betree_info_value_types(pp::PrettyPrinter, msg::Vector{Proto.var end function pretty_csv_data(pp::PrettyPrinter, msg::Proto.CSVData) - flat1402 = try_flat(pp, msg, pretty_csv_data) - if !isnothing(flat1402) - write(pp, flat1402) + flat1404 = try_flat(pp, msg, pretty_csv_data) + if !isnothing(flat1404) + write(pp, flat1404) return nothing else _dollar_dollar = msg - fields1396 = (_dollar_dollar.locator, _dollar_dollar.config, _dollar_dollar.columns, _dollar_dollar.asof,) - unwrapped_fields1397 = fields1396 + fields1398 = (_dollar_dollar.locator, _dollar_dollar.config, _dollar_dollar.columns, _dollar_dollar.asof,) + unwrapped_fields1399 = fields1398 write(pp, "(csv_data") indent_sexp!(pp) newline(pp) - field1398 = unwrapped_fields1397[1] - pretty_csvlocator(pp, field1398) + field1400 = unwrapped_fields1399[1] + pretty_csvlocator(pp, field1400) newline(pp) - field1399 = unwrapped_fields1397[2] - pretty_csv_config(pp, field1399) + field1401 = unwrapped_fields1399[2] + pretty_csv_config(pp, field1401) newline(pp) - field1400 = unwrapped_fields1397[3] - pretty_gnf_columns(pp, field1400) + field1402 = unwrapped_fields1399[3] + pretty_gnf_columns(pp, field1402) newline(pp) - field1401 = unwrapped_fields1397[4] - pretty_csv_asof(pp, field1401) + field1403 = unwrapped_fields1399[4] + pretty_csv_asof(pp, field1403) dedent!(pp) write(pp, ")") end @@ -3907,37 +3907,37 @@ function pretty_csv_data(pp::PrettyPrinter, msg::Proto.CSVData) end function pretty_csvlocator(pp::PrettyPrinter, msg::Proto.CSVLocator) - flat1409 = try_flat(pp, msg, pretty_csvlocator) - if !isnothing(flat1409) - write(pp, flat1409) + flat1411 = try_flat(pp, msg, pretty_csvlocator) + if !isnothing(flat1411) + write(pp, flat1411) return nothing else _dollar_dollar = msg if !isempty(_dollar_dollar.paths) - _t1763 = _dollar_dollar.paths + _t1767 = _dollar_dollar.paths else - _t1763 = nothing + _t1767 = nothing end if String(copy(_dollar_dollar.inline_data)) != "" - _t1764 = String(copy(_dollar_dollar.inline_data)) + _t1768 = String(copy(_dollar_dollar.inline_data)) else - _t1764 = nothing + _t1768 = nothing end - fields1403 = (_t1763, _t1764,) - unwrapped_fields1404 = fields1403 + fields1405 = (_t1767, _t1768,) + unwrapped_fields1406 = fields1405 write(pp, "(csv_locator") indent_sexp!(pp) - field1405 = unwrapped_fields1404[1] - if !isnothing(field1405) - newline(pp) - opt_val1406 = field1405 - pretty_csv_locator_paths(pp, opt_val1406) - end - field1407 = unwrapped_fields1404[2] + field1407 = unwrapped_fields1406[1] if !isnothing(field1407) newline(pp) opt_val1408 = field1407 - pretty_csv_locator_inline_data(pp, opt_val1408) + pretty_csv_locator_paths(pp, opt_val1408) + end + field1409 = unwrapped_fields1406[2] + if !isnothing(field1409) + newline(pp) + opt_val1410 = field1409 + pretty_csv_locator_inline_data(pp, opt_val1410) end dedent!(pp) write(pp, ")") @@ -3946,22 +3946,22 @@ function pretty_csvlocator(pp::PrettyPrinter, msg::Proto.CSVLocator) end function pretty_csv_locator_paths(pp::PrettyPrinter, msg::Vector{String}) - flat1413 = try_flat(pp, msg, pretty_csv_locator_paths) - if !isnothing(flat1413) - write(pp, flat1413) + flat1415 = try_flat(pp, msg, pretty_csv_locator_paths) + if !isnothing(flat1415) + write(pp, flat1415) return nothing else - fields1410 = msg + fields1412 = msg write(pp, "(paths") indent_sexp!(pp) - if !isempty(fields1410) + if !isempty(fields1412) newline(pp) - for (i1765, elem1411) in enumerate(fields1410) - i1412 = i1765 - 1 - if (i1412 > 0) + for (i1769, elem1413) in enumerate(fields1412) + i1414 = i1769 - 1 + if (i1414 > 0) newline(pp) end - write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, elem1411)) + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, elem1413)) end end dedent!(pp) @@ -3971,16 +3971,16 @@ function pretty_csv_locator_paths(pp::PrettyPrinter, msg::Vector{String}) end function pretty_csv_locator_inline_data(pp::PrettyPrinter, msg::String) - flat1415 = try_flat(pp, msg, pretty_csv_locator_inline_data) - if !isnothing(flat1415) - write(pp, flat1415) + flat1417 = try_flat(pp, msg, pretty_csv_locator_inline_data) + if !isnothing(flat1417) + write(pp, flat1417) return nothing else - fields1414 = msg + fields1416 = msg write(pp, "(inline_data") indent_sexp!(pp) newline(pp) - write(pp, format_string(pp, fields1414)) + write(pp, format_string(pp, fields1416)) dedent!(pp) write(pp, ")") end @@ -3988,26 +3988,26 @@ function pretty_csv_locator_inline_data(pp::PrettyPrinter, msg::String) end function pretty_csv_config(pp::PrettyPrinter, msg::Proto.CSVConfig) - flat1421 = try_flat(pp, msg, pretty_csv_config) - if !isnothing(flat1421) - write(pp, flat1421) + flat1423 = try_flat(pp, msg, pretty_csv_config) + if !isnothing(flat1423) + write(pp, flat1423) return nothing else _dollar_dollar = msg - _t1766 = deconstruct_csv_config(pp, _dollar_dollar) - _t1767 = deconstruct_csv_storage_integration_optional(pp, _dollar_dollar) - fields1416 = (_t1766, _t1767,) - unwrapped_fields1417 = fields1416 + _t1770 = deconstruct_csv_config(pp, _dollar_dollar) + _t1771 = deconstruct_csv_storage_integration_optional(pp, _dollar_dollar) + fields1418 = (_t1770, _t1771,) + unwrapped_fields1419 = fields1418 write(pp, "(csv_config") indent_sexp!(pp) newline(pp) - field1418 = unwrapped_fields1417[1] - pretty_config_dict(pp, field1418) - field1419 = unwrapped_fields1417[2] - if !isnothing(field1419) + field1420 = unwrapped_fields1419[1] + pretty_config_dict(pp, field1420) + field1421 = unwrapped_fields1419[2] + if !isnothing(field1421) newline(pp) - opt_val1420 = field1419 - pretty__storage_integration(pp, opt_val1420) + opt_val1422 = field1421 + pretty__storage_integration(pp, opt_val1422) end dedent!(pp) write(pp, ")") @@ -4016,16 +4016,16 @@ function pretty_csv_config(pp::PrettyPrinter, msg::Proto.CSVConfig) end function pretty__storage_integration(pp::PrettyPrinter, msg::Vector{Tuple{String, Proto.Value}}) - flat1423 = try_flat(pp, msg, pretty__storage_integration) - if !isnothing(flat1423) - write(pp, flat1423) + flat1425 = try_flat(pp, msg, pretty__storage_integration) + if !isnothing(flat1425) + write(pp, flat1425) return nothing else - fields1422 = msg + fields1424 = msg write(pp, "(storage_integration") indent_sexp!(pp) newline(pp) - pretty_config_dict(pp, fields1422) + pretty_config_dict(pp, fields1424) dedent!(pp) write(pp, ")") end @@ -4033,22 +4033,22 @@ function pretty__storage_integration(pp::PrettyPrinter, msg::Vector{Tuple{String end function pretty_gnf_columns(pp::PrettyPrinter, msg::Vector{Proto.GNFColumn}) - flat1427 = try_flat(pp, msg, pretty_gnf_columns) - if !isnothing(flat1427) - write(pp, flat1427) + flat1429 = try_flat(pp, msg, pretty_gnf_columns) + if !isnothing(flat1429) + write(pp, flat1429) return nothing else - fields1424 = msg + fields1426 = msg write(pp, "(columns") indent_sexp!(pp) - if !isempty(fields1424) + if !isempty(fields1426) newline(pp) - for (i1768, elem1425) in enumerate(fields1424) - i1426 = i1768 - 1 - if (i1426 > 0) + for (i1772, elem1427) in enumerate(fields1426) + i1428 = i1772 - 1 + if (i1428 > 0) newline(pp) end - pretty_gnf_column(pp, elem1425) + pretty_gnf_column(pp, elem1427) end end dedent!(pp) @@ -4058,39 +4058,39 @@ function pretty_gnf_columns(pp::PrettyPrinter, msg::Vector{Proto.GNFColumn}) end function pretty_gnf_column(pp::PrettyPrinter, msg::Proto.GNFColumn) - flat1436 = try_flat(pp, msg, pretty_gnf_column) - if !isnothing(flat1436) - write(pp, flat1436) + flat1438 = try_flat(pp, msg, pretty_gnf_column) + if !isnothing(flat1438) + write(pp, flat1438) return nothing else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("target_id")) - _t1769 = _dollar_dollar.target_id + _t1773 = _dollar_dollar.target_id else - _t1769 = nothing + _t1773 = nothing end - fields1428 = (_dollar_dollar.column_path, _t1769, _dollar_dollar.types,) - unwrapped_fields1429 = fields1428 + fields1430 = (_dollar_dollar.column_path, _t1773, _dollar_dollar.types,) + unwrapped_fields1431 = fields1430 write(pp, "(column") indent_sexp!(pp) newline(pp) - field1430 = unwrapped_fields1429[1] - pretty_gnf_column_path(pp, field1430) - field1431 = unwrapped_fields1429[2] - if !isnothing(field1431) + field1432 = unwrapped_fields1431[1] + pretty_gnf_column_path(pp, field1432) + field1433 = unwrapped_fields1431[2] + if !isnothing(field1433) newline(pp) - opt_val1432 = field1431 - pretty_relation_id(pp, opt_val1432) + opt_val1434 = field1433 + pretty_relation_id(pp, opt_val1434) end newline(pp) write(pp, "[") - field1433 = unwrapped_fields1429[3] - for (i1770, elem1434) in enumerate(field1433) - i1435 = i1770 - 1 - if (i1435 > 0) + field1435 = unwrapped_fields1431[3] + for (i1774, elem1436) in enumerate(field1435) + i1437 = i1774 - 1 + if (i1437 > 0) newline(pp) end - pretty_type(pp, elem1434) + pretty_type(pp, elem1436) end write(pp, "]") dedent!(pp) @@ -4100,39 +4100,39 @@ function pretty_gnf_column(pp::PrettyPrinter, msg::Proto.GNFColumn) end function pretty_gnf_column_path(pp::PrettyPrinter, msg::Vector{String}) - flat1443 = try_flat(pp, msg, pretty_gnf_column_path) - if !isnothing(flat1443) - write(pp, flat1443) + flat1445 = try_flat(pp, msg, pretty_gnf_column_path) + if !isnothing(flat1445) + write(pp, flat1445) return nothing else _dollar_dollar = msg if length(_dollar_dollar) == 1 - _t1771 = _dollar_dollar[1] + _t1775 = _dollar_dollar[1] else - _t1771 = nothing + _t1775 = nothing end - deconstruct_result1441 = _t1771 - if !isnothing(deconstruct_result1441) - unwrapped1442 = deconstruct_result1441 - write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, unwrapped1442)) + deconstruct_result1443 = _t1775 + if !isnothing(deconstruct_result1443) + unwrapped1444 = deconstruct_result1443 + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, unwrapped1444)) else _dollar_dollar = msg if length(_dollar_dollar) != 1 - _t1772 = _dollar_dollar + _t1776 = _dollar_dollar else - _t1772 = nothing + _t1776 = nothing end - deconstruct_result1437 = _t1772 - if !isnothing(deconstruct_result1437) - unwrapped1438 = deconstruct_result1437 + deconstruct_result1439 = _t1776 + if !isnothing(deconstruct_result1439) + unwrapped1440 = deconstruct_result1439 write(pp, "[") indent!(pp) - for (i1773, elem1439) in enumerate(unwrapped1438) - i1440 = i1773 - 1 - if (i1440 > 0) + for (i1777, elem1441) in enumerate(unwrapped1440) + i1442 = i1777 - 1 + if (i1442 > 0) newline(pp) end - write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, elem1439)) + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, elem1441)) end dedent!(pp) write(pp, "]") @@ -4145,16 +4145,16 @@ function pretty_gnf_column_path(pp::PrettyPrinter, msg::Vector{String}) end function pretty_csv_asof(pp::PrettyPrinter, msg::String) - flat1445 = try_flat(pp, msg, pretty_csv_asof) - if !isnothing(flat1445) - write(pp, flat1445) + flat1447 = try_flat(pp, msg, pretty_csv_asof) + if !isnothing(flat1447) + write(pp, flat1447) return nothing else - fields1444 = msg + fields1446 = msg write(pp, "(asof") indent_sexp!(pp) newline(pp) - write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, fields1444)) + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, fields1446)) dedent!(pp) write(pp, ")") end @@ -4162,42 +4162,42 @@ function pretty_csv_asof(pp::PrettyPrinter, msg::String) end function pretty_iceberg_data(pp::PrettyPrinter, msg::Proto.IcebergData) - flat1456 = try_flat(pp, msg, pretty_iceberg_data) - if !isnothing(flat1456) - write(pp, flat1456) + flat1458 = try_flat(pp, msg, pretty_iceberg_data) + if !isnothing(flat1458) + write(pp, flat1458) return nothing else _dollar_dollar = msg - _t1774 = deconstruct_iceberg_data_from_snapshot_optional(pp, _dollar_dollar) - _t1775 = deconstruct_iceberg_data_to_snapshot_optional(pp, _dollar_dollar) - fields1446 = (_dollar_dollar.locator, _dollar_dollar.config, _dollar_dollar.columns, _t1774, _t1775, _dollar_dollar.returns_delta,) - unwrapped_fields1447 = fields1446 + _t1778 = deconstruct_iceberg_data_from_snapshot_optional(pp, _dollar_dollar) + _t1779 = deconstruct_iceberg_data_to_snapshot_optional(pp, _dollar_dollar) + fields1448 = (_dollar_dollar.locator, _dollar_dollar.config, _dollar_dollar.columns, _t1778, _t1779, _dollar_dollar.returns_delta,) + unwrapped_fields1449 = fields1448 write(pp, "(iceberg_data") indent_sexp!(pp) newline(pp) - field1448 = unwrapped_fields1447[1] - pretty_iceberg_locator(pp, field1448) + field1450 = unwrapped_fields1449[1] + pretty_iceberg_locator(pp, field1450) newline(pp) - field1449 = unwrapped_fields1447[2] - pretty_iceberg_catalog_config(pp, field1449) + field1451 = unwrapped_fields1449[2] + pretty_iceberg_catalog_config(pp, field1451) newline(pp) - field1450 = unwrapped_fields1447[3] - pretty_gnf_columns(pp, field1450) - field1451 = unwrapped_fields1447[4] - if !isnothing(field1451) - newline(pp) - opt_val1452 = field1451 - pretty_iceberg_from_snapshot(pp, opt_val1452) - end - field1453 = unwrapped_fields1447[5] + field1452 = unwrapped_fields1449[3] + pretty_gnf_columns(pp, field1452) + field1453 = unwrapped_fields1449[4] if !isnothing(field1453) newline(pp) opt_val1454 = field1453 - pretty_iceberg_to_snapshot(pp, opt_val1454) + pretty_iceberg_from_snapshot(pp, opt_val1454) + end + field1455 = unwrapped_fields1449[5] + if !isnothing(field1455) + newline(pp) + opt_val1456 = field1455 + pretty_iceberg_to_snapshot(pp, opt_val1456) end newline(pp) - field1455 = unwrapped_fields1447[6] - pretty_boolean_value(pp, field1455) + field1457 = unwrapped_fields1449[6] + pretty_boolean_value(pp, field1457) dedent!(pp) write(pp, ")") end @@ -4205,25 +4205,25 @@ function pretty_iceberg_data(pp::PrettyPrinter, msg::Proto.IcebergData) end function pretty_iceberg_locator(pp::PrettyPrinter, msg::Proto.IcebergLocator) - flat1462 = try_flat(pp, msg, pretty_iceberg_locator) - if !isnothing(flat1462) - write(pp, flat1462) + flat1464 = try_flat(pp, msg, pretty_iceberg_locator) + if !isnothing(flat1464) + write(pp, flat1464) return nothing else _dollar_dollar = msg - fields1457 = (_dollar_dollar.table_name, _dollar_dollar.namespace, _dollar_dollar.warehouse,) - unwrapped_fields1458 = fields1457 + fields1459 = (_dollar_dollar.table_name, _dollar_dollar.namespace, _dollar_dollar.warehouse,) + unwrapped_fields1460 = fields1459 write(pp, "(iceberg_locator") indent_sexp!(pp) newline(pp) - field1459 = unwrapped_fields1458[1] - pretty_iceberg_locator_table_name(pp, field1459) + field1461 = unwrapped_fields1460[1] + pretty_iceberg_locator_table_name(pp, field1461) newline(pp) - field1460 = unwrapped_fields1458[2] - pretty_iceberg_locator_namespace(pp, field1460) + field1462 = unwrapped_fields1460[2] + pretty_iceberg_locator_namespace(pp, field1462) newline(pp) - field1461 = unwrapped_fields1458[3] - pretty_iceberg_locator_warehouse(pp, field1461) + field1463 = unwrapped_fields1460[3] + pretty_iceberg_locator_warehouse(pp, field1463) dedent!(pp) write(pp, ")") end @@ -4231,16 +4231,16 @@ function pretty_iceberg_locator(pp::PrettyPrinter, msg::Proto.IcebergLocator) end function pretty_iceberg_locator_table_name(pp::PrettyPrinter, msg::String) - flat1464 = try_flat(pp, msg, pretty_iceberg_locator_table_name) - if !isnothing(flat1464) - write(pp, flat1464) + flat1466 = try_flat(pp, msg, pretty_iceberg_locator_table_name) + if !isnothing(flat1466) + write(pp, flat1466) return nothing else - fields1463 = msg + fields1465 = msg write(pp, "(table_name") indent_sexp!(pp) newline(pp) - write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, fields1463)) + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, fields1465)) dedent!(pp) write(pp, ")") end @@ -4248,22 +4248,22 @@ function pretty_iceberg_locator_table_name(pp::PrettyPrinter, msg::String) end function pretty_iceberg_locator_namespace(pp::PrettyPrinter, msg::Vector{String}) - flat1468 = try_flat(pp, msg, pretty_iceberg_locator_namespace) - if !isnothing(flat1468) - write(pp, flat1468) + flat1470 = try_flat(pp, msg, pretty_iceberg_locator_namespace) + if !isnothing(flat1470) + write(pp, flat1470) return nothing else - fields1465 = msg + fields1467 = msg write(pp, "(namespace") indent_sexp!(pp) - if !isempty(fields1465) + if !isempty(fields1467) newline(pp) - for (i1776, elem1466) in enumerate(fields1465) - i1467 = i1776 - 1 - if (i1467 > 0) + for (i1780, elem1468) in enumerate(fields1467) + i1469 = i1780 - 1 + if (i1469 > 0) newline(pp) end - write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, elem1466)) + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, elem1468)) end end dedent!(pp) @@ -4273,16 +4273,16 @@ function pretty_iceberg_locator_namespace(pp::PrettyPrinter, msg::Vector{String} end function pretty_iceberg_locator_warehouse(pp::PrettyPrinter, msg::String) - flat1470 = try_flat(pp, msg, pretty_iceberg_locator_warehouse) - if !isnothing(flat1470) - write(pp, flat1470) + flat1472 = try_flat(pp, msg, pretty_iceberg_locator_warehouse) + if !isnothing(flat1472) + write(pp, flat1472) return nothing else - fields1469 = msg + fields1471 = msg write(pp, "(warehouse") indent_sexp!(pp) newline(pp) - write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, fields1469)) + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, fields1471)) dedent!(pp) write(pp, ")") end @@ -4290,32 +4290,32 @@ function pretty_iceberg_locator_warehouse(pp::PrettyPrinter, msg::String) end function pretty_iceberg_catalog_config(pp::PrettyPrinter, msg::Proto.IcebergCatalogConfig) - flat1478 = try_flat(pp, msg, pretty_iceberg_catalog_config) - if !isnothing(flat1478) - write(pp, flat1478) + flat1480 = try_flat(pp, msg, pretty_iceberg_catalog_config) + if !isnothing(flat1480) + write(pp, flat1480) return nothing else _dollar_dollar = msg - _t1777 = deconstruct_iceberg_catalog_config_scope_optional(pp, _dollar_dollar) - fields1471 = (_dollar_dollar.catalog_uri, _t1777, sort([(k, v) for (k, v) in _dollar_dollar.properties]), sort([(k, v) for (k, v) in _dollar_dollar.auth_properties]),) - unwrapped_fields1472 = fields1471 + _t1781 = deconstruct_iceberg_catalog_config_scope_optional(pp, _dollar_dollar) + fields1473 = (_dollar_dollar.catalog_uri, _t1781, sort([(k, v) for (k, v) in _dollar_dollar.properties]), sort([(k, v) for (k, v) in _dollar_dollar.auth_properties]),) + unwrapped_fields1474 = fields1473 write(pp, "(iceberg_catalog_config") indent_sexp!(pp) newline(pp) - field1473 = unwrapped_fields1472[1] - pretty_iceberg_catalog_uri(pp, field1473) - field1474 = unwrapped_fields1472[2] - if !isnothing(field1474) + field1475 = unwrapped_fields1474[1] + pretty_iceberg_catalog_uri(pp, field1475) + field1476 = unwrapped_fields1474[2] + if !isnothing(field1476) newline(pp) - opt_val1475 = field1474 - pretty_iceberg_catalog_config_scope(pp, opt_val1475) + opt_val1477 = field1476 + pretty_iceberg_catalog_config_scope(pp, opt_val1477) end newline(pp) - field1476 = unwrapped_fields1472[3] - pretty_iceberg_properties(pp, field1476) + field1478 = unwrapped_fields1474[3] + pretty_iceberg_properties(pp, field1478) newline(pp) - field1477 = unwrapped_fields1472[4] - pretty_iceberg_auth_properties(pp, field1477) + field1479 = unwrapped_fields1474[4] + pretty_iceberg_auth_properties(pp, field1479) dedent!(pp) write(pp, ")") end @@ -4323,16 +4323,16 @@ function pretty_iceberg_catalog_config(pp::PrettyPrinter, msg::Proto.IcebergCata end function pretty_iceberg_catalog_uri(pp::PrettyPrinter, msg::String) - flat1480 = try_flat(pp, msg, pretty_iceberg_catalog_uri) - if !isnothing(flat1480) - write(pp, flat1480) + flat1482 = try_flat(pp, msg, pretty_iceberg_catalog_uri) + if !isnothing(flat1482) + write(pp, flat1482) return nothing else - fields1479 = msg + fields1481 = msg write(pp, "(catalog_uri") indent_sexp!(pp) newline(pp) - write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, fields1479)) + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, fields1481)) dedent!(pp) write(pp, ")") end @@ -4340,16 +4340,16 @@ function pretty_iceberg_catalog_uri(pp::PrettyPrinter, msg::String) end function pretty_iceberg_catalog_config_scope(pp::PrettyPrinter, msg::String) - flat1482 = try_flat(pp, msg, pretty_iceberg_catalog_config_scope) - if !isnothing(flat1482) - write(pp, flat1482) + flat1484 = try_flat(pp, msg, pretty_iceberg_catalog_config_scope) + if !isnothing(flat1484) + write(pp, flat1484) return nothing else - fields1481 = msg + fields1483 = msg write(pp, "(scope") indent_sexp!(pp) newline(pp) - write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, fields1481)) + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, fields1483)) dedent!(pp) write(pp, ")") end @@ -4357,22 +4357,22 @@ function pretty_iceberg_catalog_config_scope(pp::PrettyPrinter, msg::String) end function pretty_iceberg_properties(pp::PrettyPrinter, msg::Vector{Tuple{String, String}}) - flat1486 = try_flat(pp, msg, pretty_iceberg_properties) - if !isnothing(flat1486) - write(pp, flat1486) + flat1488 = try_flat(pp, msg, pretty_iceberg_properties) + if !isnothing(flat1488) + write(pp, flat1488) return nothing else - fields1483 = msg + fields1485 = msg write(pp, "(properties") indent_sexp!(pp) - if !isempty(fields1483) + if !isempty(fields1485) newline(pp) - for (i1778, elem1484) in enumerate(fields1483) - i1485 = i1778 - 1 - if (i1485 > 0) + for (i1782, elem1486) in enumerate(fields1485) + i1487 = i1782 - 1 + if (i1487 > 0) newline(pp) end - pretty_iceberg_property_entry(pp, elem1484) + pretty_iceberg_property_entry(pp, elem1486) end end dedent!(pp) @@ -4382,22 +4382,22 @@ function pretty_iceberg_properties(pp::PrettyPrinter, msg::Vector{Tuple{String, end function pretty_iceberg_property_entry(pp::PrettyPrinter, msg::Tuple{String, String}) - flat1491 = try_flat(pp, msg, pretty_iceberg_property_entry) - if !isnothing(flat1491) - write(pp, flat1491) + flat1493 = try_flat(pp, msg, pretty_iceberg_property_entry) + if !isnothing(flat1493) + write(pp, flat1493) return nothing else _dollar_dollar = msg - fields1487 = (_dollar_dollar[1], _dollar_dollar[2],) - unwrapped_fields1488 = fields1487 + fields1489 = (_dollar_dollar[1], _dollar_dollar[2],) + unwrapped_fields1490 = fields1489 write(pp, "(prop") indent_sexp!(pp) newline(pp) - field1489 = unwrapped_fields1488[1] - write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, field1489)) + field1491 = unwrapped_fields1490[1] + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, field1491)) newline(pp) - field1490 = unwrapped_fields1488[2] - write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, field1490)) + field1492 = unwrapped_fields1490[2] + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, field1492)) dedent!(pp) write(pp, ")") end @@ -4405,22 +4405,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}}) - flat1495 = try_flat(pp, msg, pretty_iceberg_auth_properties) - if !isnothing(flat1495) - write(pp, flat1495) + flat1497 = try_flat(pp, msg, pretty_iceberg_auth_properties) + if !isnothing(flat1497) + write(pp, flat1497) return nothing else - fields1492 = msg + fields1494 = msg write(pp, "(auth_properties") indent_sexp!(pp) - if !isempty(fields1492) + if !isempty(fields1494) newline(pp) - for (i1779, elem1493) in enumerate(fields1492) - i1494 = i1779 - 1 - if (i1494 > 0) + for (i1783, elem1495) in enumerate(fields1494) + i1496 = i1783 - 1 + if (i1496 > 0) newline(pp) end - pretty_iceberg_masked_property_entry(pp, elem1493) + pretty_iceberg_masked_property_entry(pp, elem1495) end end dedent!(pp) @@ -4430,23 +4430,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}) - flat1500 = try_flat(pp, msg, pretty_iceberg_masked_property_entry) - if !isnothing(flat1500) - write(pp, flat1500) + flat1502 = try_flat(pp, msg, pretty_iceberg_masked_property_entry) + if !isnothing(flat1502) + write(pp, flat1502) return nothing else _dollar_dollar = msg - _t1780 = mask_secret_value(pp, _dollar_dollar) - fields1496 = (_dollar_dollar[1], _t1780,) - unwrapped_fields1497 = fields1496 + _t1784 = mask_secret_value(pp, _dollar_dollar) + fields1498 = (_dollar_dollar[1], _t1784,) + unwrapped_fields1499 = fields1498 write(pp, "(prop") indent_sexp!(pp) newline(pp) - field1498 = unwrapped_fields1497[1] - write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, field1498)) + field1500 = unwrapped_fields1499[1] + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, field1500)) newline(pp) - field1499 = unwrapped_fields1497[2] - write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, field1499)) + field1501 = unwrapped_fields1499[2] + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, field1501)) dedent!(pp) write(pp, ")") end @@ -4454,16 +4454,16 @@ function pretty_iceberg_masked_property_entry(pp::PrettyPrinter, msg::Tuple{Stri end function pretty_iceberg_from_snapshot(pp::PrettyPrinter, msg::String) - flat1502 = try_flat(pp, msg, pretty_iceberg_from_snapshot) - if !isnothing(flat1502) - write(pp, flat1502) + flat1504 = try_flat(pp, msg, pretty_iceberg_from_snapshot) + if !isnothing(flat1504) + write(pp, flat1504) return nothing else - fields1501 = msg + fields1503 = msg write(pp, "(from_snapshot") indent_sexp!(pp) newline(pp) - write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, fields1501)) + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, fields1503)) dedent!(pp) write(pp, ")") end @@ -4471,16 +4471,16 @@ function pretty_iceberg_from_snapshot(pp::PrettyPrinter, msg::String) end function pretty_iceberg_to_snapshot(pp::PrettyPrinter, msg::String) - flat1504 = try_flat(pp, msg, pretty_iceberg_to_snapshot) - if !isnothing(flat1504) - write(pp, flat1504) + flat1506 = try_flat(pp, msg, pretty_iceberg_to_snapshot) + if !isnothing(flat1506) + write(pp, flat1506) return nothing else - fields1503 = msg + fields1505 = msg write(pp, "(to_snapshot") indent_sexp!(pp) newline(pp) - write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, fields1503)) + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, fields1505)) dedent!(pp) write(pp, ")") end @@ -4488,18 +4488,18 @@ function pretty_iceberg_to_snapshot(pp::PrettyPrinter, msg::String) end function pretty_undefine(pp::PrettyPrinter, msg::Proto.Undefine) - flat1507 = try_flat(pp, msg, pretty_undefine) - if !isnothing(flat1507) - write(pp, flat1507) + flat1509 = try_flat(pp, msg, pretty_undefine) + if !isnothing(flat1509) + write(pp, flat1509) return nothing else _dollar_dollar = msg - fields1505 = _dollar_dollar.fragment_id - unwrapped_fields1506 = fields1505 + fields1507 = _dollar_dollar.fragment_id + unwrapped_fields1508 = fields1507 write(pp, "(undefine") indent_sexp!(pp) newline(pp) - pretty_fragment_id(pp, unwrapped_fields1506) + pretty_fragment_id(pp, unwrapped_fields1508) dedent!(pp) write(pp, ")") end @@ -4507,24 +4507,24 @@ function pretty_undefine(pp::PrettyPrinter, msg::Proto.Undefine) end function pretty_context(pp::PrettyPrinter, msg::Proto.Context) - flat1512 = try_flat(pp, msg, pretty_context) - if !isnothing(flat1512) - write(pp, flat1512) + flat1514 = try_flat(pp, msg, pretty_context) + if !isnothing(flat1514) + write(pp, flat1514) return nothing else _dollar_dollar = msg - fields1508 = _dollar_dollar.relations - unwrapped_fields1509 = fields1508 + fields1510 = _dollar_dollar.relations + unwrapped_fields1511 = fields1510 write(pp, "(context") indent_sexp!(pp) - if !isempty(unwrapped_fields1509) + if !isempty(unwrapped_fields1511) newline(pp) - for (i1781, elem1510) in enumerate(unwrapped_fields1509) - i1511 = i1781 - 1 - if (i1511 > 0) + for (i1785, elem1512) in enumerate(unwrapped_fields1511) + i1513 = i1785 - 1 + if (i1513 > 0) newline(pp) end - pretty_relation_id(pp, elem1510) + pretty_relation_id(pp, elem1512) end end dedent!(pp) @@ -4534,28 +4534,28 @@ function pretty_context(pp::PrettyPrinter, msg::Proto.Context) end function pretty_snapshot(pp::PrettyPrinter, msg::Proto.Snapshot) - flat1519 = try_flat(pp, msg, pretty_snapshot) - if !isnothing(flat1519) - write(pp, flat1519) + flat1521 = try_flat(pp, msg, pretty_snapshot) + if !isnothing(flat1521) + write(pp, flat1521) return nothing else _dollar_dollar = msg - fields1513 = (_dollar_dollar.prefix, _dollar_dollar.mappings,) - unwrapped_fields1514 = fields1513 + fields1515 = (_dollar_dollar.prefix, _dollar_dollar.mappings,) + unwrapped_fields1516 = fields1515 write(pp, "(snapshot") indent_sexp!(pp) newline(pp) - field1515 = unwrapped_fields1514[1] - pretty_edb_path(pp, field1515) - field1516 = unwrapped_fields1514[2] - if !isempty(field1516) + field1517 = unwrapped_fields1516[1] + pretty_edb_path(pp, field1517) + field1518 = unwrapped_fields1516[2] + if !isempty(field1518) newline(pp) - for (i1782, elem1517) in enumerate(field1516) - i1518 = i1782 - 1 - if (i1518 > 0) + for (i1786, elem1519) in enumerate(field1518) + i1520 = i1786 - 1 + if (i1520 > 0) newline(pp) end - pretty_snapshot_mapping(pp, elem1517) + pretty_snapshot_mapping(pp, elem1519) end end dedent!(pp) @@ -4565,40 +4565,40 @@ function pretty_snapshot(pp::PrettyPrinter, msg::Proto.Snapshot) end function pretty_snapshot_mapping(pp::PrettyPrinter, msg::Proto.SnapshotMapping) - flat1524 = try_flat(pp, msg, pretty_snapshot_mapping) - if !isnothing(flat1524) - write(pp, flat1524) + flat1526 = try_flat(pp, msg, pretty_snapshot_mapping) + if !isnothing(flat1526) + write(pp, flat1526) return nothing else _dollar_dollar = msg - fields1520 = (_dollar_dollar.destination_path, _dollar_dollar.source_relation,) - unwrapped_fields1521 = fields1520 - field1522 = unwrapped_fields1521[1] - pretty_edb_path(pp, field1522) + fields1522 = (_dollar_dollar.destination_path, _dollar_dollar.source_relation,) + unwrapped_fields1523 = fields1522 + field1524 = unwrapped_fields1523[1] + pretty_edb_path(pp, field1524) write(pp, " ") - field1523 = unwrapped_fields1521[2] - pretty_relation_id(pp, field1523) + field1525 = unwrapped_fields1523[2] + pretty_relation_id(pp, field1525) end return nothing end function pretty_epoch_reads(pp::PrettyPrinter, msg::Vector{Proto.Read}) - flat1528 = try_flat(pp, msg, pretty_epoch_reads) - if !isnothing(flat1528) - write(pp, flat1528) + flat1530 = try_flat(pp, msg, pretty_epoch_reads) + if !isnothing(flat1530) + write(pp, flat1530) return nothing else - fields1525 = msg + fields1527 = msg write(pp, "(reads") indent_sexp!(pp) - if !isempty(fields1525) + if !isempty(fields1527) newline(pp) - for (i1783, elem1526) in enumerate(fields1525) - i1527 = i1783 - 1 - if (i1527 > 0) + for (i1787, elem1528) in enumerate(fields1527) + i1529 = i1787 - 1 + if (i1529 > 0) newline(pp) end - pretty_read(pp, elem1526) + pretty_read(pp, elem1528) end end dedent!(pp) @@ -4608,76 +4608,76 @@ function pretty_epoch_reads(pp::PrettyPrinter, msg::Vector{Proto.Read}) end function pretty_read(pp::PrettyPrinter, msg::Proto.Read) - flat1541 = try_flat(pp, msg, pretty_read) - if !isnothing(flat1541) - write(pp, flat1541) + flat1543 = try_flat(pp, msg, pretty_read) + if !isnothing(flat1543) + write(pp, flat1543) return nothing else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("demand")) - _t1784 = _get_oneof_field(_dollar_dollar, :demand) + _t1788 = _get_oneof_field(_dollar_dollar, :demand) else - _t1784 = nothing + _t1788 = nothing end - deconstruct_result1539 = _t1784 - if !isnothing(deconstruct_result1539) - unwrapped1540 = deconstruct_result1539 - pretty_demand(pp, unwrapped1540) + deconstruct_result1541 = _t1788 + if !isnothing(deconstruct_result1541) + unwrapped1542 = deconstruct_result1541 + pretty_demand(pp, unwrapped1542) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("output")) - _t1785 = _get_oneof_field(_dollar_dollar, :output) + _t1789 = _get_oneof_field(_dollar_dollar, :output) else - _t1785 = nothing + _t1789 = nothing end - deconstruct_result1537 = _t1785 - if !isnothing(deconstruct_result1537) - unwrapped1538 = deconstruct_result1537 - pretty_output(pp, unwrapped1538) + deconstruct_result1539 = _t1789 + if !isnothing(deconstruct_result1539) + unwrapped1540 = deconstruct_result1539 + pretty_output(pp, unwrapped1540) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("what_if")) - _t1786 = _get_oneof_field(_dollar_dollar, :what_if) + _t1790 = _get_oneof_field(_dollar_dollar, :what_if) else - _t1786 = nothing + _t1790 = nothing end - deconstruct_result1535 = _t1786 - if !isnothing(deconstruct_result1535) - unwrapped1536 = deconstruct_result1535 - pretty_what_if(pp, unwrapped1536) + deconstruct_result1537 = _t1790 + if !isnothing(deconstruct_result1537) + unwrapped1538 = deconstruct_result1537 + pretty_what_if(pp, unwrapped1538) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("abort")) - _t1787 = _get_oneof_field(_dollar_dollar, :abort) + _t1791 = _get_oneof_field(_dollar_dollar, :abort) else - _t1787 = nothing + _t1791 = nothing end - deconstruct_result1533 = _t1787 - if !isnothing(deconstruct_result1533) - unwrapped1534 = deconstruct_result1533 - pretty_abort(pp, unwrapped1534) + deconstruct_result1535 = _t1791 + if !isnothing(deconstruct_result1535) + unwrapped1536 = deconstruct_result1535 + pretty_abort(pp, unwrapped1536) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("#export")) - _t1788 = _get_oneof_field(_dollar_dollar, :var"#export") + _t1792 = _get_oneof_field(_dollar_dollar, :var"#export") else - _t1788 = nothing + _t1792 = nothing end - deconstruct_result1531 = _t1788 - if !isnothing(deconstruct_result1531) - unwrapped1532 = deconstruct_result1531 - pretty_export(pp, unwrapped1532) + deconstruct_result1533 = _t1792 + if !isnothing(deconstruct_result1533) + unwrapped1534 = deconstruct_result1533 + pretty_export(pp, unwrapped1534) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("export_output")) - _t1789 = _get_oneof_field(_dollar_dollar, :export_output) + _t1793 = _get_oneof_field(_dollar_dollar, :export_output) else - _t1789 = nothing + _t1793 = nothing end - deconstruct_result1529 = _t1789 - if !isnothing(deconstruct_result1529) - unwrapped1530 = deconstruct_result1529 - pretty_export_output(pp, unwrapped1530) + deconstruct_result1531 = _t1793 + if !isnothing(deconstruct_result1531) + unwrapped1532 = deconstruct_result1531 + pretty_export_output(pp, unwrapped1532) else throw(ParseError("No matching rule for read")) end @@ -4691,18 +4691,18 @@ function pretty_read(pp::PrettyPrinter, msg::Proto.Read) end function pretty_demand(pp::PrettyPrinter, msg::Proto.Demand) - flat1544 = try_flat(pp, msg, pretty_demand) - if !isnothing(flat1544) - write(pp, flat1544) + flat1546 = try_flat(pp, msg, pretty_demand) + if !isnothing(flat1546) + write(pp, flat1546) return nothing else _dollar_dollar = msg - fields1542 = _dollar_dollar.relation_id - unwrapped_fields1543 = fields1542 + fields1544 = _dollar_dollar.relation_id + unwrapped_fields1545 = fields1544 write(pp, "(demand") indent_sexp!(pp) newline(pp) - pretty_relation_id(pp, unwrapped_fields1543) + pretty_relation_id(pp, unwrapped_fields1545) dedent!(pp) write(pp, ")") end @@ -4710,22 +4710,22 @@ function pretty_demand(pp::PrettyPrinter, msg::Proto.Demand) end function pretty_output(pp::PrettyPrinter, msg::Proto.Output) - flat1549 = try_flat(pp, msg, pretty_output) - if !isnothing(flat1549) - write(pp, flat1549) + flat1551 = try_flat(pp, msg, pretty_output) + if !isnothing(flat1551) + write(pp, flat1551) return nothing else _dollar_dollar = msg - fields1545 = (_dollar_dollar.name, _dollar_dollar.relation_id,) - unwrapped_fields1546 = fields1545 + fields1547 = (_dollar_dollar.name, _dollar_dollar.relation_id,) + unwrapped_fields1548 = fields1547 write(pp, "(output") indent_sexp!(pp) newline(pp) - field1547 = unwrapped_fields1546[1] - pretty_name(pp, field1547) + field1549 = unwrapped_fields1548[1] + pretty_name(pp, field1549) newline(pp) - field1548 = unwrapped_fields1546[2] - pretty_relation_id(pp, field1548) + field1550 = unwrapped_fields1548[2] + pretty_relation_id(pp, field1550) dedent!(pp) write(pp, ")") end @@ -4733,22 +4733,22 @@ function pretty_output(pp::PrettyPrinter, msg::Proto.Output) end function pretty_what_if(pp::PrettyPrinter, msg::Proto.WhatIf) - flat1554 = try_flat(pp, msg, pretty_what_if) - if !isnothing(flat1554) - write(pp, flat1554) + flat1556 = try_flat(pp, msg, pretty_what_if) + if !isnothing(flat1556) + write(pp, flat1556) return nothing else _dollar_dollar = msg - fields1550 = (_dollar_dollar.branch, _dollar_dollar.epoch,) - unwrapped_fields1551 = fields1550 + fields1552 = (_dollar_dollar.branch, _dollar_dollar.epoch,) + unwrapped_fields1553 = fields1552 write(pp, "(what_if") indent_sexp!(pp) newline(pp) - field1552 = unwrapped_fields1551[1] - pretty_name(pp, field1552) + field1554 = unwrapped_fields1553[1] + pretty_name(pp, field1554) newline(pp) - field1553 = unwrapped_fields1551[2] - pretty_epoch(pp, field1553) + field1555 = unwrapped_fields1553[2] + pretty_epoch(pp, field1555) dedent!(pp) write(pp, ")") end @@ -4756,30 +4756,30 @@ function pretty_what_if(pp::PrettyPrinter, msg::Proto.WhatIf) end function pretty_abort(pp::PrettyPrinter, msg::Proto.Abort) - flat1560 = try_flat(pp, msg, pretty_abort) - if !isnothing(flat1560) - write(pp, flat1560) + flat1562 = try_flat(pp, msg, pretty_abort) + if !isnothing(flat1562) + write(pp, flat1562) return nothing else _dollar_dollar = msg if _dollar_dollar.name != "abort" - _t1790 = _dollar_dollar.name + _t1794 = _dollar_dollar.name else - _t1790 = nothing + _t1794 = nothing end - fields1555 = (_t1790, _dollar_dollar.relation_id,) - unwrapped_fields1556 = fields1555 + fields1557 = (_t1794, _dollar_dollar.relation_id,) + unwrapped_fields1558 = fields1557 write(pp, "(abort") indent_sexp!(pp) - field1557 = unwrapped_fields1556[1] - if !isnothing(field1557) + field1559 = unwrapped_fields1558[1] + if !isnothing(field1559) newline(pp) - opt_val1558 = field1557 - pretty_name(pp, opt_val1558) + opt_val1560 = field1559 + pretty_name(pp, opt_val1560) end newline(pp) - field1559 = unwrapped_fields1556[2] - pretty_relation_id(pp, field1559) + field1561 = unwrapped_fields1558[2] + pretty_relation_id(pp, field1561) dedent!(pp) write(pp, ")") end @@ -4787,40 +4787,40 @@ function pretty_abort(pp::PrettyPrinter, msg::Proto.Abort) end function pretty_export(pp::PrettyPrinter, msg::Proto.Export) - flat1565 = try_flat(pp, msg, pretty_export) - if !isnothing(flat1565) - write(pp, flat1565) + flat1567 = try_flat(pp, msg, pretty_export) + if !isnothing(flat1567) + write(pp, flat1567) return nothing else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("csv_config")) - _t1791 = _get_oneof_field(_dollar_dollar, :csv_config) + _t1795 = _get_oneof_field(_dollar_dollar, :csv_config) else - _t1791 = nothing + _t1795 = nothing end - deconstruct_result1563 = _t1791 - if !isnothing(deconstruct_result1563) - unwrapped1564 = deconstruct_result1563 + deconstruct_result1565 = _t1795 + if !isnothing(deconstruct_result1565) + unwrapped1566 = deconstruct_result1565 write(pp, "(export") indent_sexp!(pp) newline(pp) - pretty_export_csv_config(pp, unwrapped1564) + pretty_export_csv_config(pp, unwrapped1566) dedent!(pp) write(pp, ")") else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("iceberg_config")) - _t1792 = _get_oneof_field(_dollar_dollar, :iceberg_config) + _t1796 = _get_oneof_field(_dollar_dollar, :iceberg_config) else - _t1792 = nothing + _t1796 = nothing end - deconstruct_result1561 = _t1792 - if !isnothing(deconstruct_result1561) - unwrapped1562 = deconstruct_result1561 + deconstruct_result1563 = _t1796 + if !isnothing(deconstruct_result1563) + unwrapped1564 = deconstruct_result1563 write(pp, "(export_iceberg") indent_sexp!(pp) newline(pp) - pretty_export_iceberg_config(pp, unwrapped1562) + pretty_export_iceberg_config(pp, unwrapped1564) dedent!(pp) write(pp, ")") else @@ -4832,55 +4832,55 @@ function pretty_export(pp::PrettyPrinter, msg::Proto.Export) end function pretty_export_csv_config(pp::PrettyPrinter, msg::Proto.ExportCSVConfig) - flat1576 = try_flat(pp, msg, pretty_export_csv_config) - if !isnothing(flat1576) - write(pp, flat1576) + flat1578 = try_flat(pp, msg, pretty_export_csv_config) + if !isnothing(flat1578) + write(pp, flat1578) return nothing else _dollar_dollar = msg if length(_dollar_dollar.data_columns) == 0 - _t1793 = (_dollar_dollar.path, _dollar_dollar.csv_source, _dollar_dollar.csv_config,) + _t1797 = (_dollar_dollar.path, _dollar_dollar.csv_source, _dollar_dollar.csv_config,) else - _t1793 = nothing + _t1797 = nothing end - deconstruct_result1571 = _t1793 - if !isnothing(deconstruct_result1571) - unwrapped1572 = deconstruct_result1571 + deconstruct_result1573 = _t1797 + if !isnothing(deconstruct_result1573) + unwrapped1574 = deconstruct_result1573 write(pp, "(export_csv_config_v2") indent_sexp!(pp) newline(pp) - field1573 = unwrapped1572[1] - pretty_export_csv_path(pp, field1573) + field1575 = unwrapped1574[1] + pretty_export_csv_path(pp, field1575) newline(pp) - field1574 = unwrapped1572[2] - pretty_export_csv_source(pp, field1574) + field1576 = unwrapped1574[2] + pretty_export_csv_source(pp, field1576) newline(pp) - field1575 = unwrapped1572[3] - pretty_csv_config(pp, field1575) + field1577 = unwrapped1574[3] + pretty_csv_config(pp, field1577) dedent!(pp) write(pp, ")") else _dollar_dollar = msg if length(_dollar_dollar.data_columns) != 0 - _t1795 = deconstruct_export_csv_config(pp, _dollar_dollar) - _t1794 = (_dollar_dollar.path, _dollar_dollar.data_columns, _t1795,) + _t1799 = deconstruct_export_csv_config(pp, _dollar_dollar) + _t1798 = (_dollar_dollar.path, _dollar_dollar.data_columns, _t1799,) else - _t1794 = nothing + _t1798 = nothing end - deconstruct_result1566 = _t1794 - if !isnothing(deconstruct_result1566) - unwrapped1567 = deconstruct_result1566 + deconstruct_result1568 = _t1798 + if !isnothing(deconstruct_result1568) + unwrapped1569 = deconstruct_result1568 write(pp, "(export_csv_config") indent_sexp!(pp) newline(pp) - field1568 = unwrapped1567[1] - pretty_export_csv_path(pp, field1568) + field1570 = unwrapped1569[1] + pretty_export_csv_path(pp, field1570) newline(pp) - field1569 = unwrapped1567[2] - pretty_export_csv_columns_list(pp, field1569) + field1571 = unwrapped1569[2] + pretty_export_csv_columns_list(pp, field1571) newline(pp) - field1570 = unwrapped1567[3] - pretty_config_dict(pp, field1570) + field1572 = unwrapped1569[3] + pretty_config_dict(pp, field1572) dedent!(pp) write(pp, ")") else @@ -4892,16 +4892,16 @@ function pretty_export_csv_config(pp::PrettyPrinter, msg::Proto.ExportCSVConfig) end function pretty_export_csv_path(pp::PrettyPrinter, msg::String) - flat1578 = try_flat(pp, msg, pretty_export_csv_path) - if !isnothing(flat1578) - write(pp, flat1578) + flat1580 = try_flat(pp, msg, pretty_export_csv_path) + if !isnothing(flat1580) + write(pp, flat1580) return nothing else - fields1577 = msg + fields1579 = msg write(pp, "(path") indent_sexp!(pp) newline(pp) - write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, fields1577)) + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, fields1579)) dedent!(pp) write(pp, ")") end @@ -4909,30 +4909,30 @@ function pretty_export_csv_path(pp::PrettyPrinter, msg::String) end function pretty_export_csv_source(pp::PrettyPrinter, msg::Proto.ExportCSVSource) - flat1585 = try_flat(pp, msg, pretty_export_csv_source) - if !isnothing(flat1585) - write(pp, flat1585) + flat1587 = try_flat(pp, msg, pretty_export_csv_source) + if !isnothing(flat1587) + write(pp, flat1587) return nothing else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("gnf_columns")) - _t1796 = _get_oneof_field(_dollar_dollar, :gnf_columns).columns + _t1800 = _get_oneof_field(_dollar_dollar, :gnf_columns).columns else - _t1796 = nothing + _t1800 = nothing end - deconstruct_result1581 = _t1796 - if !isnothing(deconstruct_result1581) - unwrapped1582 = deconstruct_result1581 + deconstruct_result1583 = _t1800 + if !isnothing(deconstruct_result1583) + unwrapped1584 = deconstruct_result1583 write(pp, "(gnf_columns") indent_sexp!(pp) - if !isempty(unwrapped1582) + if !isempty(unwrapped1584) newline(pp) - for (i1797, elem1583) in enumerate(unwrapped1582) - i1584 = i1797 - 1 - if (i1584 > 0) + for (i1801, elem1585) in enumerate(unwrapped1584) + i1586 = i1801 - 1 + if (i1586 > 0) newline(pp) end - pretty_export_csv_column(pp, elem1583) + pretty_export_csv_column(pp, elem1585) end end dedent!(pp) @@ -4940,17 +4940,17 @@ function pretty_export_csv_source(pp::PrettyPrinter, msg::Proto.ExportCSVSource) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("table_def")) - _t1798 = _get_oneof_field(_dollar_dollar, :table_def) + _t1802 = _get_oneof_field(_dollar_dollar, :table_def) else - _t1798 = nothing + _t1802 = nothing end - deconstruct_result1579 = _t1798 - if !isnothing(deconstruct_result1579) - unwrapped1580 = deconstruct_result1579 + deconstruct_result1581 = _t1802 + if !isnothing(deconstruct_result1581) + unwrapped1582 = deconstruct_result1581 write(pp, "(table_def") indent_sexp!(pp) newline(pp) - pretty_relation_id(pp, unwrapped1580) + pretty_relation_id(pp, unwrapped1582) dedent!(pp) write(pp, ")") else @@ -4962,22 +4962,22 @@ function pretty_export_csv_source(pp::PrettyPrinter, msg::Proto.ExportCSVSource) end function pretty_export_csv_column(pp::PrettyPrinter, msg::Proto.ExportCSVColumn) - flat1590 = try_flat(pp, msg, pretty_export_csv_column) - if !isnothing(flat1590) - write(pp, flat1590) + flat1592 = try_flat(pp, msg, pretty_export_csv_column) + if !isnothing(flat1592) + write(pp, flat1592) return nothing else _dollar_dollar = msg - fields1586 = (_dollar_dollar.column_name, _dollar_dollar.column_data,) - unwrapped_fields1587 = fields1586 + fields1588 = (_dollar_dollar.column_name, _dollar_dollar.column_data,) + unwrapped_fields1589 = fields1588 write(pp, "(column") indent_sexp!(pp) newline(pp) - field1588 = unwrapped_fields1587[1] - write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, field1588)) + field1590 = unwrapped_fields1589[1] + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, field1590)) newline(pp) - field1589 = unwrapped_fields1587[2] - pretty_relation_id(pp, field1589) + field1591 = unwrapped_fields1589[2] + pretty_relation_id(pp, field1591) dedent!(pp) write(pp, ")") end @@ -4985,22 +4985,22 @@ function pretty_export_csv_column(pp::PrettyPrinter, msg::Proto.ExportCSVColumn) end function pretty_export_csv_columns_list(pp::PrettyPrinter, msg::Vector{Proto.ExportCSVColumn}) - flat1594 = try_flat(pp, msg, pretty_export_csv_columns_list) - if !isnothing(flat1594) - write(pp, flat1594) + flat1596 = try_flat(pp, msg, pretty_export_csv_columns_list) + if !isnothing(flat1596) + write(pp, flat1596) return nothing else - fields1591 = msg + fields1593 = msg write(pp, "(columns") indent_sexp!(pp) - if !isempty(fields1591) + if !isempty(fields1593) newline(pp) - for (i1799, elem1592) in enumerate(fields1591) - i1593 = i1799 - 1 - if (i1593 > 0) + for (i1803, elem1594) in enumerate(fields1593) + i1595 = i1803 - 1 + if (i1595 > 0) newline(pp) end - pretty_export_csv_column(pp, elem1592) + pretty_export_csv_column(pp, elem1594) end end dedent!(pp) @@ -5010,34 +5010,34 @@ function pretty_export_csv_columns_list(pp::PrettyPrinter, msg::Vector{Proto.Exp end function pretty_export_iceberg_config(pp::PrettyPrinter, msg::Proto.ExportIcebergConfig) - flat1603 = try_flat(pp, msg, pretty_export_iceberg_config) - if !isnothing(flat1603) - write(pp, flat1603) + flat1605 = try_flat(pp, msg, pretty_export_iceberg_config) + if !isnothing(flat1605) + write(pp, flat1605) return nothing else _dollar_dollar = msg - _t1800 = deconstruct_export_iceberg_config_optional(pp, _dollar_dollar) - fields1595 = (_dollar_dollar.locator, _dollar_dollar.config, _dollar_dollar.table_def, sort([(k, v) for (k, v) in _dollar_dollar.table_properties]), _t1800,) - unwrapped_fields1596 = fields1595 + _t1804 = deconstruct_export_iceberg_config_optional(pp, _dollar_dollar) + fields1597 = (_dollar_dollar.locator, _dollar_dollar.config, _dollar_dollar.table_def, sort([(k, v) for (k, v) in _dollar_dollar.table_properties]), _t1804,) + unwrapped_fields1598 = fields1597 write(pp, "(export_iceberg_config") indent_sexp!(pp) newline(pp) - field1597 = unwrapped_fields1596[1] - pretty_iceberg_locator(pp, field1597) + field1599 = unwrapped_fields1598[1] + pretty_iceberg_locator(pp, field1599) newline(pp) - field1598 = unwrapped_fields1596[2] - pretty_iceberg_catalog_config(pp, field1598) + field1600 = unwrapped_fields1598[2] + pretty_iceberg_catalog_config(pp, field1600) newline(pp) - field1599 = unwrapped_fields1596[3] - pretty_export_iceberg_table_def(pp, field1599) + field1601 = unwrapped_fields1598[3] + pretty_export_iceberg_table_def(pp, field1601) newline(pp) - field1600 = unwrapped_fields1596[4] - pretty_iceberg_table_properties(pp, field1600) - field1601 = unwrapped_fields1596[5] - if !isnothing(field1601) + field1602 = unwrapped_fields1598[4] + pretty_iceberg_table_properties(pp, field1602) + field1603 = unwrapped_fields1598[5] + if !isnothing(field1603) newline(pp) - opt_val1602 = field1601 - pretty_config_dict(pp, opt_val1602) + opt_val1604 = field1603 + pretty_config_dict(pp, opt_val1604) end dedent!(pp) write(pp, ")") @@ -5046,16 +5046,16 @@ function pretty_export_iceberg_config(pp::PrettyPrinter, msg::Proto.ExportIceber end function pretty_export_iceberg_table_def(pp::PrettyPrinter, msg::Proto.RelationId) - flat1605 = try_flat(pp, msg, pretty_export_iceberg_table_def) - if !isnothing(flat1605) - write(pp, flat1605) + flat1607 = try_flat(pp, msg, pretty_export_iceberg_table_def) + if !isnothing(flat1607) + write(pp, flat1607) return nothing else - fields1604 = msg + fields1606 = msg write(pp, "(table_def") indent_sexp!(pp) newline(pp) - pretty_relation_id(pp, fields1604) + pretty_relation_id(pp, fields1606) dedent!(pp) write(pp, ")") end @@ -5063,22 +5063,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}}) - flat1609 = try_flat(pp, msg, pretty_iceberg_table_properties) - if !isnothing(flat1609) - write(pp, flat1609) + flat1611 = try_flat(pp, msg, pretty_iceberg_table_properties) + if !isnothing(flat1611) + write(pp, flat1611) return nothing else - fields1606 = msg + fields1608 = msg write(pp, "(table_properties") indent_sexp!(pp) - if !isempty(fields1606) + if !isempty(fields1608) newline(pp) - for (i1801, elem1607) in enumerate(fields1606) - i1608 = i1801 - 1 - if (i1608 > 0) + for (i1805, elem1609) in enumerate(fields1608) + i1610 = i1805 - 1 + if (i1610 > 0) newline(pp) end - pretty_iceberg_property_entry(pp, elem1607) + pretty_iceberg_property_entry(pp, elem1609) end end dedent!(pp) @@ -5088,23 +5088,27 @@ function pretty_iceberg_table_properties(pp::PrettyPrinter, msg::Vector{Tuple{St end function pretty_export_output(pp::PrettyPrinter, msg::Proto.ExportOutput) - flat1612 = try_flat(pp, msg, pretty_export_output) - if !isnothing(flat1612) - write(pp, flat1612) + flat1616 = try_flat(pp, msg, pretty_export_output) + if !isnothing(flat1616) + write(pp, flat1616) return nothing else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("csv")) - _t1802 = _get_oneof_field(_dollar_dollar, :csv) + _t1806 = (_dollar_dollar.name, _get_oneof_field(_dollar_dollar, :csv),) else - _t1802 = nothing + _t1806 = nothing end - fields1610 = _t1802 - unwrapped_fields1611 = fields1610 + fields1612 = _t1806 + unwrapped_fields1613 = fields1612 write(pp, "(export_output") indent_sexp!(pp) newline(pp) - pretty_export_csv_output(pp, unwrapped_fields1611) + field1614 = unwrapped_fields1613[1] + pretty_name(pp, field1614) + newline(pp) + field1615 = unwrapped_fields1613[2] + pretty_export_csv_output(pp, field1615) dedent!(pp) write(pp, ")") end @@ -5112,22 +5116,22 @@ function pretty_export_output(pp::PrettyPrinter, msg::Proto.ExportOutput) end function pretty_export_csv_output(pp::PrettyPrinter, msg::Proto.ExportCSVOutput) - flat1617 = try_flat(pp, msg, pretty_export_csv_output) - if !isnothing(flat1617) - write(pp, flat1617) + flat1621 = try_flat(pp, msg, pretty_export_csv_output) + if !isnothing(flat1621) + write(pp, flat1621) return nothing else _dollar_dollar = msg - fields1613 = (_dollar_dollar.csv_source, _dollar_dollar.csv_config,) - unwrapped_fields1614 = fields1613 + fields1617 = (_dollar_dollar.csv_source, _dollar_dollar.csv_config,) + unwrapped_fields1618 = fields1617 write(pp, "(csv") indent_sexp!(pp) newline(pp) - field1615 = unwrapped_fields1614[1] - pretty_export_csv_source(pp, field1615) + field1619 = unwrapped_fields1618[1] + pretty_export_csv_source(pp, field1619) newline(pp) - field1616 = unwrapped_fields1614[2] - pretty_csv_config(pp, field1616) + field1620 = unwrapped_fields1618[2] + pretty_csv_config(pp, field1620) dedent!(pp) write(pp, ")") end @@ -5140,12 +5144,12 @@ end function pretty_debug_info(pp::PrettyPrinter, msg::Proto.DebugInfo) write(pp, "(debug_info") indent_sexp!(pp) - for (i1854, _rid) in enumerate(msg.ids) - _idx = i1854 - 1 + for (i1858, _rid) in enumerate(msg.ids) + _idx = i1858 - 1 newline(pp) write(pp, "(") - _t1855 = Proto.UInt128Value(low=_rid.id_low, high=_rid.id_high) - _pprint_dispatch(pp, _t1855) + _t1859 = Proto.UInt128Value(low=_rid.id_low, high=_rid.id_high) + _pprint_dispatch(pp, _t1859) write(pp, " ") write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, msg.orig_names[_idx + 1])) write(pp, ")") @@ -5217,8 +5221,8 @@ function pretty_functional_dependency(pp::PrettyPrinter, msg::Proto.FunctionalDe _pprint_dispatch(pp, msg.guard) newline(pp) write(pp, ":keys (") - for (i1856, _elem) in enumerate(msg.keys) - _idx = i1856 - 1 + for (i1860, _elem) in enumerate(msg.keys) + _idx = i1860 - 1 if (_idx > 0) write(pp, " ") end @@ -5227,8 +5231,8 @@ function pretty_functional_dependency(pp::PrettyPrinter, msg::Proto.FunctionalDe write(pp, ")") newline(pp) write(pp, ":values (") - for (i1857, _elem) in enumerate(msg.values) - _idx = i1857 - 1 + for (i1861, _elem) in enumerate(msg.values) + _idx = i1861 - 1 if (_idx > 0) write(pp, " ") end @@ -5282,8 +5286,8 @@ function pretty_export_csv_columns(pp::PrettyPrinter, msg::Proto.ExportCSVColumn indent_sexp!(pp) newline(pp) write(pp, ":columns (") - for (i1858, _elem) in enumerate(msg.columns) - _idx = i1858 - 1 + for (i1862, _elem) in enumerate(msg.columns) + _idx = i1862 - 1 if (_idx > 0) write(pp, " ") end diff --git a/sdks/python/src/lqp/gen/parser.py b/sdks/python/src/lqp/gen/parser.py index 8556c158..0dfe64ca 100644 --- a/sdks/python/src/lqp/gen/parser.py +++ b/sdks/python/src/lqp/gen/parser.py @@ -424,196 +424,196 @@ def relation_id_to_uint128(self, msg): def _extract_value_int32(self, value: logic_pb2.Value | None, default: int) -> int: if value is not None: assert value is not None - _t2113 = value.HasField("int32_value") + _t2116 = value.HasField("int32_value") else: - _t2113 = False - if _t2113: + _t2116 = False + if _t2116: assert value is not None return value.int32_value else: - _t2114 = None + _t2117 = 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 - _t2115 = value.HasField("int_value") + _t2118 = value.HasField("int_value") else: - _t2115 = False - if _t2115: + _t2118 = False + if _t2118: assert value is not None return value.int_value else: - _t2116 = None + _t2119 = 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 - _t2117 = value.HasField("string_value") + _t2120 = value.HasField("string_value") else: - _t2117 = False - if _t2117: + _t2120 = False + if _t2120: assert value is not None return value.string_value else: - _t2118 = None + _t2121 = 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 - _t2119 = value.HasField("boolean_value") + _t2122 = value.HasField("boolean_value") else: - _t2119 = False - if _t2119: + _t2122 = False + if _t2122: assert value is not None return value.boolean_value else: - _t2120 = None + _t2123 = 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 - _t2121 = value.HasField("string_value") + _t2124 = value.HasField("string_value") else: - _t2121 = False - if _t2121: + _t2124 = False + if _t2124: assert value is not None return [value.string_value] else: - _t2122 = None + _t2125 = 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 - _t2123 = value.HasField("int_value") + _t2126 = value.HasField("int_value") else: - _t2123 = False - if _t2123: + _t2126 = False + if _t2126: assert value is not None return value.int_value else: - _t2124 = None + _t2127 = 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 - _t2125 = value.HasField("float_value") + _t2128 = value.HasField("float_value") else: - _t2125 = False - if _t2125: + _t2128 = False + if _t2128: assert value is not None return value.float_value else: - _t2126 = None + _t2129 = 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 - _t2127 = value.HasField("string_value") + _t2130 = value.HasField("string_value") else: - _t2127 = False - if _t2127: + _t2130 = False + if _t2130: assert value is not None return value.string_value.encode() else: - _t2128 = None + _t2131 = 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 - _t2129 = value.HasField("uint128_value") + _t2132 = value.HasField("uint128_value") else: - _t2129 = False - if _t2129: + _t2132 = False + if _t2132: assert value is not None return value.uint128_value else: - _t2130 = None + _t2133 = None return None def construct_csv_config(self, config_dict: Sequence[tuple[str, logic_pb2.Value]], storage_integration_opt: Sequence[tuple[str, logic_pb2.Value]] | None) -> logic_pb2.CSVConfig: config = dict(config_dict) - _t2131 = self._extract_value_int32(config.get("csv_header_row"), 1) - header_row = _t2131 - _t2132 = self._extract_value_int64(config.get("csv_skip"), 0) - skip = _t2132 - _t2133 = self._extract_value_string(config.get("csv_new_line"), "") - new_line = _t2133 - _t2134 = self._extract_value_string(config.get("csv_delimiter"), ",") - delimiter = _t2134 - _t2135 = self._extract_value_string(config.get("csv_quotechar"), '"') - quotechar = _t2135 - _t2136 = self._extract_value_string(config.get("csv_escapechar"), '"') - escapechar = _t2136 - _t2137 = self._extract_value_string(config.get("csv_comment"), "") - comment = _t2137 - _t2138 = self._extract_value_string_list(config.get("csv_missing_strings"), []) - missing_strings = _t2138 - _t2139 = self._extract_value_string(config.get("csv_decimal_separator"), ".") - decimal_separator = _t2139 - _t2140 = self._extract_value_string(config.get("csv_encoding"), "utf-8") - encoding = _t2140 - _t2141 = self._extract_value_string(config.get("csv_compression"), "") - compression = _t2141 - _t2142 = self._extract_value_int64(config.get("csv_partition_size_mb"), 0) - partition_size_mb = _t2142 - _t2143 = self.construct_csv_storage_integration(storage_integration_opt) - storage_integration = _t2143 - _t2144 = 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 _t2144 + _t2134 = self._extract_value_int32(config.get("csv_header_row"), 1) + header_row = _t2134 + _t2135 = self._extract_value_int64(config.get("csv_skip"), 0) + skip = _t2135 + _t2136 = self._extract_value_string(config.get("csv_new_line"), "") + new_line = _t2136 + _t2137 = self._extract_value_string(config.get("csv_delimiter"), ",") + delimiter = _t2137 + _t2138 = self._extract_value_string(config.get("csv_quotechar"), '"') + quotechar = _t2138 + _t2139 = self._extract_value_string(config.get("csv_escapechar"), '"') + escapechar = _t2139 + _t2140 = self._extract_value_string(config.get("csv_comment"), "") + comment = _t2140 + _t2141 = self._extract_value_string_list(config.get("csv_missing_strings"), []) + missing_strings = _t2141 + _t2142 = self._extract_value_string(config.get("csv_decimal_separator"), ".") + decimal_separator = _t2142 + _t2143 = self._extract_value_string(config.get("csv_encoding"), "utf-8") + encoding = _t2143 + _t2144 = self._extract_value_string(config.get("csv_compression"), "") + compression = _t2144 + _t2145 = self._extract_value_int64(config.get("csv_partition_size_mb"), 0) + partition_size_mb = _t2145 + _t2146 = self.construct_csv_storage_integration(storage_integration_opt) + storage_integration = _t2146 + _t2147 = 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 _t2147 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: - _t2145 = None + _t2148 = None assert storage_integration_opt is not None config = dict(storage_integration_opt) - _t2146 = self._extract_value_string(config.get("provider"), "") - _t2147 = self._extract_value_string(config.get("azure_sas_token"), "") - _t2148 = self._extract_value_string(config.get("s3_region"), "") - _t2149 = self._extract_value_string(config.get("s3_access_key_id"), "") - _t2150 = self._extract_value_string(config.get("s3_secret_access_key"), "") - _t2151 = logic_pb2.StorageIntegration(provider=_t2146, azure_sas_token=_t2147, s3_region=_t2148, s3_access_key_id=_t2149, s3_secret_access_key=_t2150) - return _t2151 + _t2149 = self._extract_value_string(config.get("provider"), "") + _t2150 = self._extract_value_string(config.get("azure_sas_token"), "") + _t2151 = self._extract_value_string(config.get("s3_region"), "") + _t2152 = self._extract_value_string(config.get("s3_access_key_id"), "") + _t2153 = self._extract_value_string(config.get("s3_secret_access_key"), "") + _t2154 = logic_pb2.StorageIntegration(provider=_t2149, azure_sas_token=_t2150, s3_region=_t2151, s3_access_key_id=_t2152, s3_secret_access_key=_t2153) + return _t2154 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) - _t2152 = self._try_extract_value_float64(config.get("betree_config_epsilon")) - epsilon = _t2152 - _t2153 = self._try_extract_value_int64(config.get("betree_config_max_pivots")) - max_pivots = _t2153 - _t2154 = self._try_extract_value_int64(config.get("betree_config_max_deltas")) - max_deltas = _t2154 - _t2155 = self._try_extract_value_int64(config.get("betree_config_max_leaf")) - max_leaf = _t2155 - _t2156 = logic_pb2.BeTreeConfig(epsilon=epsilon, max_pivots=max_pivots, max_deltas=max_deltas, max_leaf=max_leaf) - storage_config = _t2156 - _t2157 = self._try_extract_value_uint128(config.get("betree_locator_root_pageid")) - root_pageid = _t2157 - _t2158 = self._try_extract_value_bytes(config.get("betree_locator_inline_data")) - inline_data = _t2158 - _t2159 = self._try_extract_value_int64(config.get("betree_locator_element_count")) - element_count = _t2159 - _t2160 = self._try_extract_value_int64(config.get("betree_locator_tree_height")) - tree_height = _t2160 - _t2161 = logic_pb2.BeTreeLocator(root_pageid=root_pageid, inline_data=inline_data, element_count=element_count, tree_height=tree_height) - relation_locator = _t2161 - _t2162 = logic_pb2.BeTreeInfo(key_types=key_types, value_types=value_types, storage_config=storage_config, relation_locator=relation_locator) - return _t2162 + _t2155 = self._try_extract_value_float64(config.get("betree_config_epsilon")) + epsilon = _t2155 + _t2156 = self._try_extract_value_int64(config.get("betree_config_max_pivots")) + max_pivots = _t2156 + _t2157 = self._try_extract_value_int64(config.get("betree_config_max_deltas")) + max_deltas = _t2157 + _t2158 = self._try_extract_value_int64(config.get("betree_config_max_leaf")) + max_leaf = _t2158 + _t2159 = logic_pb2.BeTreeConfig(epsilon=epsilon, max_pivots=max_pivots, max_deltas=max_deltas, max_leaf=max_leaf) + storage_config = _t2159 + _t2160 = self._try_extract_value_uint128(config.get("betree_locator_root_pageid")) + root_pageid = _t2160 + _t2161 = self._try_extract_value_bytes(config.get("betree_locator_inline_data")) + inline_data = _t2161 + _t2162 = self._try_extract_value_int64(config.get("betree_locator_element_count")) + element_count = _t2162 + _t2163 = self._try_extract_value_int64(config.get("betree_locator_tree_height")) + tree_height = _t2163 + _t2164 = logic_pb2.BeTreeLocator(root_pageid=root_pageid, inline_data=inline_data, element_count=element_count, tree_height=tree_height) + relation_locator = _t2164 + _t2165 = logic_pb2.BeTreeInfo(key_types=key_types, value_types=value_types, storage_config=storage_config, relation_locator=relation_locator) + return _t2165 def default_configure(self) -> transactions_pb2.Configure: - _t2163 = transactions_pb2.IVMConfig(level=transactions_pb2.MaintenanceLevel.MAINTENANCE_LEVEL_OFF) - ivm_config = _t2163 - _t2164 = transactions_pb2.Configure(semantics_version=0, ivm_config=ivm_config) - return _t2164 + _t2166 = transactions_pb2.IVMConfig(level=transactions_pb2.MaintenanceLevel.MAINTENANCE_LEVEL_OFF) + ivm_config = _t2166 + _t2167 = transactions_pb2.Configure(semantics_version=0, ivm_config=ivm_config) + return _t2167 def construct_configure(self, config_dict: Sequence[tuple[str, logic_pb2.Value]]) -> transactions_pb2.Configure: config = dict(config_dict) @@ -630,3413 +630,3415 @@ 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 - _t2165 = transactions_pb2.IVMConfig(level=maintenance_level) - ivm_config = _t2165 - _t2166 = self._extract_value_int64(config.get("semantics_version"), 0) - semantics_version = _t2166 - _t2167 = transactions_pb2.Configure(semantics_version=semantics_version, ivm_config=ivm_config) - return _t2167 + _t2168 = transactions_pb2.IVMConfig(level=maintenance_level) + ivm_config = _t2168 + _t2169 = self._extract_value_int64(config.get("semantics_version"), 0) + semantics_version = _t2169 + _t2170 = transactions_pb2.Configure(semantics_version=semantics_version, ivm_config=ivm_config) + return _t2170 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) - _t2168 = self._extract_value_int64(config.get("partition_size"), 0) - partition_size = _t2168 - _t2169 = self._extract_value_string(config.get("compression"), "") - compression = _t2169 - _t2170 = self._extract_value_boolean(config.get("syntax_header_row"), True) - syntax_header_row = _t2170 - _t2171 = self._extract_value_string(config.get("syntax_missing_string"), "") - syntax_missing_string = _t2171 - _t2172 = self._extract_value_string(config.get("syntax_delim"), ",") - syntax_delim = _t2172 - _t2173 = self._extract_value_string(config.get("syntax_quotechar"), '"') - syntax_quotechar = _t2173 - _t2174 = self._extract_value_string(config.get("syntax_escapechar"), "\\") - syntax_escapechar = _t2174 - _t2175 = 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 _t2175 + _t2171 = self._extract_value_int64(config.get("partition_size"), 0) + partition_size = _t2171 + _t2172 = self._extract_value_string(config.get("compression"), "") + compression = _t2172 + _t2173 = self._extract_value_boolean(config.get("syntax_header_row"), True) + syntax_header_row = _t2173 + _t2174 = self._extract_value_string(config.get("syntax_missing_string"), "") + syntax_missing_string = _t2174 + _t2175 = self._extract_value_string(config.get("syntax_delim"), ",") + syntax_delim = _t2175 + _t2176 = self._extract_value_string(config.get("syntax_quotechar"), '"') + syntax_quotechar = _t2176 + _t2177 = self._extract_value_string(config.get("syntax_escapechar"), "\\") + syntax_escapechar = _t2177 + _t2178 = 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 _t2178 def construct_export_csv_config_with_source(self, path: str, csv_source: transactions_pb2.ExportCSVSource, csv_config: logic_pb2.CSVConfig) -> transactions_pb2.ExportCSVConfig: - _t2176 = transactions_pb2.ExportCSVConfig(path=path, csv_source=csv_source, csv_config=csv_config) - return _t2176 + _t2179 = transactions_pb2.ExportCSVConfig(path=path, csv_source=csv_source, csv_config=csv_config) + return _t2179 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) - _t2177 = logic_pb2.IcebergCatalogConfig(catalog_uri=catalog_uri, scope=(scope_opt if scope_opt is not None else ""), properties=props, auth_properties=auth_props) - return _t2177 + _t2180 = logic_pb2.IcebergCatalogConfig(catalog_uri=catalog_uri, scope=(scope_opt if scope_opt is not None else ""), properties=props, auth_properties=auth_props) + return _t2180 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: - _t2178 = 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 _t2178 + _t2181 = 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 _t2181 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 [])) - _t2179 = self._extract_value_string(cfg.get("prefix"), "") - prefix = _t2179 - _t2180 = self._extract_value_int64(cfg.get("target_file_size_bytes"), 0) - target_file_size_bytes = _t2180 - _t2181 = self._extract_value_string(cfg.get("compression"), "") - compression = _t2181 + _t2182 = self._extract_value_string(cfg.get("prefix"), "") + prefix = _t2182 + _t2183 = self._extract_value_int64(cfg.get("target_file_size_bytes"), 0) + target_file_size_bytes = _t2183 + _t2184 = self._extract_value_string(cfg.get("compression"), "") + compression = _t2184 table_props = dict(table_property_pairs) - _t2182 = 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 _t2182 + _t2185 = 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 _t2185 # --- Parse methods --- def parse_transaction(self) -> transactions_pb2.Transaction: - span_start681 = self.span_start() + span_start682 = self.span_start() self.consume_literal("(") self.consume_literal("transaction") if (self.match_lookahead_literal("(", 0) and self.match_lookahead_literal("configure", 1)): - _t1351 = self.parse_configure() - _t1350 = _t1351 - else: - _t1350 = None - configure675 = _t1350 - if (self.match_lookahead_literal("(", 0) and self.match_lookahead_literal("sync", 1)): - _t1353 = self.parse_sync() + _t1353 = self.parse_configure() _t1352 = _t1353 else: _t1352 = None - sync676 = _t1352 - xs677 = [] - cond678 = self.match_lookahead_literal("(", 0) - while cond678: - _t1354 = self.parse_epoch() - item679 = _t1354 - xs677.append(item679) - cond678 = self.match_lookahead_literal("(", 0) - epochs680 = xs677 - self.consume_literal(")") - _t1355 = self.default_configure() - _t1356 = transactions_pb2.Transaction(epochs=epochs680, configure=(configure675 if configure675 is not None else _t1355), sync=sync676) - result682 = _t1356 - self.record_span(span_start681, "Transaction") - return result682 + configure676 = _t1352 + if (self.match_lookahead_literal("(", 0) and self.match_lookahead_literal("sync", 1)): + _t1355 = self.parse_sync() + _t1354 = _t1355 + else: + _t1354 = None + sync677 = _t1354 + xs678 = [] + cond679 = self.match_lookahead_literal("(", 0) + while cond679: + _t1356 = self.parse_epoch() + item680 = _t1356 + xs678.append(item680) + cond679 = self.match_lookahead_literal("(", 0) + epochs681 = xs678 + self.consume_literal(")") + _t1357 = self.default_configure() + _t1358 = transactions_pb2.Transaction(epochs=epochs681, configure=(configure676 if configure676 is not None else _t1357), sync=sync677) + result683 = _t1358 + self.record_span(span_start682, "Transaction") + return result683 def parse_configure(self) -> transactions_pb2.Configure: - span_start684 = self.span_start() + span_start685 = self.span_start() self.consume_literal("(") self.consume_literal("configure") - _t1357 = self.parse_config_dict() - config_dict683 = _t1357 + _t1359 = self.parse_config_dict() + config_dict684 = _t1359 self.consume_literal(")") - _t1358 = self.construct_configure(config_dict683) - result685 = _t1358 - self.record_span(span_start684, "Configure") - return result685 + _t1360 = self.construct_configure(config_dict684) + result686 = _t1360 + self.record_span(span_start685, "Configure") + return result686 def parse_config_dict(self) -> Sequence[tuple[str, logic_pb2.Value]]: self.consume_literal("{") - xs686 = [] - cond687 = self.match_lookahead_literal(":", 0) - while cond687: - _t1359 = self.parse_config_key_value() - item688 = _t1359 - xs686.append(item688) - cond687 = self.match_lookahead_literal(":", 0) - config_key_values689 = xs686 + xs687 = [] + cond688 = self.match_lookahead_literal(":", 0) + while cond688: + _t1361 = self.parse_config_key_value() + item689 = _t1361 + xs687.append(item689) + cond688 = self.match_lookahead_literal(":", 0) + config_key_values690 = xs687 self.consume_literal("}") - return config_key_values689 + return config_key_values690 def parse_config_key_value(self) -> tuple[str, logic_pb2.Value]: self.consume_literal(":") - symbol690 = self.consume_terminal("SYMBOL") - _t1360 = self.parse_raw_value() - raw_value691 = _t1360 - return (symbol690, raw_value691,) + symbol691 = self.consume_terminal("SYMBOL") + _t1362 = self.parse_raw_value() + raw_value692 = _t1362 + return (symbol691, raw_value692,) def parse_raw_value(self) -> logic_pb2.Value: - span_start705 = self.span_start() + span_start706 = self.span_start() if self.match_lookahead_literal("true", 0): - _t1361 = 12 + _t1363 = 12 else: if self.match_lookahead_literal("missing", 0): - _t1362 = 11 + _t1364 = 11 else: if self.match_lookahead_literal("false", 0): - _t1363 = 12 + _t1365 = 12 else: if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("datetime", 1): - _t1365 = 1 + _t1367 = 1 else: if self.match_lookahead_literal("date", 1): - _t1366 = 0 + _t1368 = 0 else: - _t1366 = -1 - _t1365 = _t1366 - _t1364 = _t1365 + _t1368 = -1 + _t1367 = _t1368 + _t1366 = _t1367 else: if self.match_lookahead_terminal("UINT32", 0): - _t1367 = 7 + _t1369 = 7 else: if self.match_lookahead_terminal("UINT128", 0): - _t1368 = 8 + _t1370 = 8 else: if self.match_lookahead_terminal("STRING", 0): - _t1369 = 2 + _t1371 = 2 else: if self.match_lookahead_terminal("INT32", 0): - _t1370 = 3 + _t1372 = 3 else: if self.match_lookahead_terminal("INT128", 0): - _t1371 = 9 + _t1373 = 9 else: if self.match_lookahead_terminal("INT", 0): - _t1372 = 4 + _t1374 = 4 else: if self.match_lookahead_terminal("FLOAT32", 0): - _t1373 = 5 + _t1375 = 5 else: if self.match_lookahead_terminal("FLOAT", 0): - _t1374 = 6 + _t1376 = 6 else: if self.match_lookahead_terminal("DECIMAL", 0): - _t1375 = 10 + _t1377 = 10 else: - _t1375 = -1 - _t1374 = _t1375 - _t1373 = _t1374 - _t1372 = _t1373 - _t1371 = _t1372 - _t1370 = _t1371 - _t1369 = _t1370 - _t1368 = _t1369 - _t1367 = _t1368 - _t1364 = _t1367 - _t1363 = _t1364 - _t1362 = _t1363 - _t1361 = _t1362 - prediction692 = _t1361 - if prediction692 == 12: - _t1377 = self.parse_boolean_value() - boolean_value704 = _t1377 - _t1378 = logic_pb2.Value(boolean_value=boolean_value704) - _t1376 = _t1378 - else: - if prediction692 == 11: + _t1377 = -1 + _t1376 = _t1377 + _t1375 = _t1376 + _t1374 = _t1375 + _t1373 = _t1374 + _t1372 = _t1373 + _t1371 = _t1372 + _t1370 = _t1371 + _t1369 = _t1370 + _t1366 = _t1369 + _t1365 = _t1366 + _t1364 = _t1365 + _t1363 = _t1364 + prediction693 = _t1363 + if prediction693 == 12: + _t1379 = self.parse_boolean_value() + boolean_value705 = _t1379 + _t1380 = logic_pb2.Value(boolean_value=boolean_value705) + _t1378 = _t1380 + else: + if prediction693 == 11: self.consume_literal("missing") - _t1380 = logic_pb2.MissingValue() - _t1381 = logic_pb2.Value(missing_value=_t1380) - _t1379 = _t1381 + _t1382 = logic_pb2.MissingValue() + _t1383 = logic_pb2.Value(missing_value=_t1382) + _t1381 = _t1383 else: - if prediction692 == 10: - decimal703 = self.consume_terminal("DECIMAL") - _t1383 = logic_pb2.Value(decimal_value=decimal703) - _t1382 = _t1383 + if prediction693 == 10: + decimal704 = self.consume_terminal("DECIMAL") + _t1385 = logic_pb2.Value(decimal_value=decimal704) + _t1384 = _t1385 else: - if prediction692 == 9: - int128702 = self.consume_terminal("INT128") - _t1385 = logic_pb2.Value(int128_value=int128702) - _t1384 = _t1385 + if prediction693 == 9: + int128703 = self.consume_terminal("INT128") + _t1387 = logic_pb2.Value(int128_value=int128703) + _t1386 = _t1387 else: - if prediction692 == 8: - uint128701 = self.consume_terminal("UINT128") - _t1387 = logic_pb2.Value(uint128_value=uint128701) - _t1386 = _t1387 + if prediction693 == 8: + uint128702 = self.consume_terminal("UINT128") + _t1389 = logic_pb2.Value(uint128_value=uint128702) + _t1388 = _t1389 else: - if prediction692 == 7: - uint32700 = self.consume_terminal("UINT32") - _t1389 = logic_pb2.Value(uint32_value=uint32700) - _t1388 = _t1389 + if prediction693 == 7: + uint32701 = self.consume_terminal("UINT32") + _t1391 = logic_pb2.Value(uint32_value=uint32701) + _t1390 = _t1391 else: - if prediction692 == 6: - float699 = self.consume_terminal("FLOAT") - _t1391 = logic_pb2.Value(float_value=float699) - _t1390 = _t1391 + if prediction693 == 6: + float700 = self.consume_terminal("FLOAT") + _t1393 = logic_pb2.Value(float_value=float700) + _t1392 = _t1393 else: - if prediction692 == 5: - float32698 = self.consume_terminal("FLOAT32") - _t1393 = logic_pb2.Value(float32_value=float32698) - _t1392 = _t1393 + if prediction693 == 5: + float32699 = self.consume_terminal("FLOAT32") + _t1395 = logic_pb2.Value(float32_value=float32699) + _t1394 = _t1395 else: - if prediction692 == 4: - int697 = self.consume_terminal("INT") - _t1395 = logic_pb2.Value(int_value=int697) - _t1394 = _t1395 + if prediction693 == 4: + int698 = self.consume_terminal("INT") + _t1397 = logic_pb2.Value(int_value=int698) + _t1396 = _t1397 else: - if prediction692 == 3: - int32696 = self.consume_terminal("INT32") - _t1397 = logic_pb2.Value(int32_value=int32696) - _t1396 = _t1397 + if prediction693 == 3: + int32697 = self.consume_terminal("INT32") + _t1399 = logic_pb2.Value(int32_value=int32697) + _t1398 = _t1399 else: - if prediction692 == 2: - string695 = self.consume_terminal("STRING") - _t1399 = logic_pb2.Value(string_value=string695) - _t1398 = _t1399 + if prediction693 == 2: + string696 = self.consume_terminal("STRING") + _t1401 = logic_pb2.Value(string_value=string696) + _t1400 = _t1401 else: - if prediction692 == 1: - _t1401 = self.parse_raw_datetime() - raw_datetime694 = _t1401 - _t1402 = logic_pb2.Value(datetime_value=raw_datetime694) - _t1400 = _t1402 + if prediction693 == 1: + _t1403 = self.parse_raw_datetime() + raw_datetime695 = _t1403 + _t1404 = logic_pb2.Value(datetime_value=raw_datetime695) + _t1402 = _t1404 else: - if prediction692 == 0: - _t1404 = self.parse_raw_date() - raw_date693 = _t1404 - _t1405 = logic_pb2.Value(date_value=raw_date693) - _t1403 = _t1405 + if prediction693 == 0: + _t1406 = self.parse_raw_date() + raw_date694 = _t1406 + _t1407 = logic_pb2.Value(date_value=raw_date694) + _t1405 = _t1407 else: raise ParseError("Unexpected token in raw_value" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1400 = _t1403 - _t1398 = _t1400 - _t1396 = _t1398 - _t1394 = _t1396 - _t1392 = _t1394 - _t1390 = _t1392 - _t1388 = _t1390 - _t1386 = _t1388 - _t1384 = _t1386 - _t1382 = _t1384 - _t1379 = _t1382 - _t1376 = _t1379 - result706 = _t1376 - self.record_span(span_start705, "Value") - return result706 + _t1402 = _t1405 + _t1400 = _t1402 + _t1398 = _t1400 + _t1396 = _t1398 + _t1394 = _t1396 + _t1392 = _t1394 + _t1390 = _t1392 + _t1388 = _t1390 + _t1386 = _t1388 + _t1384 = _t1386 + _t1381 = _t1384 + _t1378 = _t1381 + result707 = _t1378 + self.record_span(span_start706, "Value") + return result707 def parse_raw_date(self) -> logic_pb2.DateValue: - span_start710 = self.span_start() + span_start711 = self.span_start() self.consume_literal("(") self.consume_literal("date") - int707 = self.consume_terminal("INT") - int_3708 = self.consume_terminal("INT") - int_4709 = self.consume_terminal("INT") + int708 = self.consume_terminal("INT") + int_3709 = self.consume_terminal("INT") + int_4710 = self.consume_terminal("INT") self.consume_literal(")") - _t1406 = logic_pb2.DateValue(year=int(int707), month=int(int_3708), day=int(int_4709)) - result711 = _t1406 - self.record_span(span_start710, "DateValue") - return result711 + _t1408 = logic_pb2.DateValue(year=int(int708), month=int(int_3709), day=int(int_4710)) + result712 = _t1408 + self.record_span(span_start711, "DateValue") + return result712 def parse_raw_datetime(self) -> logic_pb2.DateTimeValue: - span_start719 = self.span_start() + span_start720 = self.span_start() self.consume_literal("(") self.consume_literal("datetime") - int712 = self.consume_terminal("INT") - int_3713 = self.consume_terminal("INT") - int_4714 = self.consume_terminal("INT") - int_5715 = self.consume_terminal("INT") - int_6716 = self.consume_terminal("INT") - int_7717 = self.consume_terminal("INT") + int713 = self.consume_terminal("INT") + int_3714 = self.consume_terminal("INT") + int_4715 = self.consume_terminal("INT") + int_5716 = self.consume_terminal("INT") + int_6717 = self.consume_terminal("INT") + int_7718 = self.consume_terminal("INT") if self.match_lookahead_terminal("INT", 0): - _t1407 = self.consume_terminal("INT") + _t1409 = self.consume_terminal("INT") else: - _t1407 = None - int_8718 = _t1407 + _t1409 = None + int_8719 = _t1409 self.consume_literal(")") - _t1408 = logic_pb2.DateTimeValue(year=int(int712), month=int(int_3713), day=int(int_4714), hour=int(int_5715), minute=int(int_6716), second=int(int_7717), microsecond=int((int_8718 if int_8718 is not None else 0))) - result720 = _t1408 - self.record_span(span_start719, "DateTimeValue") - return result720 + _t1410 = logic_pb2.DateTimeValue(year=int(int713), month=int(int_3714), day=int(int_4715), hour=int(int_5716), minute=int(int_6717), second=int(int_7718), microsecond=int((int_8719 if int_8719 is not None else 0))) + result721 = _t1410 + self.record_span(span_start720, "DateTimeValue") + return result721 def parse_boolean_value(self) -> bool: if self.match_lookahead_literal("true", 0): - _t1409 = 0 + _t1411 = 0 else: if self.match_lookahead_literal("false", 0): - _t1410 = 1 + _t1412 = 1 else: - _t1410 = -1 - _t1409 = _t1410 - prediction721 = _t1409 - if prediction721 == 1: + _t1412 = -1 + _t1411 = _t1412 + prediction722 = _t1411 + if prediction722 == 1: self.consume_literal("false") - _t1411 = False + _t1413 = False else: - if prediction721 == 0: + if prediction722 == 0: self.consume_literal("true") - _t1412 = True + _t1414 = True else: raise ParseError("Unexpected token in boolean_value" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1411 = _t1412 - return _t1411 + _t1413 = _t1414 + return _t1413 def parse_sync(self) -> transactions_pb2.Sync: - span_start726 = self.span_start() + span_start727 = self.span_start() self.consume_literal("(") self.consume_literal("sync") - xs722 = [] - cond723 = self.match_lookahead_literal(":", 0) - while cond723: - _t1413 = self.parse_fragment_id() - item724 = _t1413 - xs722.append(item724) - cond723 = self.match_lookahead_literal(":", 0) - fragment_ids725 = xs722 - self.consume_literal(")") - _t1414 = transactions_pb2.Sync(fragments=fragment_ids725) - result727 = _t1414 - self.record_span(span_start726, "Sync") - return result727 + xs723 = [] + cond724 = self.match_lookahead_literal(":", 0) + while cond724: + _t1415 = self.parse_fragment_id() + item725 = _t1415 + xs723.append(item725) + cond724 = self.match_lookahead_literal(":", 0) + fragment_ids726 = xs723 + self.consume_literal(")") + _t1416 = transactions_pb2.Sync(fragments=fragment_ids726) + result728 = _t1416 + self.record_span(span_start727, "Sync") + return result728 def parse_fragment_id(self) -> fragments_pb2.FragmentId: - span_start729 = self.span_start() + span_start730 = self.span_start() self.consume_literal(":") - symbol728 = self.consume_terminal("SYMBOL") - result730 = fragments_pb2.FragmentId(id=symbol728.encode()) - self.record_span(span_start729, "FragmentId") - return result730 + symbol729 = self.consume_terminal("SYMBOL") + result731 = fragments_pb2.FragmentId(id=symbol729.encode()) + self.record_span(span_start730, "FragmentId") + return result731 def parse_epoch(self) -> transactions_pb2.Epoch: - span_start733 = self.span_start() + span_start734 = self.span_start() self.consume_literal("(") self.consume_literal("epoch") if (self.match_lookahead_literal("(", 0) and self.match_lookahead_literal("writes", 1)): - _t1416 = self.parse_epoch_writes() - _t1415 = _t1416 - else: - _t1415 = None - epoch_writes731 = _t1415 - if self.match_lookahead_literal("(", 0): - _t1418 = self.parse_epoch_reads() + _t1418 = self.parse_epoch_writes() _t1417 = _t1418 else: _t1417 = None - epoch_reads732 = _t1417 + epoch_writes732 = _t1417 + if self.match_lookahead_literal("(", 0): + _t1420 = self.parse_epoch_reads() + _t1419 = _t1420 + else: + _t1419 = None + epoch_reads733 = _t1419 self.consume_literal(")") - _t1419 = transactions_pb2.Epoch(writes=(epoch_writes731 if epoch_writes731 is not None else []), reads=(epoch_reads732 if epoch_reads732 is not None else [])) - result734 = _t1419 - self.record_span(span_start733, "Epoch") - return result734 + _t1421 = transactions_pb2.Epoch(writes=(epoch_writes732 if epoch_writes732 is not None else []), reads=(epoch_reads733 if epoch_reads733 is not None else [])) + result735 = _t1421 + self.record_span(span_start734, "Epoch") + return result735 def parse_epoch_writes(self) -> Sequence[transactions_pb2.Write]: self.consume_literal("(") self.consume_literal("writes") - xs735 = [] - cond736 = self.match_lookahead_literal("(", 0) - while cond736: - _t1420 = self.parse_write() - item737 = _t1420 - xs735.append(item737) - cond736 = self.match_lookahead_literal("(", 0) - writes738 = xs735 + xs736 = [] + cond737 = self.match_lookahead_literal("(", 0) + while cond737: + _t1422 = self.parse_write() + item738 = _t1422 + xs736.append(item738) + cond737 = self.match_lookahead_literal("(", 0) + writes739 = xs736 self.consume_literal(")") - return writes738 + return writes739 def parse_write(self) -> transactions_pb2.Write: - span_start744 = self.span_start() + span_start745 = self.span_start() if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("undefine", 1): - _t1422 = 1 + _t1424 = 1 else: if self.match_lookahead_literal("snapshot", 1): - _t1423 = 3 + _t1425 = 3 else: if self.match_lookahead_literal("define", 1): - _t1424 = 0 + _t1426 = 0 else: if self.match_lookahead_literal("context", 1): - _t1425 = 2 + _t1427 = 2 else: - _t1425 = -1 - _t1424 = _t1425 - _t1423 = _t1424 - _t1422 = _t1423 - _t1421 = _t1422 - else: - _t1421 = -1 - prediction739 = _t1421 - if prediction739 == 3: - _t1427 = self.parse_snapshot() - snapshot743 = _t1427 - _t1428 = transactions_pb2.Write(snapshot=snapshot743) - _t1426 = _t1428 - else: - if prediction739 == 2: - _t1430 = self.parse_context() - context742 = _t1430 - _t1431 = transactions_pb2.Write(context=context742) - _t1429 = _t1431 + _t1427 = -1 + _t1426 = _t1427 + _t1425 = _t1426 + _t1424 = _t1425 + _t1423 = _t1424 + else: + _t1423 = -1 + prediction740 = _t1423 + if prediction740 == 3: + _t1429 = self.parse_snapshot() + snapshot744 = _t1429 + _t1430 = transactions_pb2.Write(snapshot=snapshot744) + _t1428 = _t1430 + else: + if prediction740 == 2: + _t1432 = self.parse_context() + context743 = _t1432 + _t1433 = transactions_pb2.Write(context=context743) + _t1431 = _t1433 else: - if prediction739 == 1: - _t1433 = self.parse_undefine() - undefine741 = _t1433 - _t1434 = transactions_pb2.Write(undefine=undefine741) - _t1432 = _t1434 + if prediction740 == 1: + _t1435 = self.parse_undefine() + undefine742 = _t1435 + _t1436 = transactions_pb2.Write(undefine=undefine742) + _t1434 = _t1436 else: - if prediction739 == 0: - _t1436 = self.parse_define() - define740 = _t1436 - _t1437 = transactions_pb2.Write(define=define740) - _t1435 = _t1437 + if prediction740 == 0: + _t1438 = self.parse_define() + define741 = _t1438 + _t1439 = transactions_pb2.Write(define=define741) + _t1437 = _t1439 else: raise ParseError("Unexpected token in write" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1432 = _t1435 - _t1429 = _t1432 - _t1426 = _t1429 - result745 = _t1426 - self.record_span(span_start744, "Write") - return result745 + _t1434 = _t1437 + _t1431 = _t1434 + _t1428 = _t1431 + result746 = _t1428 + self.record_span(span_start745, "Write") + return result746 def parse_define(self) -> transactions_pb2.Define: - span_start747 = self.span_start() + span_start748 = self.span_start() self.consume_literal("(") self.consume_literal("define") - _t1438 = self.parse_fragment() - fragment746 = _t1438 + _t1440 = self.parse_fragment() + fragment747 = _t1440 self.consume_literal(")") - _t1439 = transactions_pb2.Define(fragment=fragment746) - result748 = _t1439 - self.record_span(span_start747, "Define") - return result748 + _t1441 = transactions_pb2.Define(fragment=fragment747) + result749 = _t1441 + self.record_span(span_start748, "Define") + return result749 def parse_fragment(self) -> fragments_pb2.Fragment: - span_start754 = self.span_start() + span_start755 = self.span_start() self.consume_literal("(") self.consume_literal("fragment") - _t1440 = self.parse_new_fragment_id() - new_fragment_id749 = _t1440 - xs750 = [] - cond751 = self.match_lookahead_literal("(", 0) - while cond751: - _t1441 = self.parse_declaration() - item752 = _t1441 - xs750.append(item752) - cond751 = self.match_lookahead_literal("(", 0) - declarations753 = xs750 - self.consume_literal(")") - result755 = self.construct_fragment(new_fragment_id749, declarations753) - self.record_span(span_start754, "Fragment") - return result755 + _t1442 = self.parse_new_fragment_id() + new_fragment_id750 = _t1442 + xs751 = [] + cond752 = self.match_lookahead_literal("(", 0) + while cond752: + _t1443 = self.parse_declaration() + item753 = _t1443 + xs751.append(item753) + cond752 = self.match_lookahead_literal("(", 0) + declarations754 = xs751 + self.consume_literal(")") + result756 = self.construct_fragment(new_fragment_id750, declarations754) + self.record_span(span_start755, "Fragment") + return result756 def parse_new_fragment_id(self) -> fragments_pb2.FragmentId: - span_start757 = self.span_start() - _t1442 = self.parse_fragment_id() - fragment_id756 = _t1442 - self.start_fragment(fragment_id756) - result758 = fragment_id756 - self.record_span(span_start757, "FragmentId") - return result758 + span_start758 = self.span_start() + _t1444 = self.parse_fragment_id() + fragment_id757 = _t1444 + self.start_fragment(fragment_id757) + result759 = fragment_id757 + self.record_span(span_start758, "FragmentId") + return result759 def parse_declaration(self) -> logic_pb2.Declaration: - span_start764 = self.span_start() + span_start765 = self.span_start() if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("iceberg_data", 1): - _t1444 = 3 + _t1446 = 3 else: if self.match_lookahead_literal("functional_dependency", 1): - _t1445 = 2 + _t1447 = 2 else: if self.match_lookahead_literal("edb", 1): - _t1446 = 3 + _t1448 = 3 else: if self.match_lookahead_literal("def", 1): - _t1447 = 0 + _t1449 = 0 else: if self.match_lookahead_literal("csv_data", 1): - _t1448 = 3 + _t1450 = 3 else: if self.match_lookahead_literal("betree_relation", 1): - _t1449 = 3 + _t1451 = 3 else: if self.match_lookahead_literal("algorithm", 1): - _t1450 = 1 + _t1452 = 1 else: - _t1450 = -1 - _t1449 = _t1450 - _t1448 = _t1449 - _t1447 = _t1448 - _t1446 = _t1447 - _t1445 = _t1446 - _t1444 = _t1445 - _t1443 = _t1444 - else: - _t1443 = -1 - prediction759 = _t1443 - if prediction759 == 3: - _t1452 = self.parse_data() - data763 = _t1452 - _t1453 = logic_pb2.Declaration(data=data763) - _t1451 = _t1453 - else: - if prediction759 == 2: - _t1455 = self.parse_constraint() - constraint762 = _t1455 - _t1456 = logic_pb2.Declaration(constraint=constraint762) - _t1454 = _t1456 + _t1452 = -1 + _t1451 = _t1452 + _t1450 = _t1451 + _t1449 = _t1450 + _t1448 = _t1449 + _t1447 = _t1448 + _t1446 = _t1447 + _t1445 = _t1446 + else: + _t1445 = -1 + prediction760 = _t1445 + if prediction760 == 3: + _t1454 = self.parse_data() + data764 = _t1454 + _t1455 = logic_pb2.Declaration(data=data764) + _t1453 = _t1455 + else: + if prediction760 == 2: + _t1457 = self.parse_constraint() + constraint763 = _t1457 + _t1458 = logic_pb2.Declaration(constraint=constraint763) + _t1456 = _t1458 else: - if prediction759 == 1: - _t1458 = self.parse_algorithm() - algorithm761 = _t1458 - _t1459 = logic_pb2.Declaration(algorithm=algorithm761) - _t1457 = _t1459 + if prediction760 == 1: + _t1460 = self.parse_algorithm() + algorithm762 = _t1460 + _t1461 = logic_pb2.Declaration(algorithm=algorithm762) + _t1459 = _t1461 else: - if prediction759 == 0: - _t1461 = self.parse_def() - def760 = _t1461 - _t1462 = logic_pb2.Declaration() - getattr(_t1462, 'def').CopyFrom(def760) - _t1460 = _t1462 + if prediction760 == 0: + _t1463 = self.parse_def() + def761 = _t1463 + _t1464 = logic_pb2.Declaration() + getattr(_t1464, 'def').CopyFrom(def761) + _t1462 = _t1464 else: raise ParseError("Unexpected token in declaration" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1457 = _t1460 - _t1454 = _t1457 - _t1451 = _t1454 - result765 = _t1451 - self.record_span(span_start764, "Declaration") - return result765 + _t1459 = _t1462 + _t1456 = _t1459 + _t1453 = _t1456 + result766 = _t1453 + self.record_span(span_start765, "Declaration") + return result766 def parse_def(self) -> logic_pb2.Def: - span_start769 = self.span_start() + span_start770 = self.span_start() self.consume_literal("(") self.consume_literal("def") - _t1463 = self.parse_relation_id() - relation_id766 = _t1463 - _t1464 = self.parse_abstraction() - abstraction767 = _t1464 + _t1465 = self.parse_relation_id() + relation_id767 = _t1465 + _t1466 = self.parse_abstraction() + abstraction768 = _t1466 if self.match_lookahead_literal("(", 0): - _t1466 = self.parse_attrs() - _t1465 = _t1466 + _t1468 = self.parse_attrs() + _t1467 = _t1468 else: - _t1465 = None - attrs768 = _t1465 + _t1467 = None + attrs769 = _t1467 self.consume_literal(")") - _t1467 = logic_pb2.Def(name=relation_id766, body=abstraction767, attrs=(attrs768 if attrs768 is not None else [])) - result770 = _t1467 - self.record_span(span_start769, "Def") - return result770 + _t1469 = logic_pb2.Def(name=relation_id767, body=abstraction768, attrs=(attrs769 if attrs769 is not None else [])) + result771 = _t1469 + self.record_span(span_start770, "Def") + return result771 def parse_relation_id(self) -> logic_pb2.RelationId: - span_start774 = self.span_start() + span_start775 = self.span_start() if self.match_lookahead_literal(":", 0): - _t1468 = 0 + _t1470 = 0 else: if self.match_lookahead_terminal("UINT128", 0): - _t1469 = 1 + _t1471 = 1 else: - _t1469 = -1 - _t1468 = _t1469 - prediction771 = _t1468 - if prediction771 == 1: - uint128773 = self.consume_terminal("UINT128") - _t1470 = logic_pb2.RelationId(id_low=uint128773.low, id_high=uint128773.high) - else: - if prediction771 == 0: + _t1471 = -1 + _t1470 = _t1471 + prediction772 = _t1470 + if prediction772 == 1: + uint128774 = self.consume_terminal("UINT128") + _t1472 = logic_pb2.RelationId(id_low=uint128774.low, id_high=uint128774.high) + else: + if prediction772 == 0: self.consume_literal(":") - symbol772 = self.consume_terminal("SYMBOL") - _t1471 = self.relation_id_from_string(symbol772) + symbol773 = self.consume_terminal("SYMBOL") + _t1473 = self.relation_id_from_string(symbol773) else: raise ParseError("Unexpected token in relation_id" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1470 = _t1471 - result775 = _t1470 - self.record_span(span_start774, "RelationId") - return result775 + _t1472 = _t1473 + result776 = _t1472 + self.record_span(span_start775, "RelationId") + return result776 def parse_abstraction(self) -> logic_pb2.Abstraction: - span_start778 = self.span_start() + span_start779 = self.span_start() self.consume_literal("(") - _t1472 = self.parse_bindings() - bindings776 = _t1472 - _t1473 = self.parse_formula() - formula777 = _t1473 + _t1474 = self.parse_bindings() + bindings777 = _t1474 + _t1475 = self.parse_formula() + formula778 = _t1475 self.consume_literal(")") - _t1474 = logic_pb2.Abstraction(vars=(list(bindings776[0]) + list(bindings776[1] if bindings776[1] is not None else [])), value=formula777) - result779 = _t1474 - self.record_span(span_start778, "Abstraction") - return result779 + _t1476 = logic_pb2.Abstraction(vars=(list(bindings777[0]) + list(bindings777[1] if bindings777[1] is not None else [])), value=formula778) + result780 = _t1476 + self.record_span(span_start779, "Abstraction") + return result780 def parse_bindings(self) -> tuple[Sequence[logic_pb2.Binding], Sequence[logic_pb2.Binding]]: self.consume_literal("[") - xs780 = [] - cond781 = self.match_lookahead_terminal("SYMBOL", 0) - while cond781: - _t1475 = self.parse_binding() - item782 = _t1475 - xs780.append(item782) - cond781 = self.match_lookahead_terminal("SYMBOL", 0) - bindings783 = xs780 + xs781 = [] + cond782 = self.match_lookahead_terminal("SYMBOL", 0) + while cond782: + _t1477 = self.parse_binding() + item783 = _t1477 + xs781.append(item783) + cond782 = self.match_lookahead_terminal("SYMBOL", 0) + bindings784 = xs781 if self.match_lookahead_literal("|", 0): - _t1477 = self.parse_value_bindings() - _t1476 = _t1477 + _t1479 = self.parse_value_bindings() + _t1478 = _t1479 else: - _t1476 = None - value_bindings784 = _t1476 + _t1478 = None + value_bindings785 = _t1478 self.consume_literal("]") - return (bindings783, (value_bindings784 if value_bindings784 is not None else []),) + return (bindings784, (value_bindings785 if value_bindings785 is not None else []),) def parse_binding(self) -> logic_pb2.Binding: - span_start787 = self.span_start() - symbol785 = self.consume_terminal("SYMBOL") + span_start788 = self.span_start() + symbol786 = self.consume_terminal("SYMBOL") self.consume_literal("::") - _t1478 = self.parse_type() - type786 = _t1478 - _t1479 = logic_pb2.Var(name=symbol785) - _t1480 = logic_pb2.Binding(var=_t1479, type=type786) - result788 = _t1480 - self.record_span(span_start787, "Binding") - return result788 + _t1480 = self.parse_type() + type787 = _t1480 + _t1481 = logic_pb2.Var(name=symbol786) + _t1482 = logic_pb2.Binding(var=_t1481, type=type787) + result789 = _t1482 + self.record_span(span_start788, "Binding") + return result789 def parse_type(self) -> logic_pb2.Type: - span_start804 = self.span_start() + span_start805 = self.span_start() if self.match_lookahead_literal("UNKNOWN", 0): - _t1481 = 0 + _t1483 = 0 else: if self.match_lookahead_literal("UINT32", 0): - _t1482 = 13 + _t1484 = 13 else: if self.match_lookahead_literal("UINT128", 0): - _t1483 = 4 + _t1485 = 4 else: if self.match_lookahead_literal("STRING", 0): - _t1484 = 1 + _t1486 = 1 else: if self.match_lookahead_literal("MISSING", 0): - _t1485 = 8 + _t1487 = 8 else: if self.match_lookahead_literal("INT32", 0): - _t1486 = 11 + _t1488 = 11 else: if self.match_lookahead_literal("INT128", 0): - _t1487 = 5 + _t1489 = 5 else: if self.match_lookahead_literal("INT", 0): - _t1488 = 2 + _t1490 = 2 else: if self.match_lookahead_literal("FLOAT32", 0): - _t1489 = 12 + _t1491 = 12 else: if self.match_lookahead_literal("FLOAT", 0): - _t1490 = 3 + _t1492 = 3 else: if self.match_lookahead_literal("DATETIME", 0): - _t1491 = 7 + _t1493 = 7 else: if self.match_lookahead_literal("DATE", 0): - _t1492 = 6 + _t1494 = 6 else: if self.match_lookahead_literal("BOOLEAN", 0): - _t1493 = 10 + _t1495 = 10 else: if self.match_lookahead_literal("(", 0): - _t1494 = 9 + _t1496 = 9 else: - _t1494 = -1 - _t1493 = _t1494 - _t1492 = _t1493 - _t1491 = _t1492 - _t1490 = _t1491 - _t1489 = _t1490 - _t1488 = _t1489 - _t1487 = _t1488 - _t1486 = _t1487 - _t1485 = _t1486 - _t1484 = _t1485 - _t1483 = _t1484 - _t1482 = _t1483 - _t1481 = _t1482 - prediction789 = _t1481 - if prediction789 == 13: - _t1496 = self.parse_uint32_type() - uint32_type803 = _t1496 - _t1497 = logic_pb2.Type(uint32_type=uint32_type803) - _t1495 = _t1497 - else: - if prediction789 == 12: - _t1499 = self.parse_float32_type() - float32_type802 = _t1499 - _t1500 = logic_pb2.Type(float32_type=float32_type802) - _t1498 = _t1500 + _t1496 = -1 + _t1495 = _t1496 + _t1494 = _t1495 + _t1493 = _t1494 + _t1492 = _t1493 + _t1491 = _t1492 + _t1490 = _t1491 + _t1489 = _t1490 + _t1488 = _t1489 + _t1487 = _t1488 + _t1486 = _t1487 + _t1485 = _t1486 + _t1484 = _t1485 + _t1483 = _t1484 + prediction790 = _t1483 + if prediction790 == 13: + _t1498 = self.parse_uint32_type() + uint32_type804 = _t1498 + _t1499 = logic_pb2.Type(uint32_type=uint32_type804) + _t1497 = _t1499 + else: + if prediction790 == 12: + _t1501 = self.parse_float32_type() + float32_type803 = _t1501 + _t1502 = logic_pb2.Type(float32_type=float32_type803) + _t1500 = _t1502 else: - if prediction789 == 11: - _t1502 = self.parse_int32_type() - int32_type801 = _t1502 - _t1503 = logic_pb2.Type(int32_type=int32_type801) - _t1501 = _t1503 + if prediction790 == 11: + _t1504 = self.parse_int32_type() + int32_type802 = _t1504 + _t1505 = logic_pb2.Type(int32_type=int32_type802) + _t1503 = _t1505 else: - if prediction789 == 10: - _t1505 = self.parse_boolean_type() - boolean_type800 = _t1505 - _t1506 = logic_pb2.Type(boolean_type=boolean_type800) - _t1504 = _t1506 + if prediction790 == 10: + _t1507 = self.parse_boolean_type() + boolean_type801 = _t1507 + _t1508 = logic_pb2.Type(boolean_type=boolean_type801) + _t1506 = _t1508 else: - if prediction789 == 9: - _t1508 = self.parse_decimal_type() - decimal_type799 = _t1508 - _t1509 = logic_pb2.Type(decimal_type=decimal_type799) - _t1507 = _t1509 + if prediction790 == 9: + _t1510 = self.parse_decimal_type() + decimal_type800 = _t1510 + _t1511 = logic_pb2.Type(decimal_type=decimal_type800) + _t1509 = _t1511 else: - if prediction789 == 8: - _t1511 = self.parse_missing_type() - missing_type798 = _t1511 - _t1512 = logic_pb2.Type(missing_type=missing_type798) - _t1510 = _t1512 + if prediction790 == 8: + _t1513 = self.parse_missing_type() + missing_type799 = _t1513 + _t1514 = logic_pb2.Type(missing_type=missing_type799) + _t1512 = _t1514 else: - if prediction789 == 7: - _t1514 = self.parse_datetime_type() - datetime_type797 = _t1514 - _t1515 = logic_pb2.Type(datetime_type=datetime_type797) - _t1513 = _t1515 + if prediction790 == 7: + _t1516 = self.parse_datetime_type() + datetime_type798 = _t1516 + _t1517 = logic_pb2.Type(datetime_type=datetime_type798) + _t1515 = _t1517 else: - if prediction789 == 6: - _t1517 = self.parse_date_type() - date_type796 = _t1517 - _t1518 = logic_pb2.Type(date_type=date_type796) - _t1516 = _t1518 + if prediction790 == 6: + _t1519 = self.parse_date_type() + date_type797 = _t1519 + _t1520 = logic_pb2.Type(date_type=date_type797) + _t1518 = _t1520 else: - if prediction789 == 5: - _t1520 = self.parse_int128_type() - int128_type795 = _t1520 - _t1521 = logic_pb2.Type(int128_type=int128_type795) - _t1519 = _t1521 + if prediction790 == 5: + _t1522 = self.parse_int128_type() + int128_type796 = _t1522 + _t1523 = logic_pb2.Type(int128_type=int128_type796) + _t1521 = _t1523 else: - if prediction789 == 4: - _t1523 = self.parse_uint128_type() - uint128_type794 = _t1523 - _t1524 = logic_pb2.Type(uint128_type=uint128_type794) - _t1522 = _t1524 + if prediction790 == 4: + _t1525 = self.parse_uint128_type() + uint128_type795 = _t1525 + _t1526 = logic_pb2.Type(uint128_type=uint128_type795) + _t1524 = _t1526 else: - if prediction789 == 3: - _t1526 = self.parse_float_type() - float_type793 = _t1526 - _t1527 = logic_pb2.Type(float_type=float_type793) - _t1525 = _t1527 + if prediction790 == 3: + _t1528 = self.parse_float_type() + float_type794 = _t1528 + _t1529 = logic_pb2.Type(float_type=float_type794) + _t1527 = _t1529 else: - if prediction789 == 2: - _t1529 = self.parse_int_type() - int_type792 = _t1529 - _t1530 = logic_pb2.Type(int_type=int_type792) - _t1528 = _t1530 + if prediction790 == 2: + _t1531 = self.parse_int_type() + int_type793 = _t1531 + _t1532 = logic_pb2.Type(int_type=int_type793) + _t1530 = _t1532 else: - if prediction789 == 1: - _t1532 = self.parse_string_type() - string_type791 = _t1532 - _t1533 = logic_pb2.Type(string_type=string_type791) - _t1531 = _t1533 + if prediction790 == 1: + _t1534 = self.parse_string_type() + string_type792 = _t1534 + _t1535 = logic_pb2.Type(string_type=string_type792) + _t1533 = _t1535 else: - if prediction789 == 0: - _t1535 = self.parse_unspecified_type() - unspecified_type790 = _t1535 - _t1536 = logic_pb2.Type(unspecified_type=unspecified_type790) - _t1534 = _t1536 + if prediction790 == 0: + _t1537 = self.parse_unspecified_type() + unspecified_type791 = _t1537 + _t1538 = logic_pb2.Type(unspecified_type=unspecified_type791) + _t1536 = _t1538 else: raise ParseError("Unexpected token in type" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1531 = _t1534 - _t1528 = _t1531 - _t1525 = _t1528 - _t1522 = _t1525 - _t1519 = _t1522 - _t1516 = _t1519 - _t1513 = _t1516 - _t1510 = _t1513 - _t1507 = _t1510 - _t1504 = _t1507 - _t1501 = _t1504 - _t1498 = _t1501 - _t1495 = _t1498 - result805 = _t1495 - self.record_span(span_start804, "Type") - return result805 + _t1533 = _t1536 + _t1530 = _t1533 + _t1527 = _t1530 + _t1524 = _t1527 + _t1521 = _t1524 + _t1518 = _t1521 + _t1515 = _t1518 + _t1512 = _t1515 + _t1509 = _t1512 + _t1506 = _t1509 + _t1503 = _t1506 + _t1500 = _t1503 + _t1497 = _t1500 + result806 = _t1497 + self.record_span(span_start805, "Type") + return result806 def parse_unspecified_type(self) -> logic_pb2.UnspecifiedType: - span_start806 = self.span_start() + span_start807 = self.span_start() self.consume_literal("UNKNOWN") - _t1537 = logic_pb2.UnspecifiedType() - result807 = _t1537 - self.record_span(span_start806, "UnspecifiedType") - return result807 + _t1539 = logic_pb2.UnspecifiedType() + result808 = _t1539 + self.record_span(span_start807, "UnspecifiedType") + return result808 def parse_string_type(self) -> logic_pb2.StringType: - span_start808 = self.span_start() + span_start809 = self.span_start() self.consume_literal("STRING") - _t1538 = logic_pb2.StringType() - result809 = _t1538 - self.record_span(span_start808, "StringType") - return result809 + _t1540 = logic_pb2.StringType() + result810 = _t1540 + self.record_span(span_start809, "StringType") + return result810 def parse_int_type(self) -> logic_pb2.IntType: - span_start810 = self.span_start() + span_start811 = self.span_start() self.consume_literal("INT") - _t1539 = logic_pb2.IntType() - result811 = _t1539 - self.record_span(span_start810, "IntType") - return result811 + _t1541 = logic_pb2.IntType() + result812 = _t1541 + self.record_span(span_start811, "IntType") + return result812 def parse_float_type(self) -> logic_pb2.FloatType: - span_start812 = self.span_start() + span_start813 = self.span_start() self.consume_literal("FLOAT") - _t1540 = logic_pb2.FloatType() - result813 = _t1540 - self.record_span(span_start812, "FloatType") - return result813 + _t1542 = logic_pb2.FloatType() + result814 = _t1542 + self.record_span(span_start813, "FloatType") + return result814 def parse_uint128_type(self) -> logic_pb2.UInt128Type: - span_start814 = self.span_start() + span_start815 = self.span_start() self.consume_literal("UINT128") - _t1541 = logic_pb2.UInt128Type() - result815 = _t1541 - self.record_span(span_start814, "UInt128Type") - return result815 + _t1543 = logic_pb2.UInt128Type() + result816 = _t1543 + self.record_span(span_start815, "UInt128Type") + return result816 def parse_int128_type(self) -> logic_pb2.Int128Type: - span_start816 = self.span_start() + span_start817 = self.span_start() self.consume_literal("INT128") - _t1542 = logic_pb2.Int128Type() - result817 = _t1542 - self.record_span(span_start816, "Int128Type") - return result817 + _t1544 = logic_pb2.Int128Type() + result818 = _t1544 + self.record_span(span_start817, "Int128Type") + return result818 def parse_date_type(self) -> logic_pb2.DateType: - span_start818 = self.span_start() + span_start819 = self.span_start() self.consume_literal("DATE") - _t1543 = logic_pb2.DateType() - result819 = _t1543 - self.record_span(span_start818, "DateType") - return result819 + _t1545 = logic_pb2.DateType() + result820 = _t1545 + self.record_span(span_start819, "DateType") + return result820 def parse_datetime_type(self) -> logic_pb2.DateTimeType: - span_start820 = self.span_start() + span_start821 = self.span_start() self.consume_literal("DATETIME") - _t1544 = logic_pb2.DateTimeType() - result821 = _t1544 - self.record_span(span_start820, "DateTimeType") - return result821 + _t1546 = logic_pb2.DateTimeType() + result822 = _t1546 + self.record_span(span_start821, "DateTimeType") + return result822 def parse_missing_type(self) -> logic_pb2.MissingType: - span_start822 = self.span_start() + span_start823 = self.span_start() self.consume_literal("MISSING") - _t1545 = logic_pb2.MissingType() - result823 = _t1545 - self.record_span(span_start822, "MissingType") - return result823 + _t1547 = logic_pb2.MissingType() + result824 = _t1547 + self.record_span(span_start823, "MissingType") + return result824 def parse_decimal_type(self) -> logic_pb2.DecimalType: - span_start826 = self.span_start() + span_start827 = self.span_start() self.consume_literal("(") self.consume_literal("DECIMAL") - int824 = self.consume_terminal("INT") - int_3825 = self.consume_terminal("INT") + int825 = self.consume_terminal("INT") + int_3826 = self.consume_terminal("INT") self.consume_literal(")") - _t1546 = logic_pb2.DecimalType(precision=int(int824), scale=int(int_3825)) - result827 = _t1546 - self.record_span(span_start826, "DecimalType") - return result827 + _t1548 = logic_pb2.DecimalType(precision=int(int825), scale=int(int_3826)) + result828 = _t1548 + self.record_span(span_start827, "DecimalType") + return result828 def parse_boolean_type(self) -> logic_pb2.BooleanType: - span_start828 = self.span_start() + span_start829 = self.span_start() self.consume_literal("BOOLEAN") - _t1547 = logic_pb2.BooleanType() - result829 = _t1547 - self.record_span(span_start828, "BooleanType") - return result829 + _t1549 = logic_pb2.BooleanType() + result830 = _t1549 + self.record_span(span_start829, "BooleanType") + return result830 def parse_int32_type(self) -> logic_pb2.Int32Type: - span_start830 = self.span_start() + span_start831 = self.span_start() self.consume_literal("INT32") - _t1548 = logic_pb2.Int32Type() - result831 = _t1548 - self.record_span(span_start830, "Int32Type") - return result831 + _t1550 = logic_pb2.Int32Type() + result832 = _t1550 + self.record_span(span_start831, "Int32Type") + return result832 def parse_float32_type(self) -> logic_pb2.Float32Type: - span_start832 = self.span_start() + span_start833 = self.span_start() self.consume_literal("FLOAT32") - _t1549 = logic_pb2.Float32Type() - result833 = _t1549 - self.record_span(span_start832, "Float32Type") - return result833 + _t1551 = logic_pb2.Float32Type() + result834 = _t1551 + self.record_span(span_start833, "Float32Type") + return result834 def parse_uint32_type(self) -> logic_pb2.UInt32Type: - span_start834 = self.span_start() + span_start835 = self.span_start() self.consume_literal("UINT32") - _t1550 = logic_pb2.UInt32Type() - result835 = _t1550 - self.record_span(span_start834, "UInt32Type") - return result835 + _t1552 = logic_pb2.UInt32Type() + result836 = _t1552 + self.record_span(span_start835, "UInt32Type") + return result836 def parse_value_bindings(self) -> Sequence[logic_pb2.Binding]: self.consume_literal("|") - xs836 = [] - cond837 = self.match_lookahead_terminal("SYMBOL", 0) - while cond837: - _t1551 = self.parse_binding() - item838 = _t1551 - xs836.append(item838) - cond837 = self.match_lookahead_terminal("SYMBOL", 0) - bindings839 = xs836 - return bindings839 + xs837 = [] + cond838 = self.match_lookahead_terminal("SYMBOL", 0) + while cond838: + _t1553 = self.parse_binding() + item839 = _t1553 + xs837.append(item839) + cond838 = self.match_lookahead_terminal("SYMBOL", 0) + bindings840 = xs837 + return bindings840 def parse_formula(self) -> logic_pb2.Formula: - span_start854 = self.span_start() + span_start855 = self.span_start() if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("true", 1): - _t1553 = 0 + _t1555 = 0 else: if self.match_lookahead_literal("relatom", 1): - _t1554 = 11 + _t1556 = 11 else: if self.match_lookahead_literal("reduce", 1): - _t1555 = 3 + _t1557 = 3 else: if self.match_lookahead_literal("primitive", 1): - _t1556 = 10 + _t1558 = 10 else: if self.match_lookahead_literal("pragma", 1): - _t1557 = 9 + _t1559 = 9 else: if self.match_lookahead_literal("or", 1): - _t1558 = 5 + _t1560 = 5 else: if self.match_lookahead_literal("not", 1): - _t1559 = 6 + _t1561 = 6 else: if self.match_lookahead_literal("ffi", 1): - _t1560 = 7 + _t1562 = 7 else: if self.match_lookahead_literal("false", 1): - _t1561 = 1 + _t1563 = 1 else: if self.match_lookahead_literal("exists", 1): - _t1562 = 2 + _t1564 = 2 else: if self.match_lookahead_literal("cast", 1): - _t1563 = 12 + _t1565 = 12 else: if self.match_lookahead_literal("atom", 1): - _t1564 = 8 + _t1566 = 8 else: if self.match_lookahead_literal("and", 1): - _t1565 = 4 + _t1567 = 4 else: if self.match_lookahead_literal(">=", 1): - _t1566 = 10 + _t1568 = 10 else: if self.match_lookahead_literal(">", 1): - _t1567 = 10 + _t1569 = 10 else: if self.match_lookahead_literal("=", 1): - _t1568 = 10 + _t1570 = 10 else: if self.match_lookahead_literal("<=", 1): - _t1569 = 10 + _t1571 = 10 else: if self.match_lookahead_literal("<", 1): - _t1570 = 10 + _t1572 = 10 else: if self.match_lookahead_literal("/", 1): - _t1571 = 10 + _t1573 = 10 else: if self.match_lookahead_literal("-", 1): - _t1572 = 10 + _t1574 = 10 else: if self.match_lookahead_literal("+", 1): - _t1573 = 10 + _t1575 = 10 else: if self.match_lookahead_literal("*", 1): - _t1574 = 10 + _t1576 = 10 else: - _t1574 = -1 - _t1573 = _t1574 - _t1572 = _t1573 - _t1571 = _t1572 - _t1570 = _t1571 - _t1569 = _t1570 - _t1568 = _t1569 - _t1567 = _t1568 - _t1566 = _t1567 - _t1565 = _t1566 - _t1564 = _t1565 - _t1563 = _t1564 - _t1562 = _t1563 - _t1561 = _t1562 - _t1560 = _t1561 - _t1559 = _t1560 - _t1558 = _t1559 - _t1557 = _t1558 - _t1556 = _t1557 - _t1555 = _t1556 - _t1554 = _t1555 - _t1553 = _t1554 - _t1552 = _t1553 - else: - _t1552 = -1 - prediction840 = _t1552 - if prediction840 == 12: - _t1576 = self.parse_cast() - cast853 = _t1576 - _t1577 = logic_pb2.Formula(cast=cast853) - _t1575 = _t1577 - else: - if prediction840 == 11: - _t1579 = self.parse_rel_atom() - rel_atom852 = _t1579 - _t1580 = logic_pb2.Formula(rel_atom=rel_atom852) - _t1578 = _t1580 + _t1576 = -1 + _t1575 = _t1576 + _t1574 = _t1575 + _t1573 = _t1574 + _t1572 = _t1573 + _t1571 = _t1572 + _t1570 = _t1571 + _t1569 = _t1570 + _t1568 = _t1569 + _t1567 = _t1568 + _t1566 = _t1567 + _t1565 = _t1566 + _t1564 = _t1565 + _t1563 = _t1564 + _t1562 = _t1563 + _t1561 = _t1562 + _t1560 = _t1561 + _t1559 = _t1560 + _t1558 = _t1559 + _t1557 = _t1558 + _t1556 = _t1557 + _t1555 = _t1556 + _t1554 = _t1555 + else: + _t1554 = -1 + prediction841 = _t1554 + if prediction841 == 12: + _t1578 = self.parse_cast() + cast854 = _t1578 + _t1579 = logic_pb2.Formula(cast=cast854) + _t1577 = _t1579 + else: + if prediction841 == 11: + _t1581 = self.parse_rel_atom() + rel_atom853 = _t1581 + _t1582 = logic_pb2.Formula(rel_atom=rel_atom853) + _t1580 = _t1582 else: - if prediction840 == 10: - _t1582 = self.parse_primitive() - primitive851 = _t1582 - _t1583 = logic_pb2.Formula(primitive=primitive851) - _t1581 = _t1583 + if prediction841 == 10: + _t1584 = self.parse_primitive() + primitive852 = _t1584 + _t1585 = logic_pb2.Formula(primitive=primitive852) + _t1583 = _t1585 else: - if prediction840 == 9: - _t1585 = self.parse_pragma() - pragma850 = _t1585 - _t1586 = logic_pb2.Formula(pragma=pragma850) - _t1584 = _t1586 + if prediction841 == 9: + _t1587 = self.parse_pragma() + pragma851 = _t1587 + _t1588 = logic_pb2.Formula(pragma=pragma851) + _t1586 = _t1588 else: - if prediction840 == 8: - _t1588 = self.parse_atom() - atom849 = _t1588 - _t1589 = logic_pb2.Formula(atom=atom849) - _t1587 = _t1589 + if prediction841 == 8: + _t1590 = self.parse_atom() + atom850 = _t1590 + _t1591 = logic_pb2.Formula(atom=atom850) + _t1589 = _t1591 else: - if prediction840 == 7: - _t1591 = self.parse_ffi() - ffi848 = _t1591 - _t1592 = logic_pb2.Formula(ffi=ffi848) - _t1590 = _t1592 + if prediction841 == 7: + _t1593 = self.parse_ffi() + ffi849 = _t1593 + _t1594 = logic_pb2.Formula(ffi=ffi849) + _t1592 = _t1594 else: - if prediction840 == 6: - _t1594 = self.parse_not() - not847 = _t1594 - _t1595 = logic_pb2.Formula() - getattr(_t1595, 'not').CopyFrom(not847) - _t1593 = _t1595 + if prediction841 == 6: + _t1596 = self.parse_not() + not848 = _t1596 + _t1597 = logic_pb2.Formula() + getattr(_t1597, 'not').CopyFrom(not848) + _t1595 = _t1597 else: - if prediction840 == 5: - _t1597 = self.parse_disjunction() - disjunction846 = _t1597 - _t1598 = logic_pb2.Formula(disjunction=disjunction846) - _t1596 = _t1598 + if prediction841 == 5: + _t1599 = self.parse_disjunction() + disjunction847 = _t1599 + _t1600 = logic_pb2.Formula(disjunction=disjunction847) + _t1598 = _t1600 else: - if prediction840 == 4: - _t1600 = self.parse_conjunction() - conjunction845 = _t1600 - _t1601 = logic_pb2.Formula(conjunction=conjunction845) - _t1599 = _t1601 + if prediction841 == 4: + _t1602 = self.parse_conjunction() + conjunction846 = _t1602 + _t1603 = logic_pb2.Formula(conjunction=conjunction846) + _t1601 = _t1603 else: - if prediction840 == 3: - _t1603 = self.parse_reduce() - reduce844 = _t1603 - _t1604 = logic_pb2.Formula(reduce=reduce844) - _t1602 = _t1604 + if prediction841 == 3: + _t1605 = self.parse_reduce() + reduce845 = _t1605 + _t1606 = logic_pb2.Formula(reduce=reduce845) + _t1604 = _t1606 else: - if prediction840 == 2: - _t1606 = self.parse_exists() - exists843 = _t1606 - _t1607 = logic_pb2.Formula(exists=exists843) - _t1605 = _t1607 + if prediction841 == 2: + _t1608 = self.parse_exists() + exists844 = _t1608 + _t1609 = logic_pb2.Formula(exists=exists844) + _t1607 = _t1609 else: - if prediction840 == 1: - _t1609 = self.parse_false() - false842 = _t1609 - _t1610 = logic_pb2.Formula(disjunction=false842) - _t1608 = _t1610 + if prediction841 == 1: + _t1611 = self.parse_false() + false843 = _t1611 + _t1612 = logic_pb2.Formula(disjunction=false843) + _t1610 = _t1612 else: - if prediction840 == 0: - _t1612 = self.parse_true() - true841 = _t1612 - _t1613 = logic_pb2.Formula(conjunction=true841) - _t1611 = _t1613 + if prediction841 == 0: + _t1614 = self.parse_true() + true842 = _t1614 + _t1615 = logic_pb2.Formula(conjunction=true842) + _t1613 = _t1615 else: raise ParseError("Unexpected token in formula" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1608 = _t1611 - _t1605 = _t1608 - _t1602 = _t1605 - _t1599 = _t1602 - _t1596 = _t1599 - _t1593 = _t1596 - _t1590 = _t1593 - _t1587 = _t1590 - _t1584 = _t1587 - _t1581 = _t1584 - _t1578 = _t1581 - _t1575 = _t1578 - result855 = _t1575 - self.record_span(span_start854, "Formula") - return result855 + _t1610 = _t1613 + _t1607 = _t1610 + _t1604 = _t1607 + _t1601 = _t1604 + _t1598 = _t1601 + _t1595 = _t1598 + _t1592 = _t1595 + _t1589 = _t1592 + _t1586 = _t1589 + _t1583 = _t1586 + _t1580 = _t1583 + _t1577 = _t1580 + result856 = _t1577 + self.record_span(span_start855, "Formula") + return result856 def parse_true(self) -> logic_pb2.Conjunction: - span_start856 = self.span_start() + span_start857 = self.span_start() self.consume_literal("(") self.consume_literal("true") self.consume_literal(")") - _t1614 = logic_pb2.Conjunction(args=[]) - result857 = _t1614 - self.record_span(span_start856, "Conjunction") - return result857 + _t1616 = logic_pb2.Conjunction(args=[]) + result858 = _t1616 + self.record_span(span_start857, "Conjunction") + return result858 def parse_false(self) -> logic_pb2.Disjunction: - span_start858 = self.span_start() + span_start859 = self.span_start() self.consume_literal("(") self.consume_literal("false") self.consume_literal(")") - _t1615 = logic_pb2.Disjunction(args=[]) - result859 = _t1615 - self.record_span(span_start858, "Disjunction") - return result859 + _t1617 = logic_pb2.Disjunction(args=[]) + result860 = _t1617 + self.record_span(span_start859, "Disjunction") + return result860 def parse_exists(self) -> logic_pb2.Exists: - span_start862 = self.span_start() + span_start863 = self.span_start() self.consume_literal("(") self.consume_literal("exists") - _t1616 = self.parse_bindings() - bindings860 = _t1616 - _t1617 = self.parse_formula() - formula861 = _t1617 + _t1618 = self.parse_bindings() + bindings861 = _t1618 + _t1619 = self.parse_formula() + formula862 = _t1619 self.consume_literal(")") - _t1618 = logic_pb2.Abstraction(vars=(list(bindings860[0]) + list(bindings860[1] if bindings860[1] is not None else [])), value=formula861) - _t1619 = logic_pb2.Exists(body=_t1618) - result863 = _t1619 - self.record_span(span_start862, "Exists") - return result863 + _t1620 = logic_pb2.Abstraction(vars=(list(bindings861[0]) + list(bindings861[1] if bindings861[1] is not None else [])), value=formula862) + _t1621 = logic_pb2.Exists(body=_t1620) + result864 = _t1621 + self.record_span(span_start863, "Exists") + return result864 def parse_reduce(self) -> logic_pb2.Reduce: - span_start867 = self.span_start() + span_start868 = self.span_start() self.consume_literal("(") self.consume_literal("reduce") - _t1620 = self.parse_abstraction() - abstraction864 = _t1620 - _t1621 = self.parse_abstraction() - abstraction_3865 = _t1621 - _t1622 = self.parse_terms() - terms866 = _t1622 - self.consume_literal(")") - _t1623 = logic_pb2.Reduce(op=abstraction864, body=abstraction_3865, terms=terms866) - result868 = _t1623 - self.record_span(span_start867, "Reduce") - return result868 + _t1622 = self.parse_abstraction() + abstraction865 = _t1622 + _t1623 = self.parse_abstraction() + abstraction_3866 = _t1623 + _t1624 = self.parse_terms() + terms867 = _t1624 + self.consume_literal(")") + _t1625 = logic_pb2.Reduce(op=abstraction865, body=abstraction_3866, terms=terms867) + result869 = _t1625 + self.record_span(span_start868, "Reduce") + return result869 def parse_terms(self) -> Sequence[logic_pb2.Term]: self.consume_literal("(") self.consume_literal("terms") - xs869 = [] - cond870 = (((((((((((((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 cond870: - _t1624 = self.parse_term() - item871 = _t1624 - xs869.append(item871) - cond870 = (((((((((((((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)) - terms872 = xs869 + xs870 = [] + cond871 = (((((((((((((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 cond871: + _t1626 = self.parse_term() + item872 = _t1626 + xs870.append(item872) + cond871 = (((((((((((((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)) + terms873 = xs870 self.consume_literal(")") - return terms872 + return terms873 def parse_term(self) -> logic_pb2.Term: - span_start876 = self.span_start() + span_start877 = self.span_start() if self.match_lookahead_literal("true", 0): - _t1625 = 1 + _t1627 = 1 else: if self.match_lookahead_literal("missing", 0): - _t1626 = 1 + _t1628 = 1 else: if self.match_lookahead_literal("false", 0): - _t1627 = 1 + _t1629 = 1 else: if self.match_lookahead_literal("(", 0): - _t1628 = 1 + _t1630 = 1 else: if self.match_lookahead_terminal("SYMBOL", 0): - _t1629 = 0 + _t1631 = 0 else: if self.match_lookahead_terminal("UINT32", 0): - _t1630 = 1 + _t1632 = 1 else: if self.match_lookahead_terminal("UINT128", 0): - _t1631 = 1 + _t1633 = 1 else: if self.match_lookahead_terminal("STRING", 0): - _t1632 = 1 + _t1634 = 1 else: if self.match_lookahead_terminal("INT32", 0): - _t1633 = 1 + _t1635 = 1 else: if self.match_lookahead_terminal("INT128", 0): - _t1634 = 1 + _t1636 = 1 else: if self.match_lookahead_terminal("INT", 0): - _t1635 = 1 + _t1637 = 1 else: if self.match_lookahead_terminal("FLOAT32", 0): - _t1636 = 1 + _t1638 = 1 else: if self.match_lookahead_terminal("FLOAT", 0): - _t1637 = 1 + _t1639 = 1 else: if self.match_lookahead_terminal("DECIMAL", 0): - _t1638 = 1 + _t1640 = 1 else: - _t1638 = -1 - _t1637 = _t1638 - _t1636 = _t1637 - _t1635 = _t1636 - _t1634 = _t1635 - _t1633 = _t1634 - _t1632 = _t1633 - _t1631 = _t1632 - _t1630 = _t1631 - _t1629 = _t1630 - _t1628 = _t1629 - _t1627 = _t1628 - _t1626 = _t1627 - _t1625 = _t1626 - prediction873 = _t1625 - if prediction873 == 1: - _t1640 = self.parse_value() - value875 = _t1640 - _t1641 = logic_pb2.Term(constant=value875) - _t1639 = _t1641 - else: - if prediction873 == 0: - _t1643 = self.parse_var() - var874 = _t1643 - _t1644 = logic_pb2.Term(var=var874) - _t1642 = _t1644 + _t1640 = -1 + _t1639 = _t1640 + _t1638 = _t1639 + _t1637 = _t1638 + _t1636 = _t1637 + _t1635 = _t1636 + _t1634 = _t1635 + _t1633 = _t1634 + _t1632 = _t1633 + _t1631 = _t1632 + _t1630 = _t1631 + _t1629 = _t1630 + _t1628 = _t1629 + _t1627 = _t1628 + prediction874 = _t1627 + if prediction874 == 1: + _t1642 = self.parse_value() + value876 = _t1642 + _t1643 = logic_pb2.Term(constant=value876) + _t1641 = _t1643 + else: + if prediction874 == 0: + _t1645 = self.parse_var() + var875 = _t1645 + _t1646 = logic_pb2.Term(var=var875) + _t1644 = _t1646 else: raise ParseError("Unexpected token in term" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1639 = _t1642 - result877 = _t1639 - self.record_span(span_start876, "Term") - return result877 + _t1641 = _t1644 + result878 = _t1641 + self.record_span(span_start877, "Term") + return result878 def parse_var(self) -> logic_pb2.Var: - span_start879 = self.span_start() - symbol878 = self.consume_terminal("SYMBOL") - _t1645 = logic_pb2.Var(name=symbol878) - result880 = _t1645 - self.record_span(span_start879, "Var") - return result880 + span_start880 = self.span_start() + symbol879 = self.consume_terminal("SYMBOL") + _t1647 = logic_pb2.Var(name=symbol879) + result881 = _t1647 + self.record_span(span_start880, "Var") + return result881 def parse_value(self) -> logic_pb2.Value: - span_start894 = self.span_start() + span_start895 = self.span_start() if self.match_lookahead_literal("true", 0): - _t1646 = 12 + _t1648 = 12 else: if self.match_lookahead_literal("missing", 0): - _t1647 = 11 + _t1649 = 11 else: if self.match_lookahead_literal("false", 0): - _t1648 = 12 + _t1650 = 12 else: if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("datetime", 1): - _t1650 = 1 + _t1652 = 1 else: if self.match_lookahead_literal("date", 1): - _t1651 = 0 + _t1653 = 0 else: - _t1651 = -1 - _t1650 = _t1651 - _t1649 = _t1650 + _t1653 = -1 + _t1652 = _t1653 + _t1651 = _t1652 else: if self.match_lookahead_terminal("UINT32", 0): - _t1652 = 7 + _t1654 = 7 else: if self.match_lookahead_terminal("UINT128", 0): - _t1653 = 8 + _t1655 = 8 else: if self.match_lookahead_terminal("STRING", 0): - _t1654 = 2 + _t1656 = 2 else: if self.match_lookahead_terminal("INT32", 0): - _t1655 = 3 + _t1657 = 3 else: if self.match_lookahead_terminal("INT128", 0): - _t1656 = 9 + _t1658 = 9 else: if self.match_lookahead_terminal("INT", 0): - _t1657 = 4 + _t1659 = 4 else: if self.match_lookahead_terminal("FLOAT32", 0): - _t1658 = 5 + _t1660 = 5 else: if self.match_lookahead_terminal("FLOAT", 0): - _t1659 = 6 + _t1661 = 6 else: if self.match_lookahead_terminal("DECIMAL", 0): - _t1660 = 10 + _t1662 = 10 else: - _t1660 = -1 - _t1659 = _t1660 - _t1658 = _t1659 - _t1657 = _t1658 - _t1656 = _t1657 - _t1655 = _t1656 - _t1654 = _t1655 - _t1653 = _t1654 - _t1652 = _t1653 - _t1649 = _t1652 - _t1648 = _t1649 - _t1647 = _t1648 - _t1646 = _t1647 - prediction881 = _t1646 - if prediction881 == 12: - _t1662 = self.parse_boolean_value() - boolean_value893 = _t1662 - _t1663 = logic_pb2.Value(boolean_value=boolean_value893) - _t1661 = _t1663 - else: - if prediction881 == 11: + _t1662 = -1 + _t1661 = _t1662 + _t1660 = _t1661 + _t1659 = _t1660 + _t1658 = _t1659 + _t1657 = _t1658 + _t1656 = _t1657 + _t1655 = _t1656 + _t1654 = _t1655 + _t1651 = _t1654 + _t1650 = _t1651 + _t1649 = _t1650 + _t1648 = _t1649 + prediction882 = _t1648 + if prediction882 == 12: + _t1664 = self.parse_boolean_value() + boolean_value894 = _t1664 + _t1665 = logic_pb2.Value(boolean_value=boolean_value894) + _t1663 = _t1665 + else: + if prediction882 == 11: self.consume_literal("missing") - _t1665 = logic_pb2.MissingValue() - _t1666 = logic_pb2.Value(missing_value=_t1665) - _t1664 = _t1666 + _t1667 = logic_pb2.MissingValue() + _t1668 = logic_pb2.Value(missing_value=_t1667) + _t1666 = _t1668 else: - if prediction881 == 10: - formatted_decimal892 = self.consume_terminal("DECIMAL") - _t1668 = logic_pb2.Value(decimal_value=formatted_decimal892) - _t1667 = _t1668 + if prediction882 == 10: + formatted_decimal893 = self.consume_terminal("DECIMAL") + _t1670 = logic_pb2.Value(decimal_value=formatted_decimal893) + _t1669 = _t1670 else: - if prediction881 == 9: - formatted_int128891 = self.consume_terminal("INT128") - _t1670 = logic_pb2.Value(int128_value=formatted_int128891) - _t1669 = _t1670 + if prediction882 == 9: + formatted_int128892 = self.consume_terminal("INT128") + _t1672 = logic_pb2.Value(int128_value=formatted_int128892) + _t1671 = _t1672 else: - if prediction881 == 8: - formatted_uint128890 = self.consume_terminal("UINT128") - _t1672 = logic_pb2.Value(uint128_value=formatted_uint128890) - _t1671 = _t1672 + if prediction882 == 8: + formatted_uint128891 = self.consume_terminal("UINT128") + _t1674 = logic_pb2.Value(uint128_value=formatted_uint128891) + _t1673 = _t1674 else: - if prediction881 == 7: - formatted_uint32889 = self.consume_terminal("UINT32") - _t1674 = logic_pb2.Value(uint32_value=formatted_uint32889) - _t1673 = _t1674 + if prediction882 == 7: + formatted_uint32890 = self.consume_terminal("UINT32") + _t1676 = logic_pb2.Value(uint32_value=formatted_uint32890) + _t1675 = _t1676 else: - if prediction881 == 6: - formatted_float888 = self.consume_terminal("FLOAT") - _t1676 = logic_pb2.Value(float_value=formatted_float888) - _t1675 = _t1676 + if prediction882 == 6: + formatted_float889 = self.consume_terminal("FLOAT") + _t1678 = logic_pb2.Value(float_value=formatted_float889) + _t1677 = _t1678 else: - if prediction881 == 5: - formatted_float32887 = self.consume_terminal("FLOAT32") - _t1678 = logic_pb2.Value(float32_value=formatted_float32887) - _t1677 = _t1678 + if prediction882 == 5: + formatted_float32888 = self.consume_terminal("FLOAT32") + _t1680 = logic_pb2.Value(float32_value=formatted_float32888) + _t1679 = _t1680 else: - if prediction881 == 4: - formatted_int886 = self.consume_terminal("INT") - _t1680 = logic_pb2.Value(int_value=formatted_int886) - _t1679 = _t1680 + if prediction882 == 4: + formatted_int887 = self.consume_terminal("INT") + _t1682 = logic_pb2.Value(int_value=formatted_int887) + _t1681 = _t1682 else: - if prediction881 == 3: - formatted_int32885 = self.consume_terminal("INT32") - _t1682 = logic_pb2.Value(int32_value=formatted_int32885) - _t1681 = _t1682 + if prediction882 == 3: + formatted_int32886 = self.consume_terminal("INT32") + _t1684 = logic_pb2.Value(int32_value=formatted_int32886) + _t1683 = _t1684 else: - if prediction881 == 2: - formatted_string884 = self.consume_terminal("STRING") - _t1684 = logic_pb2.Value(string_value=formatted_string884) - _t1683 = _t1684 + if prediction882 == 2: + formatted_string885 = self.consume_terminal("STRING") + _t1686 = logic_pb2.Value(string_value=formatted_string885) + _t1685 = _t1686 else: - if prediction881 == 1: - _t1686 = self.parse_datetime() - datetime883 = _t1686 - _t1687 = logic_pb2.Value(datetime_value=datetime883) - _t1685 = _t1687 + if prediction882 == 1: + _t1688 = self.parse_datetime() + datetime884 = _t1688 + _t1689 = logic_pb2.Value(datetime_value=datetime884) + _t1687 = _t1689 else: - if prediction881 == 0: - _t1689 = self.parse_date() - date882 = _t1689 - _t1690 = logic_pb2.Value(date_value=date882) - _t1688 = _t1690 + if prediction882 == 0: + _t1691 = self.parse_date() + date883 = _t1691 + _t1692 = logic_pb2.Value(date_value=date883) + _t1690 = _t1692 else: raise ParseError("Unexpected token in value" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1685 = _t1688 - _t1683 = _t1685 - _t1681 = _t1683 - _t1679 = _t1681 - _t1677 = _t1679 - _t1675 = _t1677 - _t1673 = _t1675 - _t1671 = _t1673 - _t1669 = _t1671 - _t1667 = _t1669 - _t1664 = _t1667 - _t1661 = _t1664 - result895 = _t1661 - self.record_span(span_start894, "Value") - return result895 + _t1687 = _t1690 + _t1685 = _t1687 + _t1683 = _t1685 + _t1681 = _t1683 + _t1679 = _t1681 + _t1677 = _t1679 + _t1675 = _t1677 + _t1673 = _t1675 + _t1671 = _t1673 + _t1669 = _t1671 + _t1666 = _t1669 + _t1663 = _t1666 + result896 = _t1663 + self.record_span(span_start895, "Value") + return result896 def parse_date(self) -> logic_pb2.DateValue: - span_start899 = self.span_start() + span_start900 = self.span_start() self.consume_literal("(") self.consume_literal("date") - formatted_int896 = self.consume_terminal("INT") - formatted_int_3897 = self.consume_terminal("INT") - formatted_int_4898 = self.consume_terminal("INT") + formatted_int897 = self.consume_terminal("INT") + formatted_int_3898 = self.consume_terminal("INT") + formatted_int_4899 = self.consume_terminal("INT") self.consume_literal(")") - _t1691 = logic_pb2.DateValue(year=int(formatted_int896), month=int(formatted_int_3897), day=int(formatted_int_4898)) - result900 = _t1691 - self.record_span(span_start899, "DateValue") - return result900 + _t1693 = logic_pb2.DateValue(year=int(formatted_int897), month=int(formatted_int_3898), day=int(formatted_int_4899)) + result901 = _t1693 + self.record_span(span_start900, "DateValue") + return result901 def parse_datetime(self) -> logic_pb2.DateTimeValue: - span_start908 = self.span_start() + span_start909 = self.span_start() self.consume_literal("(") self.consume_literal("datetime") - formatted_int901 = self.consume_terminal("INT") - formatted_int_3902 = self.consume_terminal("INT") - formatted_int_4903 = self.consume_terminal("INT") - formatted_int_5904 = self.consume_terminal("INT") - formatted_int_6905 = self.consume_terminal("INT") - formatted_int_7906 = self.consume_terminal("INT") + formatted_int902 = self.consume_terminal("INT") + formatted_int_3903 = self.consume_terminal("INT") + formatted_int_4904 = self.consume_terminal("INT") + formatted_int_5905 = self.consume_terminal("INT") + formatted_int_6906 = self.consume_terminal("INT") + formatted_int_7907 = self.consume_terminal("INT") if self.match_lookahead_terminal("INT", 0): - _t1692 = self.consume_terminal("INT") + _t1694 = self.consume_terminal("INT") else: - _t1692 = None - formatted_int_8907 = _t1692 + _t1694 = None + formatted_int_8908 = _t1694 self.consume_literal(")") - _t1693 = logic_pb2.DateTimeValue(year=int(formatted_int901), month=int(formatted_int_3902), day=int(formatted_int_4903), hour=int(formatted_int_5904), minute=int(formatted_int_6905), second=int(formatted_int_7906), microsecond=int((formatted_int_8907 if formatted_int_8907 is not None else 0))) - result909 = _t1693 - self.record_span(span_start908, "DateTimeValue") - return result909 + _t1695 = logic_pb2.DateTimeValue(year=int(formatted_int902), month=int(formatted_int_3903), day=int(formatted_int_4904), hour=int(formatted_int_5905), minute=int(formatted_int_6906), second=int(formatted_int_7907), microsecond=int((formatted_int_8908 if formatted_int_8908 is not None else 0))) + result910 = _t1695 + self.record_span(span_start909, "DateTimeValue") + return result910 def parse_conjunction(self) -> logic_pb2.Conjunction: - span_start914 = self.span_start() + span_start915 = self.span_start() self.consume_literal("(") self.consume_literal("and") - xs910 = [] - cond911 = self.match_lookahead_literal("(", 0) - while cond911: - _t1694 = self.parse_formula() - item912 = _t1694 - xs910.append(item912) - cond911 = self.match_lookahead_literal("(", 0) - formulas913 = xs910 - self.consume_literal(")") - _t1695 = logic_pb2.Conjunction(args=formulas913) - result915 = _t1695 - self.record_span(span_start914, "Conjunction") - return result915 + xs911 = [] + cond912 = self.match_lookahead_literal("(", 0) + while cond912: + _t1696 = self.parse_formula() + item913 = _t1696 + xs911.append(item913) + cond912 = self.match_lookahead_literal("(", 0) + formulas914 = xs911 + self.consume_literal(")") + _t1697 = logic_pb2.Conjunction(args=formulas914) + result916 = _t1697 + self.record_span(span_start915, "Conjunction") + return result916 def parse_disjunction(self) -> logic_pb2.Disjunction: - span_start920 = self.span_start() + span_start921 = self.span_start() self.consume_literal("(") self.consume_literal("or") - xs916 = [] - cond917 = self.match_lookahead_literal("(", 0) - while cond917: - _t1696 = self.parse_formula() - item918 = _t1696 - xs916.append(item918) - cond917 = self.match_lookahead_literal("(", 0) - formulas919 = xs916 - self.consume_literal(")") - _t1697 = logic_pb2.Disjunction(args=formulas919) - result921 = _t1697 - self.record_span(span_start920, "Disjunction") - return result921 + xs917 = [] + cond918 = self.match_lookahead_literal("(", 0) + while cond918: + _t1698 = self.parse_formula() + item919 = _t1698 + xs917.append(item919) + cond918 = self.match_lookahead_literal("(", 0) + formulas920 = xs917 + self.consume_literal(")") + _t1699 = logic_pb2.Disjunction(args=formulas920) + result922 = _t1699 + self.record_span(span_start921, "Disjunction") + return result922 def parse_not(self) -> logic_pb2.Not: - span_start923 = self.span_start() + span_start924 = self.span_start() self.consume_literal("(") self.consume_literal("not") - _t1698 = self.parse_formula() - formula922 = _t1698 + _t1700 = self.parse_formula() + formula923 = _t1700 self.consume_literal(")") - _t1699 = logic_pb2.Not(arg=formula922) - result924 = _t1699 - self.record_span(span_start923, "Not") - return result924 + _t1701 = logic_pb2.Not(arg=formula923) + result925 = _t1701 + self.record_span(span_start924, "Not") + return result925 def parse_ffi(self) -> logic_pb2.FFI: - span_start928 = self.span_start() + span_start929 = self.span_start() self.consume_literal("(") self.consume_literal("ffi") - _t1700 = self.parse_name() - name925 = _t1700 - _t1701 = self.parse_ffi_args() - ffi_args926 = _t1701 - _t1702 = self.parse_terms() - terms927 = _t1702 - self.consume_literal(")") - _t1703 = logic_pb2.FFI(name=name925, args=ffi_args926, terms=terms927) - result929 = _t1703 - self.record_span(span_start928, "FFI") - return result929 + _t1702 = self.parse_name() + name926 = _t1702 + _t1703 = self.parse_ffi_args() + ffi_args927 = _t1703 + _t1704 = self.parse_terms() + terms928 = _t1704 + self.consume_literal(")") + _t1705 = logic_pb2.FFI(name=name926, args=ffi_args927, terms=terms928) + result930 = _t1705 + self.record_span(span_start929, "FFI") + return result930 def parse_name(self) -> str: self.consume_literal(":") - symbol930 = self.consume_terminal("SYMBOL") - return symbol930 + symbol931 = self.consume_terminal("SYMBOL") + return symbol931 def parse_ffi_args(self) -> Sequence[logic_pb2.Abstraction]: self.consume_literal("(") self.consume_literal("args") - xs931 = [] - cond932 = self.match_lookahead_literal("(", 0) - while cond932: - _t1704 = self.parse_abstraction() - item933 = _t1704 - xs931.append(item933) - cond932 = self.match_lookahead_literal("(", 0) - abstractions934 = xs931 + xs932 = [] + cond933 = self.match_lookahead_literal("(", 0) + while cond933: + _t1706 = self.parse_abstraction() + item934 = _t1706 + xs932.append(item934) + cond933 = self.match_lookahead_literal("(", 0) + abstractions935 = xs932 self.consume_literal(")") - return abstractions934 + return abstractions935 def parse_atom(self) -> logic_pb2.Atom: - span_start940 = self.span_start() + span_start941 = self.span_start() self.consume_literal("(") self.consume_literal("atom") - _t1705 = self.parse_relation_id() - relation_id935 = _t1705 - xs936 = [] - cond937 = (((((((((((((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 cond937: - _t1706 = self.parse_term() - item938 = _t1706 - xs936.append(item938) - cond937 = (((((((((((((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)) - terms939 = xs936 - self.consume_literal(")") - _t1707 = logic_pb2.Atom(name=relation_id935, terms=terms939) - result941 = _t1707 - self.record_span(span_start940, "Atom") - return result941 + _t1707 = self.parse_relation_id() + relation_id936 = _t1707 + xs937 = [] + cond938 = (((((((((((((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 cond938: + _t1708 = self.parse_term() + item939 = _t1708 + xs937.append(item939) + cond938 = (((((((((((((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)) + terms940 = xs937 + self.consume_literal(")") + _t1709 = logic_pb2.Atom(name=relation_id936, terms=terms940) + result942 = _t1709 + self.record_span(span_start941, "Atom") + return result942 def parse_pragma(self) -> logic_pb2.Pragma: - span_start947 = self.span_start() + span_start948 = self.span_start() self.consume_literal("(") self.consume_literal("pragma") - _t1708 = self.parse_name() - name942 = _t1708 - xs943 = [] - cond944 = (((((((((((((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 cond944: - _t1709 = self.parse_term() - item945 = _t1709 - xs943.append(item945) - cond944 = (((((((((((((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)) - terms946 = xs943 - self.consume_literal(")") - _t1710 = logic_pb2.Pragma(name=name942, terms=terms946) - result948 = _t1710 - self.record_span(span_start947, "Pragma") - return result948 + _t1710 = self.parse_name() + name943 = _t1710 + xs944 = [] + cond945 = (((((((((((((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 cond945: + _t1711 = self.parse_term() + item946 = _t1711 + xs944.append(item946) + cond945 = (((((((((((((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)) + terms947 = xs944 + self.consume_literal(")") + _t1712 = logic_pb2.Pragma(name=name943, terms=terms947) + result949 = _t1712 + self.record_span(span_start948, "Pragma") + return result949 def parse_primitive(self) -> logic_pb2.Primitive: - span_start964 = self.span_start() + span_start965 = self.span_start() if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("primitive", 1): - _t1712 = 9 + _t1714 = 9 else: if self.match_lookahead_literal(">=", 1): - _t1713 = 4 + _t1715 = 4 else: if self.match_lookahead_literal(">", 1): - _t1714 = 3 + _t1716 = 3 else: if self.match_lookahead_literal("=", 1): - _t1715 = 0 + _t1717 = 0 else: if self.match_lookahead_literal("<=", 1): - _t1716 = 2 + _t1718 = 2 else: if self.match_lookahead_literal("<", 1): - _t1717 = 1 + _t1719 = 1 else: if self.match_lookahead_literal("/", 1): - _t1718 = 8 + _t1720 = 8 else: if self.match_lookahead_literal("-", 1): - _t1719 = 6 + _t1721 = 6 else: if self.match_lookahead_literal("+", 1): - _t1720 = 5 + _t1722 = 5 else: if self.match_lookahead_literal("*", 1): - _t1721 = 7 + _t1723 = 7 else: - _t1721 = -1 - _t1720 = _t1721 - _t1719 = _t1720 - _t1718 = _t1719 - _t1717 = _t1718 - _t1716 = _t1717 - _t1715 = _t1716 - _t1714 = _t1715 - _t1713 = _t1714 - _t1712 = _t1713 - _t1711 = _t1712 - else: - _t1711 = -1 - prediction949 = _t1711 - if prediction949 == 9: + _t1723 = -1 + _t1722 = _t1723 + _t1721 = _t1722 + _t1720 = _t1721 + _t1719 = _t1720 + _t1718 = _t1719 + _t1717 = _t1718 + _t1716 = _t1717 + _t1715 = _t1716 + _t1714 = _t1715 + _t1713 = _t1714 + else: + _t1713 = -1 + prediction950 = _t1713 + if prediction950 == 9: self.consume_literal("(") self.consume_literal("primitive") - _t1723 = self.parse_name() - name959 = _t1723 - xs960 = [] - cond961 = ((((((((((((((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 cond961: - _t1724 = self.parse_rel_term() - item962 = _t1724 - xs960.append(item962) - cond961 = ((((((((((((((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_terms963 = xs960 + _t1725 = self.parse_name() + name960 = _t1725 + xs961 = [] + cond962 = ((((((((((((((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 cond962: + _t1726 = self.parse_rel_term() + item963 = _t1726 + xs961.append(item963) + cond962 = ((((((((((((((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_terms964 = xs961 self.consume_literal(")") - _t1725 = logic_pb2.Primitive(name=name959, terms=rel_terms963) - _t1722 = _t1725 + _t1727 = logic_pb2.Primitive(name=name960, terms=rel_terms964) + _t1724 = _t1727 else: - if prediction949 == 8: - _t1727 = self.parse_divide() - divide958 = _t1727 - _t1726 = divide958 + if prediction950 == 8: + _t1729 = self.parse_divide() + divide959 = _t1729 + _t1728 = divide959 else: - if prediction949 == 7: - _t1729 = self.parse_multiply() - multiply957 = _t1729 - _t1728 = multiply957 + if prediction950 == 7: + _t1731 = self.parse_multiply() + multiply958 = _t1731 + _t1730 = multiply958 else: - if prediction949 == 6: - _t1731 = self.parse_minus() - minus956 = _t1731 - _t1730 = minus956 + if prediction950 == 6: + _t1733 = self.parse_minus() + minus957 = _t1733 + _t1732 = minus957 else: - if prediction949 == 5: - _t1733 = self.parse_add() - add955 = _t1733 - _t1732 = add955 + if prediction950 == 5: + _t1735 = self.parse_add() + add956 = _t1735 + _t1734 = add956 else: - if prediction949 == 4: - _t1735 = self.parse_gt_eq() - gt_eq954 = _t1735 - _t1734 = gt_eq954 + if prediction950 == 4: + _t1737 = self.parse_gt_eq() + gt_eq955 = _t1737 + _t1736 = gt_eq955 else: - if prediction949 == 3: - _t1737 = self.parse_gt() - gt953 = _t1737 - _t1736 = gt953 + if prediction950 == 3: + _t1739 = self.parse_gt() + gt954 = _t1739 + _t1738 = gt954 else: - if prediction949 == 2: - _t1739 = self.parse_lt_eq() - lt_eq952 = _t1739 - _t1738 = lt_eq952 + if prediction950 == 2: + _t1741 = self.parse_lt_eq() + lt_eq953 = _t1741 + _t1740 = lt_eq953 else: - if prediction949 == 1: - _t1741 = self.parse_lt() - lt951 = _t1741 - _t1740 = lt951 + if prediction950 == 1: + _t1743 = self.parse_lt() + lt952 = _t1743 + _t1742 = lt952 else: - if prediction949 == 0: - _t1743 = self.parse_eq() - eq950 = _t1743 - _t1742 = eq950 + if prediction950 == 0: + _t1745 = self.parse_eq() + eq951 = _t1745 + _t1744 = eq951 else: raise ParseError("Unexpected token in primitive" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1740 = _t1742 - _t1738 = _t1740 - _t1736 = _t1738 - _t1734 = _t1736 - _t1732 = _t1734 - _t1730 = _t1732 - _t1728 = _t1730 - _t1726 = _t1728 - _t1722 = _t1726 - result965 = _t1722 - self.record_span(span_start964, "Primitive") - return result965 + _t1742 = _t1744 + _t1740 = _t1742 + _t1738 = _t1740 + _t1736 = _t1738 + _t1734 = _t1736 + _t1732 = _t1734 + _t1730 = _t1732 + _t1728 = _t1730 + _t1724 = _t1728 + result966 = _t1724 + self.record_span(span_start965, "Primitive") + return result966 def parse_eq(self) -> logic_pb2.Primitive: - span_start968 = self.span_start() + span_start969 = self.span_start() self.consume_literal("(") self.consume_literal("=") - _t1744 = self.parse_term() - term966 = _t1744 - _t1745 = self.parse_term() - term_3967 = _t1745 - self.consume_literal(")") - _t1746 = logic_pb2.RelTerm(term=term966) - _t1747 = logic_pb2.RelTerm(term=term_3967) - _t1748 = logic_pb2.Primitive(name="rel_primitive_eq", terms=[_t1746, _t1747]) - result969 = _t1748 - self.record_span(span_start968, "Primitive") - return result969 + _t1746 = self.parse_term() + term967 = _t1746 + _t1747 = self.parse_term() + term_3968 = _t1747 + self.consume_literal(")") + _t1748 = logic_pb2.RelTerm(term=term967) + _t1749 = logic_pb2.RelTerm(term=term_3968) + _t1750 = logic_pb2.Primitive(name="rel_primitive_eq", terms=[_t1748, _t1749]) + result970 = _t1750 + self.record_span(span_start969, "Primitive") + return result970 def parse_lt(self) -> logic_pb2.Primitive: - span_start972 = self.span_start() + span_start973 = self.span_start() self.consume_literal("(") self.consume_literal("<") - _t1749 = self.parse_term() - term970 = _t1749 - _t1750 = self.parse_term() - term_3971 = _t1750 - self.consume_literal(")") - _t1751 = logic_pb2.RelTerm(term=term970) - _t1752 = logic_pb2.RelTerm(term=term_3971) - _t1753 = logic_pb2.Primitive(name="rel_primitive_lt_monotype", terms=[_t1751, _t1752]) - result973 = _t1753 - self.record_span(span_start972, "Primitive") - return result973 + _t1751 = self.parse_term() + term971 = _t1751 + _t1752 = self.parse_term() + term_3972 = _t1752 + self.consume_literal(")") + _t1753 = logic_pb2.RelTerm(term=term971) + _t1754 = logic_pb2.RelTerm(term=term_3972) + _t1755 = logic_pb2.Primitive(name="rel_primitive_lt_monotype", terms=[_t1753, _t1754]) + result974 = _t1755 + self.record_span(span_start973, "Primitive") + return result974 def parse_lt_eq(self) -> logic_pb2.Primitive: - span_start976 = self.span_start() + span_start977 = self.span_start() self.consume_literal("(") self.consume_literal("<=") - _t1754 = self.parse_term() - term974 = _t1754 - _t1755 = self.parse_term() - term_3975 = _t1755 - self.consume_literal(")") - _t1756 = logic_pb2.RelTerm(term=term974) - _t1757 = logic_pb2.RelTerm(term=term_3975) - _t1758 = logic_pb2.Primitive(name="rel_primitive_lt_eq_monotype", terms=[_t1756, _t1757]) - result977 = _t1758 - self.record_span(span_start976, "Primitive") - return result977 + _t1756 = self.parse_term() + term975 = _t1756 + _t1757 = self.parse_term() + term_3976 = _t1757 + self.consume_literal(")") + _t1758 = logic_pb2.RelTerm(term=term975) + _t1759 = logic_pb2.RelTerm(term=term_3976) + _t1760 = logic_pb2.Primitive(name="rel_primitive_lt_eq_monotype", terms=[_t1758, _t1759]) + result978 = _t1760 + self.record_span(span_start977, "Primitive") + return result978 def parse_gt(self) -> logic_pb2.Primitive: - span_start980 = self.span_start() + span_start981 = self.span_start() self.consume_literal("(") self.consume_literal(">") - _t1759 = self.parse_term() - term978 = _t1759 - _t1760 = self.parse_term() - term_3979 = _t1760 - self.consume_literal(")") - _t1761 = logic_pb2.RelTerm(term=term978) - _t1762 = logic_pb2.RelTerm(term=term_3979) - _t1763 = logic_pb2.Primitive(name="rel_primitive_gt_monotype", terms=[_t1761, _t1762]) - result981 = _t1763 - self.record_span(span_start980, "Primitive") - return result981 + _t1761 = self.parse_term() + term979 = _t1761 + _t1762 = self.parse_term() + term_3980 = _t1762 + self.consume_literal(")") + _t1763 = logic_pb2.RelTerm(term=term979) + _t1764 = logic_pb2.RelTerm(term=term_3980) + _t1765 = logic_pb2.Primitive(name="rel_primitive_gt_monotype", terms=[_t1763, _t1764]) + result982 = _t1765 + self.record_span(span_start981, "Primitive") + return result982 def parse_gt_eq(self) -> logic_pb2.Primitive: - span_start984 = self.span_start() + span_start985 = self.span_start() self.consume_literal("(") self.consume_literal(">=") - _t1764 = self.parse_term() - term982 = _t1764 - _t1765 = self.parse_term() - term_3983 = _t1765 - self.consume_literal(")") - _t1766 = logic_pb2.RelTerm(term=term982) - _t1767 = logic_pb2.RelTerm(term=term_3983) - _t1768 = logic_pb2.Primitive(name="rel_primitive_gt_eq_monotype", terms=[_t1766, _t1767]) - result985 = _t1768 - self.record_span(span_start984, "Primitive") - return result985 + _t1766 = self.parse_term() + term983 = _t1766 + _t1767 = self.parse_term() + term_3984 = _t1767 + self.consume_literal(")") + _t1768 = logic_pb2.RelTerm(term=term983) + _t1769 = logic_pb2.RelTerm(term=term_3984) + _t1770 = logic_pb2.Primitive(name="rel_primitive_gt_eq_monotype", terms=[_t1768, _t1769]) + result986 = _t1770 + self.record_span(span_start985, "Primitive") + return result986 def parse_add(self) -> logic_pb2.Primitive: - span_start989 = self.span_start() + span_start990 = self.span_start() self.consume_literal("(") self.consume_literal("+") - _t1769 = self.parse_term() - term986 = _t1769 - _t1770 = self.parse_term() - term_3987 = _t1770 _t1771 = self.parse_term() - term_4988 = _t1771 - self.consume_literal(")") - _t1772 = logic_pb2.RelTerm(term=term986) - _t1773 = logic_pb2.RelTerm(term=term_3987) - _t1774 = logic_pb2.RelTerm(term=term_4988) - _t1775 = logic_pb2.Primitive(name="rel_primitive_add_monotype", terms=[_t1772, _t1773, _t1774]) - result990 = _t1775 - self.record_span(span_start989, "Primitive") - return result990 + term987 = _t1771 + _t1772 = self.parse_term() + term_3988 = _t1772 + _t1773 = self.parse_term() + term_4989 = _t1773 + self.consume_literal(")") + _t1774 = logic_pb2.RelTerm(term=term987) + _t1775 = logic_pb2.RelTerm(term=term_3988) + _t1776 = logic_pb2.RelTerm(term=term_4989) + _t1777 = logic_pb2.Primitive(name="rel_primitive_add_monotype", terms=[_t1774, _t1775, _t1776]) + result991 = _t1777 + self.record_span(span_start990, "Primitive") + return result991 def parse_minus(self) -> logic_pb2.Primitive: - span_start994 = self.span_start() + span_start995 = self.span_start() self.consume_literal("(") self.consume_literal("-") - _t1776 = self.parse_term() - term991 = _t1776 - _t1777 = self.parse_term() - term_3992 = _t1777 _t1778 = self.parse_term() - term_4993 = _t1778 - self.consume_literal(")") - _t1779 = logic_pb2.RelTerm(term=term991) - _t1780 = logic_pb2.RelTerm(term=term_3992) - _t1781 = logic_pb2.RelTerm(term=term_4993) - _t1782 = logic_pb2.Primitive(name="rel_primitive_subtract_monotype", terms=[_t1779, _t1780, _t1781]) - result995 = _t1782 - self.record_span(span_start994, "Primitive") - return result995 + term992 = _t1778 + _t1779 = self.parse_term() + term_3993 = _t1779 + _t1780 = self.parse_term() + term_4994 = _t1780 + self.consume_literal(")") + _t1781 = logic_pb2.RelTerm(term=term992) + _t1782 = logic_pb2.RelTerm(term=term_3993) + _t1783 = logic_pb2.RelTerm(term=term_4994) + _t1784 = logic_pb2.Primitive(name="rel_primitive_subtract_monotype", terms=[_t1781, _t1782, _t1783]) + result996 = _t1784 + self.record_span(span_start995, "Primitive") + return result996 def parse_multiply(self) -> logic_pb2.Primitive: - span_start999 = self.span_start() + span_start1000 = self.span_start() self.consume_literal("(") self.consume_literal("*") - _t1783 = self.parse_term() - term996 = _t1783 - _t1784 = self.parse_term() - term_3997 = _t1784 _t1785 = self.parse_term() - term_4998 = _t1785 - self.consume_literal(")") - _t1786 = logic_pb2.RelTerm(term=term996) - _t1787 = logic_pb2.RelTerm(term=term_3997) - _t1788 = logic_pb2.RelTerm(term=term_4998) - _t1789 = logic_pb2.Primitive(name="rel_primitive_multiply_monotype", terms=[_t1786, _t1787, _t1788]) - result1000 = _t1789 - self.record_span(span_start999, "Primitive") - return result1000 + term997 = _t1785 + _t1786 = self.parse_term() + term_3998 = _t1786 + _t1787 = self.parse_term() + term_4999 = _t1787 + self.consume_literal(")") + _t1788 = logic_pb2.RelTerm(term=term997) + _t1789 = logic_pb2.RelTerm(term=term_3998) + _t1790 = logic_pb2.RelTerm(term=term_4999) + _t1791 = logic_pb2.Primitive(name="rel_primitive_multiply_monotype", terms=[_t1788, _t1789, _t1790]) + result1001 = _t1791 + self.record_span(span_start1000, "Primitive") + return result1001 def parse_divide(self) -> logic_pb2.Primitive: - span_start1004 = self.span_start() + span_start1005 = self.span_start() self.consume_literal("(") self.consume_literal("/") - _t1790 = self.parse_term() - term1001 = _t1790 - _t1791 = self.parse_term() - term_31002 = _t1791 _t1792 = self.parse_term() - term_41003 = _t1792 - self.consume_literal(")") - _t1793 = logic_pb2.RelTerm(term=term1001) - _t1794 = logic_pb2.RelTerm(term=term_31002) - _t1795 = logic_pb2.RelTerm(term=term_41003) - _t1796 = logic_pb2.Primitive(name="rel_primitive_divide_monotype", terms=[_t1793, _t1794, _t1795]) - result1005 = _t1796 - self.record_span(span_start1004, "Primitive") - return result1005 + term1002 = _t1792 + _t1793 = self.parse_term() + term_31003 = _t1793 + _t1794 = self.parse_term() + term_41004 = _t1794 + self.consume_literal(")") + _t1795 = logic_pb2.RelTerm(term=term1002) + _t1796 = logic_pb2.RelTerm(term=term_31003) + _t1797 = logic_pb2.RelTerm(term=term_41004) + _t1798 = logic_pb2.Primitive(name="rel_primitive_divide_monotype", terms=[_t1795, _t1796, _t1797]) + result1006 = _t1798 + self.record_span(span_start1005, "Primitive") + return result1006 def parse_rel_term(self) -> logic_pb2.RelTerm: - span_start1009 = self.span_start() + span_start1010 = self.span_start() if self.match_lookahead_literal("true", 0): - _t1797 = 1 + _t1799 = 1 else: if self.match_lookahead_literal("missing", 0): - _t1798 = 1 + _t1800 = 1 else: if self.match_lookahead_literal("false", 0): - _t1799 = 1 + _t1801 = 1 else: if self.match_lookahead_literal("(", 0): - _t1800 = 1 + _t1802 = 1 else: if self.match_lookahead_literal("#", 0): - _t1801 = 0 + _t1803 = 0 else: if self.match_lookahead_terminal("SYMBOL", 0): - _t1802 = 1 + _t1804 = 1 else: if self.match_lookahead_terminal("UINT32", 0): - _t1803 = 1 + _t1805 = 1 else: if self.match_lookahead_terminal("UINT128", 0): - _t1804 = 1 + _t1806 = 1 else: if self.match_lookahead_terminal("STRING", 0): - _t1805 = 1 + _t1807 = 1 else: if self.match_lookahead_terminal("INT32", 0): - _t1806 = 1 + _t1808 = 1 else: if self.match_lookahead_terminal("INT128", 0): - _t1807 = 1 + _t1809 = 1 else: if self.match_lookahead_terminal("INT", 0): - _t1808 = 1 + _t1810 = 1 else: if self.match_lookahead_terminal("FLOAT32", 0): - _t1809 = 1 + _t1811 = 1 else: if self.match_lookahead_terminal("FLOAT", 0): - _t1810 = 1 + _t1812 = 1 else: if self.match_lookahead_terminal("DECIMAL", 0): - _t1811 = 1 + _t1813 = 1 else: - _t1811 = -1 - _t1810 = _t1811 - _t1809 = _t1810 - _t1808 = _t1809 - _t1807 = _t1808 - _t1806 = _t1807 - _t1805 = _t1806 - _t1804 = _t1805 - _t1803 = _t1804 - _t1802 = _t1803 - _t1801 = _t1802 - _t1800 = _t1801 - _t1799 = _t1800 - _t1798 = _t1799 - _t1797 = _t1798 - prediction1006 = _t1797 - if prediction1006 == 1: - _t1813 = self.parse_term() - term1008 = _t1813 - _t1814 = logic_pb2.RelTerm(term=term1008) - _t1812 = _t1814 - else: - if prediction1006 == 0: - _t1816 = self.parse_specialized_value() - specialized_value1007 = _t1816 - _t1817 = logic_pb2.RelTerm(specialized_value=specialized_value1007) - _t1815 = _t1817 + _t1813 = -1 + _t1812 = _t1813 + _t1811 = _t1812 + _t1810 = _t1811 + _t1809 = _t1810 + _t1808 = _t1809 + _t1807 = _t1808 + _t1806 = _t1807 + _t1805 = _t1806 + _t1804 = _t1805 + _t1803 = _t1804 + _t1802 = _t1803 + _t1801 = _t1802 + _t1800 = _t1801 + _t1799 = _t1800 + prediction1007 = _t1799 + if prediction1007 == 1: + _t1815 = self.parse_term() + term1009 = _t1815 + _t1816 = logic_pb2.RelTerm(term=term1009) + _t1814 = _t1816 + else: + if prediction1007 == 0: + _t1818 = self.parse_specialized_value() + specialized_value1008 = _t1818 + _t1819 = logic_pb2.RelTerm(specialized_value=specialized_value1008) + _t1817 = _t1819 else: raise ParseError("Unexpected token in rel_term" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1812 = _t1815 - result1010 = _t1812 - self.record_span(span_start1009, "RelTerm") - return result1010 + _t1814 = _t1817 + result1011 = _t1814 + self.record_span(span_start1010, "RelTerm") + return result1011 def parse_specialized_value(self) -> logic_pb2.Value: - span_start1012 = self.span_start() + span_start1013 = self.span_start() self.consume_literal("#") - _t1818 = self.parse_raw_value() - raw_value1011 = _t1818 - result1013 = raw_value1011 - self.record_span(span_start1012, "Value") - return result1013 + _t1820 = self.parse_raw_value() + raw_value1012 = _t1820 + result1014 = raw_value1012 + self.record_span(span_start1013, "Value") + return result1014 def parse_rel_atom(self) -> logic_pb2.RelAtom: - span_start1019 = self.span_start() + span_start1020 = self.span_start() self.consume_literal("(") self.consume_literal("relatom") - _t1819 = self.parse_name() - name1014 = _t1819 - xs1015 = [] - cond1016 = ((((((((((((((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 cond1016: - _t1820 = self.parse_rel_term() - item1017 = _t1820 - xs1015.append(item1017) - cond1016 = ((((((((((((((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_terms1018 = xs1015 - self.consume_literal(")") - _t1821 = logic_pb2.RelAtom(name=name1014, terms=rel_terms1018) - result1020 = _t1821 - self.record_span(span_start1019, "RelAtom") - return result1020 + _t1821 = self.parse_name() + name1015 = _t1821 + xs1016 = [] + cond1017 = ((((((((((((((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 cond1017: + _t1822 = self.parse_rel_term() + item1018 = _t1822 + xs1016.append(item1018) + cond1017 = ((((((((((((((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_terms1019 = xs1016 + self.consume_literal(")") + _t1823 = logic_pb2.RelAtom(name=name1015, terms=rel_terms1019) + result1021 = _t1823 + self.record_span(span_start1020, "RelAtom") + return result1021 def parse_cast(self) -> logic_pb2.Cast: - span_start1023 = self.span_start() + span_start1024 = self.span_start() self.consume_literal("(") self.consume_literal("cast") - _t1822 = self.parse_term() - term1021 = _t1822 - _t1823 = self.parse_term() - term_31022 = _t1823 + _t1824 = self.parse_term() + term1022 = _t1824 + _t1825 = self.parse_term() + term_31023 = _t1825 self.consume_literal(")") - _t1824 = logic_pb2.Cast(input=term1021, result=term_31022) - result1024 = _t1824 - self.record_span(span_start1023, "Cast") - return result1024 + _t1826 = logic_pb2.Cast(input=term1022, result=term_31023) + result1025 = _t1826 + self.record_span(span_start1024, "Cast") + return result1025 def parse_attrs(self) -> Sequence[logic_pb2.Attribute]: self.consume_literal("(") self.consume_literal("attrs") - xs1025 = [] - cond1026 = self.match_lookahead_literal("(", 0) - while cond1026: - _t1825 = self.parse_attribute() - item1027 = _t1825 - xs1025.append(item1027) - cond1026 = self.match_lookahead_literal("(", 0) - attributes1028 = xs1025 + xs1026 = [] + cond1027 = self.match_lookahead_literal("(", 0) + while cond1027: + _t1827 = self.parse_attribute() + item1028 = _t1827 + xs1026.append(item1028) + cond1027 = self.match_lookahead_literal("(", 0) + attributes1029 = xs1026 self.consume_literal(")") - return attributes1028 + return attributes1029 def parse_attribute(self) -> logic_pb2.Attribute: - span_start1034 = self.span_start() + span_start1035 = self.span_start() self.consume_literal("(") self.consume_literal("attribute") - _t1826 = self.parse_name() - name1029 = _t1826 - xs1030 = [] - cond1031 = ((((((((((((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 cond1031: - _t1827 = self.parse_raw_value() - item1032 = _t1827 - xs1030.append(item1032) - cond1031 = ((((((((((((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_values1033 = xs1030 - self.consume_literal(")") - _t1828 = logic_pb2.Attribute(name=name1029, args=raw_values1033) - result1035 = _t1828 - self.record_span(span_start1034, "Attribute") - return result1035 + _t1828 = self.parse_name() + name1030 = _t1828 + xs1031 = [] + cond1032 = ((((((((((((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 cond1032: + _t1829 = self.parse_raw_value() + item1033 = _t1829 + xs1031.append(item1033) + cond1032 = ((((((((((((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_values1034 = xs1031 + self.consume_literal(")") + _t1830 = logic_pb2.Attribute(name=name1030, args=raw_values1034) + result1036 = _t1830 + self.record_span(span_start1035, "Attribute") + return result1036 def parse_algorithm(self) -> logic_pb2.Algorithm: - span_start1042 = self.span_start() + span_start1043 = self.span_start() self.consume_literal("(") self.consume_literal("algorithm") - xs1036 = [] - cond1037 = (self.match_lookahead_literal(":", 0) or self.match_lookahead_terminal("UINT128", 0)) - while cond1037: - _t1829 = self.parse_relation_id() - item1038 = _t1829 - xs1036.append(item1038) - cond1037 = (self.match_lookahead_literal(":", 0) or self.match_lookahead_terminal("UINT128", 0)) - relation_ids1039 = xs1036 - _t1830 = self.parse_script() - script1040 = _t1830 + xs1037 = [] + cond1038 = (self.match_lookahead_literal(":", 0) or self.match_lookahead_terminal("UINT128", 0)) + while cond1038: + _t1831 = self.parse_relation_id() + item1039 = _t1831 + xs1037.append(item1039) + cond1038 = (self.match_lookahead_literal(":", 0) or self.match_lookahead_terminal("UINT128", 0)) + relation_ids1040 = xs1037 + _t1832 = self.parse_script() + script1041 = _t1832 if self.match_lookahead_literal("(", 0): - _t1832 = self.parse_attrs() - _t1831 = _t1832 + _t1834 = self.parse_attrs() + _t1833 = _t1834 else: - _t1831 = None - attrs1041 = _t1831 + _t1833 = None + attrs1042 = _t1833 self.consume_literal(")") - _t1833 = logic_pb2.Algorithm(body=script1040, attrs=(attrs1041 if attrs1041 is not None else [])) - getattr(_t1833, 'global').extend(relation_ids1039) - result1043 = _t1833 - self.record_span(span_start1042, "Algorithm") - return result1043 + _t1835 = logic_pb2.Algorithm(body=script1041, attrs=(attrs1042 if attrs1042 is not None else [])) + getattr(_t1835, 'global').extend(relation_ids1040) + result1044 = _t1835 + self.record_span(span_start1043, "Algorithm") + return result1044 def parse_script(self) -> logic_pb2.Script: - span_start1048 = self.span_start() + span_start1049 = self.span_start() self.consume_literal("(") self.consume_literal("script") - xs1044 = [] - cond1045 = self.match_lookahead_literal("(", 0) - while cond1045: - _t1834 = self.parse_construct() - item1046 = _t1834 - xs1044.append(item1046) - cond1045 = self.match_lookahead_literal("(", 0) - constructs1047 = xs1044 - self.consume_literal(")") - _t1835 = logic_pb2.Script(constructs=constructs1047) - result1049 = _t1835 - self.record_span(span_start1048, "Script") - return result1049 + xs1045 = [] + cond1046 = self.match_lookahead_literal("(", 0) + while cond1046: + _t1836 = self.parse_construct() + item1047 = _t1836 + xs1045.append(item1047) + cond1046 = self.match_lookahead_literal("(", 0) + constructs1048 = xs1045 + self.consume_literal(")") + _t1837 = logic_pb2.Script(constructs=constructs1048) + result1050 = _t1837 + self.record_span(span_start1049, "Script") + return result1050 def parse_construct(self) -> logic_pb2.Construct: - span_start1053 = self.span_start() + span_start1054 = self.span_start() if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("upsert", 1): - _t1837 = 1 + _t1839 = 1 else: if self.match_lookahead_literal("monus", 1): - _t1838 = 1 + _t1840 = 1 else: if self.match_lookahead_literal("monoid", 1): - _t1839 = 1 + _t1841 = 1 else: if self.match_lookahead_literal("loop", 1): - _t1840 = 0 + _t1842 = 0 else: if self.match_lookahead_literal("break", 1): - _t1841 = 1 + _t1843 = 1 else: if self.match_lookahead_literal("assign", 1): - _t1842 = 1 + _t1844 = 1 else: - _t1842 = -1 - _t1841 = _t1842 - _t1840 = _t1841 - _t1839 = _t1840 - _t1838 = _t1839 - _t1837 = _t1838 - _t1836 = _t1837 - else: - _t1836 = -1 - prediction1050 = _t1836 - if prediction1050 == 1: - _t1844 = self.parse_instruction() - instruction1052 = _t1844 - _t1845 = logic_pb2.Construct(instruction=instruction1052) - _t1843 = _t1845 - else: - if prediction1050 == 0: - _t1847 = self.parse_loop() - loop1051 = _t1847 - _t1848 = logic_pb2.Construct(loop=loop1051) - _t1846 = _t1848 + _t1844 = -1 + _t1843 = _t1844 + _t1842 = _t1843 + _t1841 = _t1842 + _t1840 = _t1841 + _t1839 = _t1840 + _t1838 = _t1839 + else: + _t1838 = -1 + prediction1051 = _t1838 + if prediction1051 == 1: + _t1846 = self.parse_instruction() + instruction1053 = _t1846 + _t1847 = logic_pb2.Construct(instruction=instruction1053) + _t1845 = _t1847 + else: + if prediction1051 == 0: + _t1849 = self.parse_loop() + loop1052 = _t1849 + _t1850 = logic_pb2.Construct(loop=loop1052) + _t1848 = _t1850 else: raise ParseError("Unexpected token in construct" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1843 = _t1846 - result1054 = _t1843 - self.record_span(span_start1053, "Construct") - return result1054 + _t1845 = _t1848 + result1055 = _t1845 + self.record_span(span_start1054, "Construct") + return result1055 def parse_loop(self) -> logic_pb2.Loop: - span_start1058 = self.span_start() + span_start1059 = self.span_start() self.consume_literal("(") self.consume_literal("loop") - _t1849 = self.parse_init() - init1055 = _t1849 - _t1850 = self.parse_script() - script1056 = _t1850 + _t1851 = self.parse_init() + init1056 = _t1851 + _t1852 = self.parse_script() + script1057 = _t1852 if self.match_lookahead_literal("(", 0): - _t1852 = self.parse_attrs() - _t1851 = _t1852 + _t1854 = self.parse_attrs() + _t1853 = _t1854 else: - _t1851 = None - attrs1057 = _t1851 + _t1853 = None + attrs1058 = _t1853 self.consume_literal(")") - _t1853 = logic_pb2.Loop(init=init1055, body=script1056, attrs=(attrs1057 if attrs1057 is not None else [])) - result1059 = _t1853 - self.record_span(span_start1058, "Loop") - return result1059 + _t1855 = logic_pb2.Loop(init=init1056, body=script1057, attrs=(attrs1058 if attrs1058 is not None else [])) + result1060 = _t1855 + self.record_span(span_start1059, "Loop") + return result1060 def parse_init(self) -> Sequence[logic_pb2.Instruction]: self.consume_literal("(") self.consume_literal("init") - xs1060 = [] - cond1061 = self.match_lookahead_literal("(", 0) - while cond1061: - _t1854 = self.parse_instruction() - item1062 = _t1854 - xs1060.append(item1062) - cond1061 = self.match_lookahead_literal("(", 0) - instructions1063 = xs1060 + xs1061 = [] + cond1062 = self.match_lookahead_literal("(", 0) + while cond1062: + _t1856 = self.parse_instruction() + item1063 = _t1856 + xs1061.append(item1063) + cond1062 = self.match_lookahead_literal("(", 0) + instructions1064 = xs1061 self.consume_literal(")") - return instructions1063 + return instructions1064 def parse_instruction(self) -> logic_pb2.Instruction: - span_start1070 = self.span_start() + span_start1071 = self.span_start() if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("upsert", 1): - _t1856 = 1 + _t1858 = 1 else: if self.match_lookahead_literal("monus", 1): - _t1857 = 4 + _t1859 = 4 else: if self.match_lookahead_literal("monoid", 1): - _t1858 = 3 + _t1860 = 3 else: if self.match_lookahead_literal("break", 1): - _t1859 = 2 + _t1861 = 2 else: if self.match_lookahead_literal("assign", 1): - _t1860 = 0 + _t1862 = 0 else: - _t1860 = -1 - _t1859 = _t1860 - _t1858 = _t1859 - _t1857 = _t1858 - _t1856 = _t1857 - _t1855 = _t1856 - else: - _t1855 = -1 - prediction1064 = _t1855 - if prediction1064 == 4: - _t1862 = self.parse_monus_def() - monus_def1069 = _t1862 - _t1863 = logic_pb2.Instruction(monus_def=monus_def1069) - _t1861 = _t1863 - else: - if prediction1064 == 3: - _t1865 = self.parse_monoid_def() - monoid_def1068 = _t1865 - _t1866 = logic_pb2.Instruction(monoid_def=monoid_def1068) - _t1864 = _t1866 + _t1862 = -1 + _t1861 = _t1862 + _t1860 = _t1861 + _t1859 = _t1860 + _t1858 = _t1859 + _t1857 = _t1858 + else: + _t1857 = -1 + prediction1065 = _t1857 + if prediction1065 == 4: + _t1864 = self.parse_monus_def() + monus_def1070 = _t1864 + _t1865 = logic_pb2.Instruction(monus_def=monus_def1070) + _t1863 = _t1865 + else: + if prediction1065 == 3: + _t1867 = self.parse_monoid_def() + monoid_def1069 = _t1867 + _t1868 = logic_pb2.Instruction(monoid_def=monoid_def1069) + _t1866 = _t1868 else: - if prediction1064 == 2: - _t1868 = self.parse_break() - break1067 = _t1868 - _t1869 = logic_pb2.Instruction() - getattr(_t1869, 'break').CopyFrom(break1067) - _t1867 = _t1869 + if prediction1065 == 2: + _t1870 = self.parse_break() + break1068 = _t1870 + _t1871 = logic_pb2.Instruction() + getattr(_t1871, 'break').CopyFrom(break1068) + _t1869 = _t1871 else: - if prediction1064 == 1: - _t1871 = self.parse_upsert() - upsert1066 = _t1871 - _t1872 = logic_pb2.Instruction(upsert=upsert1066) - _t1870 = _t1872 + if prediction1065 == 1: + _t1873 = self.parse_upsert() + upsert1067 = _t1873 + _t1874 = logic_pb2.Instruction(upsert=upsert1067) + _t1872 = _t1874 else: - if prediction1064 == 0: - _t1874 = self.parse_assign() - assign1065 = _t1874 - _t1875 = logic_pb2.Instruction(assign=assign1065) - _t1873 = _t1875 + if prediction1065 == 0: + _t1876 = self.parse_assign() + assign1066 = _t1876 + _t1877 = logic_pb2.Instruction(assign=assign1066) + _t1875 = _t1877 else: raise ParseError("Unexpected token in instruction" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1870 = _t1873 - _t1867 = _t1870 - _t1864 = _t1867 - _t1861 = _t1864 - result1071 = _t1861 - self.record_span(span_start1070, "Instruction") - return result1071 + _t1872 = _t1875 + _t1869 = _t1872 + _t1866 = _t1869 + _t1863 = _t1866 + result1072 = _t1863 + self.record_span(span_start1071, "Instruction") + return result1072 def parse_assign(self) -> logic_pb2.Assign: - span_start1075 = self.span_start() + span_start1076 = self.span_start() self.consume_literal("(") self.consume_literal("assign") - _t1876 = self.parse_relation_id() - relation_id1072 = _t1876 - _t1877 = self.parse_abstraction() - abstraction1073 = _t1877 + _t1878 = self.parse_relation_id() + relation_id1073 = _t1878 + _t1879 = self.parse_abstraction() + abstraction1074 = _t1879 if self.match_lookahead_literal("(", 0): - _t1879 = self.parse_attrs() - _t1878 = _t1879 + _t1881 = self.parse_attrs() + _t1880 = _t1881 else: - _t1878 = None - attrs1074 = _t1878 + _t1880 = None + attrs1075 = _t1880 self.consume_literal(")") - _t1880 = logic_pb2.Assign(name=relation_id1072, body=abstraction1073, attrs=(attrs1074 if attrs1074 is not None else [])) - result1076 = _t1880 - self.record_span(span_start1075, "Assign") - return result1076 + _t1882 = logic_pb2.Assign(name=relation_id1073, body=abstraction1074, attrs=(attrs1075 if attrs1075 is not None else [])) + result1077 = _t1882 + self.record_span(span_start1076, "Assign") + return result1077 def parse_upsert(self) -> logic_pb2.Upsert: - span_start1080 = self.span_start() + span_start1081 = self.span_start() self.consume_literal("(") self.consume_literal("upsert") - _t1881 = self.parse_relation_id() - relation_id1077 = _t1881 - _t1882 = self.parse_abstraction_with_arity() - abstraction_with_arity1078 = _t1882 + _t1883 = self.parse_relation_id() + relation_id1078 = _t1883 + _t1884 = self.parse_abstraction_with_arity() + abstraction_with_arity1079 = _t1884 if self.match_lookahead_literal("(", 0): - _t1884 = self.parse_attrs() - _t1883 = _t1884 + _t1886 = self.parse_attrs() + _t1885 = _t1886 else: - _t1883 = None - attrs1079 = _t1883 + _t1885 = None + attrs1080 = _t1885 self.consume_literal(")") - _t1885 = logic_pb2.Upsert(name=relation_id1077, body=abstraction_with_arity1078[0], attrs=(attrs1079 if attrs1079 is not None else []), value_arity=abstraction_with_arity1078[1]) - result1081 = _t1885 - self.record_span(span_start1080, "Upsert") - return result1081 + _t1887 = logic_pb2.Upsert(name=relation_id1078, body=abstraction_with_arity1079[0], attrs=(attrs1080 if attrs1080 is not None else []), value_arity=abstraction_with_arity1079[1]) + result1082 = _t1887 + self.record_span(span_start1081, "Upsert") + return result1082 def parse_abstraction_with_arity(self) -> tuple[logic_pb2.Abstraction, int]: self.consume_literal("(") - _t1886 = self.parse_bindings() - bindings1082 = _t1886 - _t1887 = self.parse_formula() - formula1083 = _t1887 + _t1888 = self.parse_bindings() + bindings1083 = _t1888 + _t1889 = self.parse_formula() + formula1084 = _t1889 self.consume_literal(")") - _t1888 = logic_pb2.Abstraction(vars=(list(bindings1082[0]) + list(bindings1082[1] if bindings1082[1] is not None else [])), value=formula1083) - return (_t1888, len(bindings1082[1]),) + _t1890 = logic_pb2.Abstraction(vars=(list(bindings1083[0]) + list(bindings1083[1] if bindings1083[1] is not None else [])), value=formula1084) + return (_t1890, len(bindings1083[1]),) def parse_break(self) -> logic_pb2.Break: - span_start1087 = self.span_start() + span_start1088 = self.span_start() self.consume_literal("(") self.consume_literal("break") - _t1889 = self.parse_relation_id() - relation_id1084 = _t1889 - _t1890 = self.parse_abstraction() - abstraction1085 = _t1890 + _t1891 = self.parse_relation_id() + relation_id1085 = _t1891 + _t1892 = self.parse_abstraction() + abstraction1086 = _t1892 if self.match_lookahead_literal("(", 0): - _t1892 = self.parse_attrs() - _t1891 = _t1892 + _t1894 = self.parse_attrs() + _t1893 = _t1894 else: - _t1891 = None - attrs1086 = _t1891 + _t1893 = None + attrs1087 = _t1893 self.consume_literal(")") - _t1893 = logic_pb2.Break(name=relation_id1084, body=abstraction1085, attrs=(attrs1086 if attrs1086 is not None else [])) - result1088 = _t1893 - self.record_span(span_start1087, "Break") - return result1088 + _t1895 = logic_pb2.Break(name=relation_id1085, body=abstraction1086, attrs=(attrs1087 if attrs1087 is not None else [])) + result1089 = _t1895 + self.record_span(span_start1088, "Break") + return result1089 def parse_monoid_def(self) -> logic_pb2.MonoidDef: - span_start1093 = self.span_start() + span_start1094 = self.span_start() self.consume_literal("(") self.consume_literal("monoid") - _t1894 = self.parse_monoid() - monoid1089 = _t1894 - _t1895 = self.parse_relation_id() - relation_id1090 = _t1895 - _t1896 = self.parse_abstraction_with_arity() - abstraction_with_arity1091 = _t1896 + _t1896 = self.parse_monoid() + monoid1090 = _t1896 + _t1897 = self.parse_relation_id() + relation_id1091 = _t1897 + _t1898 = self.parse_abstraction_with_arity() + abstraction_with_arity1092 = _t1898 if self.match_lookahead_literal("(", 0): - _t1898 = self.parse_attrs() - _t1897 = _t1898 + _t1900 = self.parse_attrs() + _t1899 = _t1900 else: - _t1897 = None - attrs1092 = _t1897 + _t1899 = None + attrs1093 = _t1899 self.consume_literal(")") - _t1899 = logic_pb2.MonoidDef(monoid=monoid1089, name=relation_id1090, body=abstraction_with_arity1091[0], attrs=(attrs1092 if attrs1092 is not None else []), value_arity=abstraction_with_arity1091[1]) - result1094 = _t1899 - self.record_span(span_start1093, "MonoidDef") - return result1094 + _t1901 = logic_pb2.MonoidDef(monoid=monoid1090, name=relation_id1091, body=abstraction_with_arity1092[0], attrs=(attrs1093 if attrs1093 is not None else []), value_arity=abstraction_with_arity1092[1]) + result1095 = _t1901 + self.record_span(span_start1094, "MonoidDef") + return result1095 def parse_monoid(self) -> logic_pb2.Monoid: - span_start1100 = self.span_start() + span_start1101 = self.span_start() if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("sum", 1): - _t1901 = 3 + _t1903 = 3 else: if self.match_lookahead_literal("or", 1): - _t1902 = 0 + _t1904 = 0 else: if self.match_lookahead_literal("min", 1): - _t1903 = 1 + _t1905 = 1 else: if self.match_lookahead_literal("max", 1): - _t1904 = 2 + _t1906 = 2 else: - _t1904 = -1 - _t1903 = _t1904 - _t1902 = _t1903 - _t1901 = _t1902 - _t1900 = _t1901 - else: - _t1900 = -1 - prediction1095 = _t1900 - if prediction1095 == 3: - _t1906 = self.parse_sum_monoid() - sum_monoid1099 = _t1906 - _t1907 = logic_pb2.Monoid(sum_monoid=sum_monoid1099) - _t1905 = _t1907 - else: - if prediction1095 == 2: - _t1909 = self.parse_max_monoid() - max_monoid1098 = _t1909 - _t1910 = logic_pb2.Monoid(max_monoid=max_monoid1098) - _t1908 = _t1910 + _t1906 = -1 + _t1905 = _t1906 + _t1904 = _t1905 + _t1903 = _t1904 + _t1902 = _t1903 + else: + _t1902 = -1 + prediction1096 = _t1902 + if prediction1096 == 3: + _t1908 = self.parse_sum_monoid() + sum_monoid1100 = _t1908 + _t1909 = logic_pb2.Monoid(sum_monoid=sum_monoid1100) + _t1907 = _t1909 + else: + if prediction1096 == 2: + _t1911 = self.parse_max_monoid() + max_monoid1099 = _t1911 + _t1912 = logic_pb2.Monoid(max_monoid=max_monoid1099) + _t1910 = _t1912 else: - if prediction1095 == 1: - _t1912 = self.parse_min_monoid() - min_monoid1097 = _t1912 - _t1913 = logic_pb2.Monoid(min_monoid=min_monoid1097) - _t1911 = _t1913 + if prediction1096 == 1: + _t1914 = self.parse_min_monoid() + min_monoid1098 = _t1914 + _t1915 = logic_pb2.Monoid(min_monoid=min_monoid1098) + _t1913 = _t1915 else: - if prediction1095 == 0: - _t1915 = self.parse_or_monoid() - or_monoid1096 = _t1915 - _t1916 = logic_pb2.Monoid(or_monoid=or_monoid1096) - _t1914 = _t1916 + if prediction1096 == 0: + _t1917 = self.parse_or_monoid() + or_monoid1097 = _t1917 + _t1918 = logic_pb2.Monoid(or_monoid=or_monoid1097) + _t1916 = _t1918 else: raise ParseError("Unexpected token in monoid" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1911 = _t1914 - _t1908 = _t1911 - _t1905 = _t1908 - result1101 = _t1905 - self.record_span(span_start1100, "Monoid") - return result1101 + _t1913 = _t1916 + _t1910 = _t1913 + _t1907 = _t1910 + result1102 = _t1907 + self.record_span(span_start1101, "Monoid") + return result1102 def parse_or_monoid(self) -> logic_pb2.OrMonoid: - span_start1102 = self.span_start() + span_start1103 = self.span_start() self.consume_literal("(") self.consume_literal("or") self.consume_literal(")") - _t1917 = logic_pb2.OrMonoid() - result1103 = _t1917 - self.record_span(span_start1102, "OrMonoid") - return result1103 + _t1919 = logic_pb2.OrMonoid() + result1104 = _t1919 + self.record_span(span_start1103, "OrMonoid") + return result1104 def parse_min_monoid(self) -> logic_pb2.MinMonoid: - span_start1105 = self.span_start() + span_start1106 = self.span_start() self.consume_literal("(") self.consume_literal("min") - _t1918 = self.parse_type() - type1104 = _t1918 + _t1920 = self.parse_type() + type1105 = _t1920 self.consume_literal(")") - _t1919 = logic_pb2.MinMonoid(type=type1104) - result1106 = _t1919 - self.record_span(span_start1105, "MinMonoid") - return result1106 + _t1921 = logic_pb2.MinMonoid(type=type1105) + result1107 = _t1921 + self.record_span(span_start1106, "MinMonoid") + return result1107 def parse_max_monoid(self) -> logic_pb2.MaxMonoid: - span_start1108 = self.span_start() + span_start1109 = self.span_start() self.consume_literal("(") self.consume_literal("max") - _t1920 = self.parse_type() - type1107 = _t1920 + _t1922 = self.parse_type() + type1108 = _t1922 self.consume_literal(")") - _t1921 = logic_pb2.MaxMonoid(type=type1107) - result1109 = _t1921 - self.record_span(span_start1108, "MaxMonoid") - return result1109 + _t1923 = logic_pb2.MaxMonoid(type=type1108) + result1110 = _t1923 + self.record_span(span_start1109, "MaxMonoid") + return result1110 def parse_sum_monoid(self) -> logic_pb2.SumMonoid: - span_start1111 = self.span_start() + span_start1112 = self.span_start() self.consume_literal("(") self.consume_literal("sum") - _t1922 = self.parse_type() - type1110 = _t1922 + _t1924 = self.parse_type() + type1111 = _t1924 self.consume_literal(")") - _t1923 = logic_pb2.SumMonoid(type=type1110) - result1112 = _t1923 - self.record_span(span_start1111, "SumMonoid") - return result1112 + _t1925 = logic_pb2.SumMonoid(type=type1111) + result1113 = _t1925 + self.record_span(span_start1112, "SumMonoid") + return result1113 def parse_monus_def(self) -> logic_pb2.MonusDef: - span_start1117 = self.span_start() + span_start1118 = self.span_start() self.consume_literal("(") self.consume_literal("monus") - _t1924 = self.parse_monoid() - monoid1113 = _t1924 - _t1925 = self.parse_relation_id() - relation_id1114 = _t1925 - _t1926 = self.parse_abstraction_with_arity() - abstraction_with_arity1115 = _t1926 + _t1926 = self.parse_monoid() + monoid1114 = _t1926 + _t1927 = self.parse_relation_id() + relation_id1115 = _t1927 + _t1928 = self.parse_abstraction_with_arity() + abstraction_with_arity1116 = _t1928 if self.match_lookahead_literal("(", 0): - _t1928 = self.parse_attrs() - _t1927 = _t1928 + _t1930 = self.parse_attrs() + _t1929 = _t1930 else: - _t1927 = None - attrs1116 = _t1927 + _t1929 = None + attrs1117 = _t1929 self.consume_literal(")") - _t1929 = logic_pb2.MonusDef(monoid=monoid1113, name=relation_id1114, body=abstraction_with_arity1115[0], attrs=(attrs1116 if attrs1116 is not None else []), value_arity=abstraction_with_arity1115[1]) - result1118 = _t1929 - self.record_span(span_start1117, "MonusDef") - return result1118 + _t1931 = logic_pb2.MonusDef(monoid=monoid1114, name=relation_id1115, body=abstraction_with_arity1116[0], attrs=(attrs1117 if attrs1117 is not None else []), value_arity=abstraction_with_arity1116[1]) + result1119 = _t1931 + self.record_span(span_start1118, "MonusDef") + return result1119 def parse_constraint(self) -> logic_pb2.Constraint: - span_start1123 = self.span_start() + span_start1124 = self.span_start() self.consume_literal("(") self.consume_literal("functional_dependency") - _t1930 = self.parse_relation_id() - relation_id1119 = _t1930 - _t1931 = self.parse_abstraction() - abstraction1120 = _t1931 - _t1932 = self.parse_functional_dependency_keys() - functional_dependency_keys1121 = _t1932 - _t1933 = self.parse_functional_dependency_values() - functional_dependency_values1122 = _t1933 - self.consume_literal(")") - _t1934 = logic_pb2.FunctionalDependency(guard=abstraction1120, keys=functional_dependency_keys1121, values=functional_dependency_values1122) - _t1935 = logic_pb2.Constraint(name=relation_id1119, functional_dependency=_t1934) - result1124 = _t1935 - self.record_span(span_start1123, "Constraint") - return result1124 + _t1932 = self.parse_relation_id() + relation_id1120 = _t1932 + _t1933 = self.parse_abstraction() + abstraction1121 = _t1933 + _t1934 = self.parse_functional_dependency_keys() + functional_dependency_keys1122 = _t1934 + _t1935 = self.parse_functional_dependency_values() + functional_dependency_values1123 = _t1935 + self.consume_literal(")") + _t1936 = logic_pb2.FunctionalDependency(guard=abstraction1121, keys=functional_dependency_keys1122, values=functional_dependency_values1123) + _t1937 = logic_pb2.Constraint(name=relation_id1120, functional_dependency=_t1936) + result1125 = _t1937 + self.record_span(span_start1124, "Constraint") + return result1125 def parse_functional_dependency_keys(self) -> Sequence[logic_pb2.Var]: self.consume_literal("(") self.consume_literal("keys") - xs1125 = [] - cond1126 = self.match_lookahead_terminal("SYMBOL", 0) - while cond1126: - _t1936 = self.parse_var() - item1127 = _t1936 - xs1125.append(item1127) - cond1126 = self.match_lookahead_terminal("SYMBOL", 0) - vars1128 = xs1125 + xs1126 = [] + cond1127 = self.match_lookahead_terminal("SYMBOL", 0) + while cond1127: + _t1938 = self.parse_var() + item1128 = _t1938 + xs1126.append(item1128) + cond1127 = self.match_lookahead_terminal("SYMBOL", 0) + vars1129 = xs1126 self.consume_literal(")") - return vars1128 + return vars1129 def parse_functional_dependency_values(self) -> Sequence[logic_pb2.Var]: self.consume_literal("(") self.consume_literal("values") - xs1129 = [] - cond1130 = self.match_lookahead_terminal("SYMBOL", 0) - while cond1130: - _t1937 = self.parse_var() - item1131 = _t1937 - xs1129.append(item1131) - cond1130 = self.match_lookahead_terminal("SYMBOL", 0) - vars1132 = xs1129 + xs1130 = [] + cond1131 = self.match_lookahead_terminal("SYMBOL", 0) + while cond1131: + _t1939 = self.parse_var() + item1132 = _t1939 + xs1130.append(item1132) + cond1131 = self.match_lookahead_terminal("SYMBOL", 0) + vars1133 = xs1130 self.consume_literal(")") - return vars1132 + return vars1133 def parse_data(self) -> logic_pb2.Data: - span_start1138 = self.span_start() + span_start1139 = self.span_start() if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("iceberg_data", 1): - _t1939 = 3 + _t1941 = 3 else: if self.match_lookahead_literal("edb", 1): - _t1940 = 0 + _t1942 = 0 else: if self.match_lookahead_literal("csv_data", 1): - _t1941 = 2 + _t1943 = 2 else: if self.match_lookahead_literal("betree_relation", 1): - _t1942 = 1 + _t1944 = 1 else: - _t1942 = -1 - _t1941 = _t1942 - _t1940 = _t1941 - _t1939 = _t1940 - _t1938 = _t1939 - else: - _t1938 = -1 - prediction1133 = _t1938 - if prediction1133 == 3: - _t1944 = self.parse_iceberg_data() - iceberg_data1137 = _t1944 - _t1945 = logic_pb2.Data(iceberg_data=iceberg_data1137) - _t1943 = _t1945 - else: - if prediction1133 == 2: - _t1947 = self.parse_csv_data() - csv_data1136 = _t1947 - _t1948 = logic_pb2.Data(csv_data=csv_data1136) - _t1946 = _t1948 + _t1944 = -1 + _t1943 = _t1944 + _t1942 = _t1943 + _t1941 = _t1942 + _t1940 = _t1941 + else: + _t1940 = -1 + prediction1134 = _t1940 + if prediction1134 == 3: + _t1946 = self.parse_iceberg_data() + iceberg_data1138 = _t1946 + _t1947 = logic_pb2.Data(iceberg_data=iceberg_data1138) + _t1945 = _t1947 + else: + if prediction1134 == 2: + _t1949 = self.parse_csv_data() + csv_data1137 = _t1949 + _t1950 = logic_pb2.Data(csv_data=csv_data1137) + _t1948 = _t1950 else: - if prediction1133 == 1: - _t1950 = self.parse_betree_relation() - betree_relation1135 = _t1950 - _t1951 = logic_pb2.Data(betree_relation=betree_relation1135) - _t1949 = _t1951 + if prediction1134 == 1: + _t1952 = self.parse_betree_relation() + betree_relation1136 = _t1952 + _t1953 = logic_pb2.Data(betree_relation=betree_relation1136) + _t1951 = _t1953 else: - if prediction1133 == 0: - _t1953 = self.parse_edb() - edb1134 = _t1953 - _t1954 = logic_pb2.Data(edb=edb1134) - _t1952 = _t1954 + if prediction1134 == 0: + _t1955 = self.parse_edb() + edb1135 = _t1955 + _t1956 = logic_pb2.Data(edb=edb1135) + _t1954 = _t1956 else: raise ParseError("Unexpected token in data" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1949 = _t1952 - _t1946 = _t1949 - _t1943 = _t1946 - result1139 = _t1943 - self.record_span(span_start1138, "Data") - return result1139 + _t1951 = _t1954 + _t1948 = _t1951 + _t1945 = _t1948 + result1140 = _t1945 + self.record_span(span_start1139, "Data") + return result1140 def parse_edb(self) -> logic_pb2.EDB: - span_start1143 = self.span_start() + span_start1144 = self.span_start() self.consume_literal("(") self.consume_literal("edb") - _t1955 = self.parse_relation_id() - relation_id1140 = _t1955 - _t1956 = self.parse_edb_path() - edb_path1141 = _t1956 - _t1957 = self.parse_edb_types() - edb_types1142 = _t1957 - self.consume_literal(")") - _t1958 = logic_pb2.EDB(target_id=relation_id1140, path=edb_path1141, types=edb_types1142) - result1144 = _t1958 - self.record_span(span_start1143, "EDB") - return result1144 + _t1957 = self.parse_relation_id() + relation_id1141 = _t1957 + _t1958 = self.parse_edb_path() + edb_path1142 = _t1958 + _t1959 = self.parse_edb_types() + edb_types1143 = _t1959 + self.consume_literal(")") + _t1960 = logic_pb2.EDB(target_id=relation_id1141, path=edb_path1142, types=edb_types1143) + result1145 = _t1960 + self.record_span(span_start1144, "EDB") + return result1145 def parse_edb_path(self) -> Sequence[str]: self.consume_literal("[") - xs1145 = [] - cond1146 = self.match_lookahead_terminal("STRING", 0) - while cond1146: - item1147 = self.consume_terminal("STRING") - xs1145.append(item1147) - cond1146 = self.match_lookahead_terminal("STRING", 0) - strings1148 = xs1145 + xs1146 = [] + cond1147 = self.match_lookahead_terminal("STRING", 0) + while cond1147: + item1148 = self.consume_terminal("STRING") + xs1146.append(item1148) + cond1147 = self.match_lookahead_terminal("STRING", 0) + strings1149 = xs1146 self.consume_literal("]") - return strings1148 + return strings1149 def parse_edb_types(self) -> Sequence[logic_pb2.Type]: self.consume_literal("[") - xs1149 = [] - cond1150 = (((((((((((((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 cond1150: - _t1959 = self.parse_type() - item1151 = _t1959 - xs1149.append(item1151) - cond1150 = (((((((((((((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)) - types1152 = xs1149 + xs1150 = [] + cond1151 = (((((((((((((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 cond1151: + _t1961 = self.parse_type() + item1152 = _t1961 + xs1150.append(item1152) + cond1151 = (((((((((((((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)) + types1153 = xs1150 self.consume_literal("]") - return types1152 + return types1153 def parse_betree_relation(self) -> logic_pb2.BeTreeRelation: - span_start1155 = self.span_start() + span_start1156 = self.span_start() self.consume_literal("(") self.consume_literal("betree_relation") - _t1960 = self.parse_relation_id() - relation_id1153 = _t1960 - _t1961 = self.parse_betree_info() - betree_info1154 = _t1961 + _t1962 = self.parse_relation_id() + relation_id1154 = _t1962 + _t1963 = self.parse_betree_info() + betree_info1155 = _t1963 self.consume_literal(")") - _t1962 = logic_pb2.BeTreeRelation(name=relation_id1153, relation_info=betree_info1154) - result1156 = _t1962 - self.record_span(span_start1155, "BeTreeRelation") - return result1156 + _t1964 = logic_pb2.BeTreeRelation(name=relation_id1154, relation_info=betree_info1155) + result1157 = _t1964 + self.record_span(span_start1156, "BeTreeRelation") + return result1157 def parse_betree_info(self) -> logic_pb2.BeTreeInfo: - span_start1160 = self.span_start() + span_start1161 = self.span_start() self.consume_literal("(") self.consume_literal("betree_info") - _t1963 = self.parse_betree_info_key_types() - betree_info_key_types1157 = _t1963 - _t1964 = self.parse_betree_info_value_types() - betree_info_value_types1158 = _t1964 - _t1965 = self.parse_config_dict() - config_dict1159 = _t1965 - self.consume_literal(")") - _t1966 = self.construct_betree_info(betree_info_key_types1157, betree_info_value_types1158, config_dict1159) - result1161 = _t1966 - self.record_span(span_start1160, "BeTreeInfo") - return result1161 + _t1965 = self.parse_betree_info_key_types() + betree_info_key_types1158 = _t1965 + _t1966 = self.parse_betree_info_value_types() + betree_info_value_types1159 = _t1966 + _t1967 = self.parse_config_dict() + config_dict1160 = _t1967 + self.consume_literal(")") + _t1968 = self.construct_betree_info(betree_info_key_types1158, betree_info_value_types1159, config_dict1160) + result1162 = _t1968 + self.record_span(span_start1161, "BeTreeInfo") + return result1162 def parse_betree_info_key_types(self) -> Sequence[logic_pb2.Type]: self.consume_literal("(") self.consume_literal("key_types") - xs1162 = [] - cond1163 = (((((((((((((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 cond1163: - _t1967 = self.parse_type() - item1164 = _t1967 - xs1162.append(item1164) - cond1163 = (((((((((((((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)) - types1165 = xs1162 + xs1163 = [] + cond1164 = (((((((((((((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 cond1164: + _t1969 = self.parse_type() + item1165 = _t1969 + xs1163.append(item1165) + cond1164 = (((((((((((((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)) + types1166 = xs1163 self.consume_literal(")") - return types1165 + return types1166 def parse_betree_info_value_types(self) -> Sequence[logic_pb2.Type]: self.consume_literal("(") self.consume_literal("value_types") - xs1166 = [] - cond1167 = (((((((((((((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 cond1167: - _t1968 = self.parse_type() - item1168 = _t1968 - xs1166.append(item1168) - cond1167 = (((((((((((((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)) - types1169 = xs1166 + xs1167 = [] + cond1168 = (((((((((((((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 cond1168: + _t1970 = self.parse_type() + item1169 = _t1970 + xs1167.append(item1169) + cond1168 = (((((((((((((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)) + types1170 = xs1167 self.consume_literal(")") - return types1169 + return types1170 def parse_csv_data(self) -> logic_pb2.CSVData: - span_start1174 = self.span_start() + span_start1175 = self.span_start() self.consume_literal("(") self.consume_literal("csv_data") - _t1969 = self.parse_csvlocator() - csvlocator1170 = _t1969 - _t1970 = self.parse_csv_config() - csv_config1171 = _t1970 - _t1971 = self.parse_gnf_columns() - gnf_columns1172 = _t1971 - _t1972 = self.parse_csv_asof() - csv_asof1173 = _t1972 - self.consume_literal(")") - _t1973 = logic_pb2.CSVData(locator=csvlocator1170, config=csv_config1171, columns=gnf_columns1172, asof=csv_asof1173) - result1175 = _t1973 - self.record_span(span_start1174, "CSVData") - return result1175 + _t1971 = self.parse_csvlocator() + csvlocator1171 = _t1971 + _t1972 = self.parse_csv_config() + csv_config1172 = _t1972 + _t1973 = self.parse_gnf_columns() + gnf_columns1173 = _t1973 + _t1974 = self.parse_csv_asof() + csv_asof1174 = _t1974 + self.consume_literal(")") + _t1975 = logic_pb2.CSVData(locator=csvlocator1171, config=csv_config1172, columns=gnf_columns1173, asof=csv_asof1174) + result1176 = _t1975 + self.record_span(span_start1175, "CSVData") + return result1176 def parse_csvlocator(self) -> logic_pb2.CSVLocator: - span_start1178 = self.span_start() + span_start1179 = self.span_start() self.consume_literal("(") self.consume_literal("csv_locator") if (self.match_lookahead_literal("(", 0) and self.match_lookahead_literal("paths", 1)): - _t1975 = self.parse_csv_locator_paths() - _t1974 = _t1975 - else: - _t1974 = None - csv_locator_paths1176 = _t1974 - if self.match_lookahead_literal("(", 0): - _t1977 = self.parse_csv_locator_inline_data() + _t1977 = self.parse_csv_locator_paths() _t1976 = _t1977 else: _t1976 = None - csv_locator_inline_data1177 = _t1976 + csv_locator_paths1177 = _t1976 + if self.match_lookahead_literal("(", 0): + _t1979 = self.parse_csv_locator_inline_data() + _t1978 = _t1979 + else: + _t1978 = None + csv_locator_inline_data1178 = _t1978 self.consume_literal(")") - _t1978 = logic_pb2.CSVLocator(paths=(csv_locator_paths1176 if csv_locator_paths1176 is not None else []), inline_data=(csv_locator_inline_data1177 if csv_locator_inline_data1177 is not None else "").encode()) - result1179 = _t1978 - self.record_span(span_start1178, "CSVLocator") - return result1179 + _t1980 = logic_pb2.CSVLocator(paths=(csv_locator_paths1177 if csv_locator_paths1177 is not None else []), inline_data=(csv_locator_inline_data1178 if csv_locator_inline_data1178 is not None else "").encode()) + result1180 = _t1980 + self.record_span(span_start1179, "CSVLocator") + return result1180 def parse_csv_locator_paths(self) -> Sequence[str]: self.consume_literal("(") self.consume_literal("paths") - xs1180 = [] - cond1181 = self.match_lookahead_terminal("STRING", 0) - while cond1181: - item1182 = self.consume_terminal("STRING") - xs1180.append(item1182) - cond1181 = self.match_lookahead_terminal("STRING", 0) - strings1183 = xs1180 + xs1181 = [] + cond1182 = self.match_lookahead_terminal("STRING", 0) + while cond1182: + item1183 = self.consume_terminal("STRING") + xs1181.append(item1183) + cond1182 = self.match_lookahead_terminal("STRING", 0) + strings1184 = xs1181 self.consume_literal(")") - return strings1183 + return strings1184 def parse_csv_locator_inline_data(self) -> str: self.consume_literal("(") self.consume_literal("inline_data") - formatted_string1184 = self.consume_terminal("STRING") + formatted_string1185 = self.consume_terminal("STRING") self.consume_literal(")") - return formatted_string1184 + return formatted_string1185 def parse_csv_config(self) -> logic_pb2.CSVConfig: - span_start1187 = self.span_start() + span_start1188 = self.span_start() self.consume_literal("(") self.consume_literal("csv_config") - _t1979 = self.parse_config_dict() - config_dict1185 = _t1979 + _t1981 = self.parse_config_dict() + config_dict1186 = _t1981 if self.match_lookahead_literal("(", 0): - _t1981 = self.parse__storage_integration() - _t1980 = _t1981 + _t1983 = self.parse__storage_integration() + _t1982 = _t1983 else: - _t1980 = None - _storage_integration1186 = _t1980 + _t1982 = None + _storage_integration1187 = _t1982 self.consume_literal(")") - _t1982 = self.construct_csv_config(config_dict1185, _storage_integration1186) - result1188 = _t1982 - self.record_span(span_start1187, "CSVConfig") - return result1188 + _t1984 = self.construct_csv_config(config_dict1186, _storage_integration1187) + result1189 = _t1984 + self.record_span(span_start1188, "CSVConfig") + return result1189 def parse__storage_integration(self) -> Sequence[tuple[str, logic_pb2.Value]]: self.consume_literal("(") self.consume_literal("storage_integration") - _t1983 = self.parse_config_dict() - config_dict1189 = _t1983 + _t1985 = self.parse_config_dict() + config_dict1190 = _t1985 self.consume_literal(")") - return config_dict1189 + return config_dict1190 def parse_gnf_columns(self) -> Sequence[logic_pb2.GNFColumn]: self.consume_literal("(") self.consume_literal("columns") - xs1190 = [] - cond1191 = self.match_lookahead_literal("(", 0) - while cond1191: - _t1984 = self.parse_gnf_column() - item1192 = _t1984 - xs1190.append(item1192) - cond1191 = self.match_lookahead_literal("(", 0) - gnf_columns1193 = xs1190 + xs1191 = [] + cond1192 = self.match_lookahead_literal("(", 0) + while cond1192: + _t1986 = self.parse_gnf_column() + item1193 = _t1986 + xs1191.append(item1193) + cond1192 = self.match_lookahead_literal("(", 0) + gnf_columns1194 = xs1191 self.consume_literal(")") - return gnf_columns1193 + return gnf_columns1194 def parse_gnf_column(self) -> logic_pb2.GNFColumn: - span_start1200 = self.span_start() + span_start1201 = self.span_start() self.consume_literal("(") self.consume_literal("column") - _t1985 = self.parse_gnf_column_path() - gnf_column_path1194 = _t1985 + _t1987 = self.parse_gnf_column_path() + gnf_column_path1195 = _t1987 if (self.match_lookahead_literal(":", 0) or self.match_lookahead_terminal("UINT128", 0)): - _t1987 = self.parse_relation_id() - _t1986 = _t1987 + _t1989 = self.parse_relation_id() + _t1988 = _t1989 else: - _t1986 = None - relation_id1195 = _t1986 + _t1988 = None + relation_id1196 = _t1988 self.consume_literal("[") - xs1196 = [] - cond1197 = (((((((((((((self.match_lookahead_literal("(", 0) or self.match_lookahead_literal("BOOLEAN", 0)) or self.match_lookahead_literal("DATE", 0)) or self.match_lookahead_literal("DATETIME", 0)) or self.match_lookahead_literal("FLOAT", 0)) or self.match_lookahead_literal("FLOAT32", 0)) or self.match_lookahead_literal("INT", 0)) or self.match_lookahead_literal("INT128", 0)) or self.match_lookahead_literal("INT32", 0)) or self.match_lookahead_literal("MISSING", 0)) or self.match_lookahead_literal("STRING", 0)) or self.match_lookahead_literal("UINT128", 0)) or self.match_lookahead_literal("UINT32", 0)) or self.match_lookahead_literal("UNKNOWN", 0)) - while cond1197: - _t1988 = self.parse_type() - item1198 = _t1988 - xs1196.append(item1198) - cond1197 = (((((((((((((self.match_lookahead_literal("(", 0) or self.match_lookahead_literal("BOOLEAN", 0)) or self.match_lookahead_literal("DATE", 0)) or self.match_lookahead_literal("DATETIME", 0)) or self.match_lookahead_literal("FLOAT", 0)) or self.match_lookahead_literal("FLOAT32", 0)) or self.match_lookahead_literal("INT", 0)) or self.match_lookahead_literal("INT128", 0)) or self.match_lookahead_literal("INT32", 0)) or self.match_lookahead_literal("MISSING", 0)) or self.match_lookahead_literal("STRING", 0)) or self.match_lookahead_literal("UINT128", 0)) or self.match_lookahead_literal("UINT32", 0)) or self.match_lookahead_literal("UNKNOWN", 0)) - types1199 = xs1196 + xs1197 = [] + cond1198 = (((((((((((((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 cond1198: + _t1990 = self.parse_type() + item1199 = _t1990 + xs1197.append(item1199) + cond1198 = (((((((((((((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)) + types1200 = xs1197 self.consume_literal("]") self.consume_literal(")") - _t1989 = logic_pb2.GNFColumn(column_path=gnf_column_path1194, target_id=relation_id1195, types=types1199) - result1201 = _t1989 - self.record_span(span_start1200, "GNFColumn") - return result1201 + _t1991 = logic_pb2.GNFColumn(column_path=gnf_column_path1195, target_id=relation_id1196, types=types1200) + result1202 = _t1991 + self.record_span(span_start1201, "GNFColumn") + return result1202 def parse_gnf_column_path(self) -> Sequence[str]: if self.match_lookahead_literal("[", 0): - _t1990 = 1 + _t1992 = 1 else: if self.match_lookahead_terminal("STRING", 0): - _t1991 = 0 + _t1993 = 0 else: - _t1991 = -1 - _t1990 = _t1991 - prediction1202 = _t1990 - if prediction1202 == 1: + _t1993 = -1 + _t1992 = _t1993 + prediction1203 = _t1992 + if prediction1203 == 1: self.consume_literal("[") - xs1204 = [] - cond1205 = self.match_lookahead_terminal("STRING", 0) - while cond1205: - item1206 = self.consume_terminal("STRING") - xs1204.append(item1206) - cond1205 = self.match_lookahead_terminal("STRING", 0) - strings1207 = xs1204 + xs1205 = [] + cond1206 = self.match_lookahead_terminal("STRING", 0) + while cond1206: + item1207 = self.consume_terminal("STRING") + xs1205.append(item1207) + cond1206 = self.match_lookahead_terminal("STRING", 0) + strings1208 = xs1205 self.consume_literal("]") - _t1992 = strings1207 + _t1994 = strings1208 else: - if prediction1202 == 0: - string1203 = self.consume_terminal("STRING") - _t1993 = [string1203] + if prediction1203 == 0: + string1204 = self.consume_terminal("STRING") + _t1995 = [string1204] else: raise ParseError("Unexpected token in gnf_column_path" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1992 = _t1993 - return _t1992 + _t1994 = _t1995 + return _t1994 def parse_csv_asof(self) -> str: self.consume_literal("(") self.consume_literal("asof") - string1208 = self.consume_terminal("STRING") + string1209 = self.consume_terminal("STRING") self.consume_literal(")") - return string1208 + return string1209 def parse_iceberg_data(self) -> logic_pb2.IcebergData: - span_start1215 = self.span_start() + span_start1216 = self.span_start() self.consume_literal("(") self.consume_literal("iceberg_data") - _t1994 = self.parse_iceberg_locator() - iceberg_locator1209 = _t1994 - _t1995 = self.parse_iceberg_catalog_config() - iceberg_catalog_config1210 = _t1995 - _t1996 = self.parse_gnf_columns() - gnf_columns1211 = _t1996 + _t1996 = self.parse_iceberg_locator() + iceberg_locator1210 = _t1996 + _t1997 = self.parse_iceberg_catalog_config() + iceberg_catalog_config1211 = _t1997 + _t1998 = self.parse_gnf_columns() + gnf_columns1212 = _t1998 if (self.match_lookahead_literal("(", 0) and self.match_lookahead_literal("from_snapshot", 1)): - _t1998 = self.parse_iceberg_from_snapshot() - _t1997 = _t1998 - else: - _t1997 = None - iceberg_from_snapshot1212 = _t1997 - if self.match_lookahead_literal("(", 0): - _t2000 = self.parse_iceberg_to_snapshot() + _t2000 = self.parse_iceberg_from_snapshot() _t1999 = _t2000 else: _t1999 = None - iceberg_to_snapshot1213 = _t1999 - _t2001 = self.parse_boolean_value() - boolean_value1214 = _t2001 + iceberg_from_snapshot1213 = _t1999 + if self.match_lookahead_literal("(", 0): + _t2002 = self.parse_iceberg_to_snapshot() + _t2001 = _t2002 + else: + _t2001 = None + iceberg_to_snapshot1214 = _t2001 + _t2003 = self.parse_boolean_value() + boolean_value1215 = _t2003 self.consume_literal(")") - _t2002 = self.construct_iceberg_data(iceberg_locator1209, iceberg_catalog_config1210, gnf_columns1211, iceberg_from_snapshot1212, iceberg_to_snapshot1213, boolean_value1214) - result1216 = _t2002 - self.record_span(span_start1215, "IcebergData") - return result1216 + _t2004 = self.construct_iceberg_data(iceberg_locator1210, iceberg_catalog_config1211, gnf_columns1212, iceberg_from_snapshot1213, iceberg_to_snapshot1214, boolean_value1215) + result1217 = _t2004 + self.record_span(span_start1216, "IcebergData") + return result1217 def parse_iceberg_locator(self) -> logic_pb2.IcebergLocator: - span_start1220 = self.span_start() + span_start1221 = self.span_start() self.consume_literal("(") self.consume_literal("iceberg_locator") - _t2003 = self.parse_iceberg_locator_table_name() - iceberg_locator_table_name1217 = _t2003 - _t2004 = self.parse_iceberg_locator_namespace() - iceberg_locator_namespace1218 = _t2004 - _t2005 = self.parse_iceberg_locator_warehouse() - iceberg_locator_warehouse1219 = _t2005 - self.consume_literal(")") - _t2006 = logic_pb2.IcebergLocator(table_name=iceberg_locator_table_name1217, namespace=iceberg_locator_namespace1218, warehouse=iceberg_locator_warehouse1219) - result1221 = _t2006 - self.record_span(span_start1220, "IcebergLocator") - return result1221 + _t2005 = self.parse_iceberg_locator_table_name() + iceberg_locator_table_name1218 = _t2005 + _t2006 = self.parse_iceberg_locator_namespace() + iceberg_locator_namespace1219 = _t2006 + _t2007 = self.parse_iceberg_locator_warehouse() + iceberg_locator_warehouse1220 = _t2007 + self.consume_literal(")") + _t2008 = logic_pb2.IcebergLocator(table_name=iceberg_locator_table_name1218, namespace=iceberg_locator_namespace1219, warehouse=iceberg_locator_warehouse1220) + result1222 = _t2008 + self.record_span(span_start1221, "IcebergLocator") + return result1222 def parse_iceberg_locator_table_name(self) -> str: self.consume_literal("(") self.consume_literal("table_name") - string1222 = self.consume_terminal("STRING") + string1223 = self.consume_terminal("STRING") self.consume_literal(")") - return string1222 + return string1223 def parse_iceberg_locator_namespace(self) -> Sequence[str]: self.consume_literal("(") self.consume_literal("namespace") - xs1223 = [] - cond1224 = self.match_lookahead_terminal("STRING", 0) - while cond1224: - item1225 = self.consume_terminal("STRING") - xs1223.append(item1225) - cond1224 = self.match_lookahead_terminal("STRING", 0) - strings1226 = xs1223 + xs1224 = [] + cond1225 = self.match_lookahead_terminal("STRING", 0) + while cond1225: + item1226 = self.consume_terminal("STRING") + xs1224.append(item1226) + cond1225 = self.match_lookahead_terminal("STRING", 0) + strings1227 = xs1224 self.consume_literal(")") - return strings1226 + return strings1227 def parse_iceberg_locator_warehouse(self) -> str: self.consume_literal("(") self.consume_literal("warehouse") - string1227 = self.consume_terminal("STRING") + string1228 = self.consume_terminal("STRING") self.consume_literal(")") - return string1227 + return string1228 def parse_iceberg_catalog_config(self) -> logic_pb2.IcebergCatalogConfig: - span_start1232 = self.span_start() + span_start1233 = self.span_start() self.consume_literal("(") self.consume_literal("iceberg_catalog_config") - _t2007 = self.parse_iceberg_catalog_uri() - iceberg_catalog_uri1228 = _t2007 + _t2009 = self.parse_iceberg_catalog_uri() + iceberg_catalog_uri1229 = _t2009 if (self.match_lookahead_literal("(", 0) and self.match_lookahead_literal("scope", 1)): - _t2009 = self.parse_iceberg_catalog_config_scope() - _t2008 = _t2009 + _t2011 = self.parse_iceberg_catalog_config_scope() + _t2010 = _t2011 else: - _t2008 = None - iceberg_catalog_config_scope1229 = _t2008 - _t2010 = self.parse_iceberg_properties() - iceberg_properties1230 = _t2010 - _t2011 = self.parse_iceberg_auth_properties() - iceberg_auth_properties1231 = _t2011 + _t2010 = None + iceberg_catalog_config_scope1230 = _t2010 + _t2012 = self.parse_iceberg_properties() + iceberg_properties1231 = _t2012 + _t2013 = self.parse_iceberg_auth_properties() + iceberg_auth_properties1232 = _t2013 self.consume_literal(")") - _t2012 = self.construct_iceberg_catalog_config(iceberg_catalog_uri1228, iceberg_catalog_config_scope1229, iceberg_properties1230, iceberg_auth_properties1231) - result1233 = _t2012 - self.record_span(span_start1232, "IcebergCatalogConfig") - return result1233 + _t2014 = self.construct_iceberg_catalog_config(iceberg_catalog_uri1229, iceberg_catalog_config_scope1230, iceberg_properties1231, iceberg_auth_properties1232) + result1234 = _t2014 + self.record_span(span_start1233, "IcebergCatalogConfig") + return result1234 def parse_iceberg_catalog_uri(self) -> str: self.consume_literal("(") self.consume_literal("catalog_uri") - string1234 = self.consume_terminal("STRING") + string1235 = self.consume_terminal("STRING") self.consume_literal(")") - return string1234 + return string1235 def parse_iceberg_catalog_config_scope(self) -> str: self.consume_literal("(") self.consume_literal("scope") - string1235 = self.consume_terminal("STRING") + string1236 = self.consume_terminal("STRING") self.consume_literal(")") - return string1235 + return string1236 def parse_iceberg_properties(self) -> Sequence[tuple[str, str]]: self.consume_literal("(") self.consume_literal("properties") - xs1236 = [] - cond1237 = self.match_lookahead_literal("(", 0) - while cond1237: - _t2013 = self.parse_iceberg_property_entry() - item1238 = _t2013 - xs1236.append(item1238) - cond1237 = self.match_lookahead_literal("(", 0) - iceberg_property_entrys1239 = xs1236 + xs1237 = [] + cond1238 = self.match_lookahead_literal("(", 0) + while cond1238: + _t2015 = self.parse_iceberg_property_entry() + item1239 = _t2015 + xs1237.append(item1239) + cond1238 = self.match_lookahead_literal("(", 0) + iceberg_property_entrys1240 = xs1237 self.consume_literal(")") - return iceberg_property_entrys1239 + return iceberg_property_entrys1240 def parse_iceberg_property_entry(self) -> tuple[str, str]: self.consume_literal("(") self.consume_literal("prop") - string1240 = self.consume_terminal("STRING") - string_31241 = self.consume_terminal("STRING") + string1241 = self.consume_terminal("STRING") + string_31242 = self.consume_terminal("STRING") self.consume_literal(")") - return (string1240, string_31241,) + return (string1241, string_31242,) def parse_iceberg_auth_properties(self) -> Sequence[tuple[str, str]]: self.consume_literal("(") self.consume_literal("auth_properties") - xs1242 = [] - cond1243 = self.match_lookahead_literal("(", 0) - while cond1243: - _t2014 = self.parse_iceberg_masked_property_entry() - item1244 = _t2014 - xs1242.append(item1244) - cond1243 = self.match_lookahead_literal("(", 0) - iceberg_masked_property_entrys1245 = xs1242 + xs1243 = [] + cond1244 = self.match_lookahead_literal("(", 0) + while cond1244: + _t2016 = self.parse_iceberg_masked_property_entry() + item1245 = _t2016 + xs1243.append(item1245) + cond1244 = self.match_lookahead_literal("(", 0) + iceberg_masked_property_entrys1246 = xs1243 self.consume_literal(")") - return iceberg_masked_property_entrys1245 + return iceberg_masked_property_entrys1246 def parse_iceberg_masked_property_entry(self) -> tuple[str, str]: self.consume_literal("(") self.consume_literal("prop") - string1246 = self.consume_terminal("STRING") - string_31247 = self.consume_terminal("STRING") + string1247 = self.consume_terminal("STRING") + string_31248 = self.consume_terminal("STRING") self.consume_literal(")") - return (string1246, string_31247,) + return (string1247, string_31248,) def parse_iceberg_from_snapshot(self) -> str: self.consume_literal("(") self.consume_literal("from_snapshot") - string1248 = self.consume_terminal("STRING") + string1249 = self.consume_terminal("STRING") self.consume_literal(")") - return string1248 + return string1249 def parse_iceberg_to_snapshot(self) -> str: self.consume_literal("(") self.consume_literal("to_snapshot") - string1249 = self.consume_terminal("STRING") + string1250 = self.consume_terminal("STRING") self.consume_literal(")") - return string1249 + return string1250 def parse_undefine(self) -> transactions_pb2.Undefine: - span_start1251 = self.span_start() + span_start1252 = self.span_start() self.consume_literal("(") self.consume_literal("undefine") - _t2015 = self.parse_fragment_id() - fragment_id1250 = _t2015 + _t2017 = self.parse_fragment_id() + fragment_id1251 = _t2017 self.consume_literal(")") - _t2016 = transactions_pb2.Undefine(fragment_id=fragment_id1250) - result1252 = _t2016 - self.record_span(span_start1251, "Undefine") - return result1252 + _t2018 = transactions_pb2.Undefine(fragment_id=fragment_id1251) + result1253 = _t2018 + self.record_span(span_start1252, "Undefine") + return result1253 def parse_context(self) -> transactions_pb2.Context: - span_start1257 = self.span_start() + span_start1258 = self.span_start() self.consume_literal("(") self.consume_literal("context") - xs1253 = [] - cond1254 = (self.match_lookahead_literal(":", 0) or self.match_lookahead_terminal("UINT128", 0)) - while cond1254: - _t2017 = self.parse_relation_id() - item1255 = _t2017 - xs1253.append(item1255) - cond1254 = (self.match_lookahead_literal(":", 0) or self.match_lookahead_terminal("UINT128", 0)) - relation_ids1256 = xs1253 - self.consume_literal(")") - _t2018 = transactions_pb2.Context(relations=relation_ids1256) - result1258 = _t2018 - self.record_span(span_start1257, "Context") - return result1258 + xs1254 = [] + cond1255 = (self.match_lookahead_literal(":", 0) or self.match_lookahead_terminal("UINT128", 0)) + while cond1255: + _t2019 = self.parse_relation_id() + item1256 = _t2019 + xs1254.append(item1256) + cond1255 = (self.match_lookahead_literal(":", 0) or self.match_lookahead_terminal("UINT128", 0)) + relation_ids1257 = xs1254 + self.consume_literal(")") + _t2020 = transactions_pb2.Context(relations=relation_ids1257) + result1259 = _t2020 + self.record_span(span_start1258, "Context") + return result1259 def parse_snapshot(self) -> transactions_pb2.Snapshot: - span_start1264 = self.span_start() + span_start1265 = self.span_start() self.consume_literal("(") self.consume_literal("snapshot") - _t2019 = self.parse_edb_path() - edb_path1259 = _t2019 - xs1260 = [] - cond1261 = self.match_lookahead_literal("[", 0) - while cond1261: - _t2020 = self.parse_snapshot_mapping() - item1262 = _t2020 - xs1260.append(item1262) - cond1261 = self.match_lookahead_literal("[", 0) - snapshot_mappings1263 = xs1260 - self.consume_literal(")") - _t2021 = transactions_pb2.Snapshot(prefix=edb_path1259, mappings=snapshot_mappings1263) - result1265 = _t2021 - self.record_span(span_start1264, "Snapshot") - return result1265 + _t2021 = self.parse_edb_path() + edb_path1260 = _t2021 + xs1261 = [] + cond1262 = self.match_lookahead_literal("[", 0) + while cond1262: + _t2022 = self.parse_snapshot_mapping() + item1263 = _t2022 + xs1261.append(item1263) + cond1262 = self.match_lookahead_literal("[", 0) + snapshot_mappings1264 = xs1261 + self.consume_literal(")") + _t2023 = transactions_pb2.Snapshot(prefix=edb_path1260, mappings=snapshot_mappings1264) + result1266 = _t2023 + self.record_span(span_start1265, "Snapshot") + return result1266 def parse_snapshot_mapping(self) -> transactions_pb2.SnapshotMapping: - span_start1268 = self.span_start() - _t2022 = self.parse_edb_path() - edb_path1266 = _t2022 - _t2023 = self.parse_relation_id() - relation_id1267 = _t2023 - _t2024 = transactions_pb2.SnapshotMapping(destination_path=edb_path1266, source_relation=relation_id1267) - result1269 = _t2024 - self.record_span(span_start1268, "SnapshotMapping") - return result1269 + span_start1269 = self.span_start() + _t2024 = self.parse_edb_path() + edb_path1267 = _t2024 + _t2025 = self.parse_relation_id() + relation_id1268 = _t2025 + _t2026 = transactions_pb2.SnapshotMapping(destination_path=edb_path1267, source_relation=relation_id1268) + result1270 = _t2026 + self.record_span(span_start1269, "SnapshotMapping") + return result1270 def parse_epoch_reads(self) -> Sequence[transactions_pb2.Read]: self.consume_literal("(") self.consume_literal("reads") - xs1270 = [] - cond1271 = self.match_lookahead_literal("(", 0) - while cond1271: - _t2025 = self.parse_read() - item1272 = _t2025 - xs1270.append(item1272) - cond1271 = self.match_lookahead_literal("(", 0) - reads1273 = xs1270 + xs1271 = [] + cond1272 = self.match_lookahead_literal("(", 0) + while cond1272: + _t2027 = self.parse_read() + item1273 = _t2027 + xs1271.append(item1273) + cond1272 = self.match_lookahead_literal("(", 0) + reads1274 = xs1271 self.consume_literal(")") - return reads1273 + return reads1274 def parse_read(self) -> transactions_pb2.Read: - span_start1281 = self.span_start() + span_start1282 = self.span_start() if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("what_if", 1): - _t2027 = 2 + _t2029 = 2 else: if self.match_lookahead_literal("output", 1): - _t2028 = 1 + _t2030 = 1 else: if self.match_lookahead_literal("export_output", 1): - _t2029 = 5 + _t2031 = 5 else: if self.match_lookahead_literal("export_iceberg", 1): - _t2030 = 4 + _t2032 = 4 else: if self.match_lookahead_literal("export", 1): - _t2031 = 4 + _t2033 = 4 else: if self.match_lookahead_literal("demand", 1): - _t2032 = 0 + _t2034 = 0 else: if self.match_lookahead_literal("abort", 1): - _t2033 = 3 + _t2035 = 3 else: - _t2033 = -1 - _t2032 = _t2033 - _t2031 = _t2032 - _t2030 = _t2031 - _t2029 = _t2030 - _t2028 = _t2029 - _t2027 = _t2028 - _t2026 = _t2027 - else: - _t2026 = -1 - prediction1274 = _t2026 - if prediction1274 == 5: - _t2035 = self.parse_export_output() - export_output1280 = _t2035 - _t2036 = transactions_pb2.Read(export_output=export_output1280) - _t2034 = _t2036 - else: - if prediction1274 == 4: - _t2038 = self.parse_export() - export1279 = _t2038 - _t2039 = transactions_pb2.Read(export=export1279) - _t2037 = _t2039 + _t2035 = -1 + _t2034 = _t2035 + _t2033 = _t2034 + _t2032 = _t2033 + _t2031 = _t2032 + _t2030 = _t2031 + _t2029 = _t2030 + _t2028 = _t2029 + else: + _t2028 = -1 + prediction1275 = _t2028 + if prediction1275 == 5: + _t2037 = self.parse_export_output() + export_output1281 = _t2037 + _t2038 = transactions_pb2.Read(export_output=export_output1281) + _t2036 = _t2038 + else: + if prediction1275 == 4: + _t2040 = self.parse_export() + export1280 = _t2040 + _t2041 = transactions_pb2.Read(export=export1280) + _t2039 = _t2041 else: - if prediction1274 == 3: - _t2041 = self.parse_abort() - abort1278 = _t2041 - _t2042 = transactions_pb2.Read(abort=abort1278) - _t2040 = _t2042 + if prediction1275 == 3: + _t2043 = self.parse_abort() + abort1279 = _t2043 + _t2044 = transactions_pb2.Read(abort=abort1279) + _t2042 = _t2044 else: - if prediction1274 == 2: - _t2044 = self.parse_what_if() - what_if1277 = _t2044 - _t2045 = transactions_pb2.Read(what_if=what_if1277) - _t2043 = _t2045 + if prediction1275 == 2: + _t2046 = self.parse_what_if() + what_if1278 = _t2046 + _t2047 = transactions_pb2.Read(what_if=what_if1278) + _t2045 = _t2047 else: - if prediction1274 == 1: - _t2047 = self.parse_output() - output1276 = _t2047 - _t2048 = transactions_pb2.Read(output=output1276) - _t2046 = _t2048 + if prediction1275 == 1: + _t2049 = self.parse_output() + output1277 = _t2049 + _t2050 = transactions_pb2.Read(output=output1277) + _t2048 = _t2050 else: - if prediction1274 == 0: - _t2050 = self.parse_demand() - demand1275 = _t2050 - _t2051 = transactions_pb2.Read(demand=demand1275) - _t2049 = _t2051 + if prediction1275 == 0: + _t2052 = self.parse_demand() + demand1276 = _t2052 + _t2053 = transactions_pb2.Read(demand=demand1276) + _t2051 = _t2053 else: raise ParseError("Unexpected token in read" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t2046 = _t2049 - _t2043 = _t2046 - _t2040 = _t2043 - _t2037 = _t2040 - _t2034 = _t2037 - result1282 = _t2034 - self.record_span(span_start1281, "Read") - return result1282 + _t2048 = _t2051 + _t2045 = _t2048 + _t2042 = _t2045 + _t2039 = _t2042 + _t2036 = _t2039 + result1283 = _t2036 + self.record_span(span_start1282, "Read") + return result1283 def parse_demand(self) -> transactions_pb2.Demand: - span_start1284 = self.span_start() + span_start1285 = self.span_start() self.consume_literal("(") self.consume_literal("demand") - _t2052 = self.parse_relation_id() - relation_id1283 = _t2052 + _t2054 = self.parse_relation_id() + relation_id1284 = _t2054 self.consume_literal(")") - _t2053 = transactions_pb2.Demand(relation_id=relation_id1283) - result1285 = _t2053 - self.record_span(span_start1284, "Demand") - return result1285 + _t2055 = transactions_pb2.Demand(relation_id=relation_id1284) + result1286 = _t2055 + self.record_span(span_start1285, "Demand") + return result1286 def parse_output(self) -> transactions_pb2.Output: - span_start1288 = self.span_start() + span_start1289 = self.span_start() self.consume_literal("(") self.consume_literal("output") - _t2054 = self.parse_name() - name1286 = _t2054 - _t2055 = self.parse_relation_id() - relation_id1287 = _t2055 + _t2056 = self.parse_name() + name1287 = _t2056 + _t2057 = self.parse_relation_id() + relation_id1288 = _t2057 self.consume_literal(")") - _t2056 = transactions_pb2.Output(name=name1286, relation_id=relation_id1287) - result1289 = _t2056 - self.record_span(span_start1288, "Output") - return result1289 + _t2058 = transactions_pb2.Output(name=name1287, relation_id=relation_id1288) + result1290 = _t2058 + self.record_span(span_start1289, "Output") + return result1290 def parse_what_if(self) -> transactions_pb2.WhatIf: - span_start1292 = self.span_start() + span_start1293 = self.span_start() self.consume_literal("(") self.consume_literal("what_if") - _t2057 = self.parse_name() - name1290 = _t2057 - _t2058 = self.parse_epoch() - epoch1291 = _t2058 + _t2059 = self.parse_name() + name1291 = _t2059 + _t2060 = self.parse_epoch() + epoch1292 = _t2060 self.consume_literal(")") - _t2059 = transactions_pb2.WhatIf(branch=name1290, epoch=epoch1291) - result1293 = _t2059 - self.record_span(span_start1292, "WhatIf") - return result1293 + _t2061 = transactions_pb2.WhatIf(branch=name1291, epoch=epoch1292) + result1294 = _t2061 + self.record_span(span_start1293, "WhatIf") + return result1294 def parse_abort(self) -> transactions_pb2.Abort: - span_start1296 = self.span_start() + span_start1297 = self.span_start() self.consume_literal("(") self.consume_literal("abort") if (self.match_lookahead_literal(":", 0) and self.match_lookahead_terminal("SYMBOL", 1)): - _t2061 = self.parse_name() - _t2060 = _t2061 + _t2063 = self.parse_name() + _t2062 = _t2063 else: - _t2060 = None - name1294 = _t2060 - _t2062 = self.parse_relation_id() - relation_id1295 = _t2062 + _t2062 = None + name1295 = _t2062 + _t2064 = self.parse_relation_id() + relation_id1296 = _t2064 self.consume_literal(")") - _t2063 = transactions_pb2.Abort(name=(name1294 if name1294 is not None else "abort"), relation_id=relation_id1295) - result1297 = _t2063 - self.record_span(span_start1296, "Abort") - return result1297 + _t2065 = transactions_pb2.Abort(name=(name1295 if name1295 is not None else "abort"), relation_id=relation_id1296) + result1298 = _t2065 + self.record_span(span_start1297, "Abort") + return result1298 def parse_export(self) -> transactions_pb2.Export: - span_start1301 = self.span_start() + span_start1302 = self.span_start() if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("export_iceberg", 1): - _t2065 = 1 + _t2067 = 1 else: if self.match_lookahead_literal("export", 1): - _t2066 = 0 + _t2068 = 0 else: - _t2066 = -1 - _t2065 = _t2066 - _t2064 = _t2065 + _t2068 = -1 + _t2067 = _t2068 + _t2066 = _t2067 else: - _t2064 = -1 - prediction1298 = _t2064 - if prediction1298 == 1: + _t2066 = -1 + prediction1299 = _t2066 + if prediction1299 == 1: self.consume_literal("(") self.consume_literal("export_iceberg") - _t2068 = self.parse_export_iceberg_config() - export_iceberg_config1300 = _t2068 + _t2070 = self.parse_export_iceberg_config() + export_iceberg_config1301 = _t2070 self.consume_literal(")") - _t2069 = transactions_pb2.Export(iceberg_config=export_iceberg_config1300) - _t2067 = _t2069 + _t2071 = transactions_pb2.Export(iceberg_config=export_iceberg_config1301) + _t2069 = _t2071 else: - if prediction1298 == 0: + if prediction1299 == 0: self.consume_literal("(") self.consume_literal("export") - _t2071 = self.parse_export_csv_config() - export_csv_config1299 = _t2071 + _t2073 = self.parse_export_csv_config() + export_csv_config1300 = _t2073 self.consume_literal(")") - _t2072 = transactions_pb2.Export(csv_config=export_csv_config1299) - _t2070 = _t2072 + _t2074 = transactions_pb2.Export(csv_config=export_csv_config1300) + _t2072 = _t2074 else: raise ParseError("Unexpected token in export" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t2067 = _t2070 - result1302 = _t2067 - self.record_span(span_start1301, "Export") - return result1302 + _t2069 = _t2072 + result1303 = _t2069 + self.record_span(span_start1302, "Export") + return result1303 def parse_export_csv_config(self) -> transactions_pb2.ExportCSVConfig: - span_start1310 = self.span_start() + span_start1311 = self.span_start() if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("export_csv_config_v2", 1): - _t2074 = 0 + _t2076 = 0 else: if self.match_lookahead_literal("export_csv_config", 1): - _t2075 = 1 + _t2077 = 1 else: - _t2075 = -1 - _t2074 = _t2075 - _t2073 = _t2074 + _t2077 = -1 + _t2076 = _t2077 + _t2075 = _t2076 else: - _t2073 = -1 - prediction1303 = _t2073 - if prediction1303 == 1: + _t2075 = -1 + prediction1304 = _t2075 + if prediction1304 == 1: self.consume_literal("(") self.consume_literal("export_csv_config") - _t2077 = self.parse_export_csv_path() - export_csv_path1307 = _t2077 - _t2078 = self.parse_export_csv_columns_list() - export_csv_columns_list1308 = _t2078 - _t2079 = self.parse_config_dict() - config_dict1309 = _t2079 + _t2079 = self.parse_export_csv_path() + export_csv_path1308 = _t2079 + _t2080 = self.parse_export_csv_columns_list() + export_csv_columns_list1309 = _t2080 + _t2081 = self.parse_config_dict() + config_dict1310 = _t2081 self.consume_literal(")") - _t2080 = self.construct_export_csv_config(export_csv_path1307, export_csv_columns_list1308, config_dict1309) - _t2076 = _t2080 + _t2082 = self.construct_export_csv_config(export_csv_path1308, export_csv_columns_list1309, config_dict1310) + _t2078 = _t2082 else: - if prediction1303 == 0: + if prediction1304 == 0: self.consume_literal("(") self.consume_literal("export_csv_config_v2") - _t2082 = self.parse_export_csv_path() - export_csv_path1304 = _t2082 - _t2083 = self.parse_export_csv_source() - export_csv_source1305 = _t2083 - _t2084 = self.parse_csv_config() - csv_config1306 = _t2084 + _t2084 = self.parse_export_csv_path() + export_csv_path1305 = _t2084 + _t2085 = self.parse_export_csv_source() + export_csv_source1306 = _t2085 + _t2086 = self.parse_csv_config() + csv_config1307 = _t2086 self.consume_literal(")") - _t2085 = self.construct_export_csv_config_with_source(export_csv_path1304, export_csv_source1305, csv_config1306) - _t2081 = _t2085 + _t2087 = self.construct_export_csv_config_with_source(export_csv_path1305, export_csv_source1306, csv_config1307) + _t2083 = _t2087 else: raise ParseError("Unexpected token in export_csv_config" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t2076 = _t2081 - result1311 = _t2076 - self.record_span(span_start1310, "ExportCSVConfig") - return result1311 + _t2078 = _t2083 + result1312 = _t2078 + self.record_span(span_start1311, "ExportCSVConfig") + return result1312 def parse_export_csv_path(self) -> str: self.consume_literal("(") self.consume_literal("path") - string1312 = self.consume_terminal("STRING") + string1313 = self.consume_terminal("STRING") self.consume_literal(")") - return string1312 + return string1313 def parse_export_csv_source(self) -> transactions_pb2.ExportCSVSource: - span_start1319 = self.span_start() + span_start1320 = self.span_start() if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("table_def", 1): - _t2087 = 1 + _t2089 = 1 else: if self.match_lookahead_literal("gnf_columns", 1): - _t2088 = 0 + _t2090 = 0 else: - _t2088 = -1 - _t2087 = _t2088 - _t2086 = _t2087 + _t2090 = -1 + _t2089 = _t2090 + _t2088 = _t2089 else: - _t2086 = -1 - prediction1313 = _t2086 - if prediction1313 == 1: + _t2088 = -1 + prediction1314 = _t2088 + if prediction1314 == 1: self.consume_literal("(") self.consume_literal("table_def") - _t2090 = self.parse_relation_id() - relation_id1318 = _t2090 + _t2092 = self.parse_relation_id() + relation_id1319 = _t2092 self.consume_literal(")") - _t2091 = transactions_pb2.ExportCSVSource(table_def=relation_id1318) - _t2089 = _t2091 + _t2093 = transactions_pb2.ExportCSVSource(table_def=relation_id1319) + _t2091 = _t2093 else: - if prediction1313 == 0: + if prediction1314 == 0: self.consume_literal("(") self.consume_literal("gnf_columns") - xs1314 = [] - cond1315 = self.match_lookahead_literal("(", 0) - while cond1315: - _t2093 = self.parse_export_csv_column() - item1316 = _t2093 - xs1314.append(item1316) - cond1315 = self.match_lookahead_literal("(", 0) - export_csv_columns1317 = xs1314 + xs1315 = [] + cond1316 = self.match_lookahead_literal("(", 0) + while cond1316: + _t2095 = self.parse_export_csv_column() + item1317 = _t2095 + xs1315.append(item1317) + cond1316 = self.match_lookahead_literal("(", 0) + export_csv_columns1318 = xs1315 self.consume_literal(")") - _t2094 = transactions_pb2.ExportCSVColumns(columns=export_csv_columns1317) - _t2095 = transactions_pb2.ExportCSVSource(gnf_columns=_t2094) - _t2092 = _t2095 + _t2096 = transactions_pb2.ExportCSVColumns(columns=export_csv_columns1318) + _t2097 = transactions_pb2.ExportCSVSource(gnf_columns=_t2096) + _t2094 = _t2097 else: raise ParseError("Unexpected token in export_csv_source" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t2089 = _t2092 - result1320 = _t2089 - self.record_span(span_start1319, "ExportCSVSource") - return result1320 + _t2091 = _t2094 + result1321 = _t2091 + self.record_span(span_start1320, "ExportCSVSource") + return result1321 def parse_export_csv_column(self) -> transactions_pb2.ExportCSVColumn: - span_start1323 = self.span_start() + span_start1324 = self.span_start() self.consume_literal("(") self.consume_literal("column") - string1321 = self.consume_terminal("STRING") - _t2096 = self.parse_relation_id() - relation_id1322 = _t2096 + string1322 = self.consume_terminal("STRING") + _t2098 = self.parse_relation_id() + relation_id1323 = _t2098 self.consume_literal(")") - _t2097 = transactions_pb2.ExportCSVColumn(column_name=string1321, column_data=relation_id1322) - result1324 = _t2097 - self.record_span(span_start1323, "ExportCSVColumn") - return result1324 + _t2099 = transactions_pb2.ExportCSVColumn(column_name=string1322, column_data=relation_id1323) + result1325 = _t2099 + self.record_span(span_start1324, "ExportCSVColumn") + return result1325 def parse_export_csv_columns_list(self) -> Sequence[transactions_pb2.ExportCSVColumn]: self.consume_literal("(") self.consume_literal("columns") - xs1325 = [] - cond1326 = self.match_lookahead_literal("(", 0) - while cond1326: - _t2098 = self.parse_export_csv_column() - item1327 = _t2098 - xs1325.append(item1327) - cond1326 = self.match_lookahead_literal("(", 0) - export_csv_columns1328 = xs1325 + xs1326 = [] + cond1327 = self.match_lookahead_literal("(", 0) + while cond1327: + _t2100 = self.parse_export_csv_column() + item1328 = _t2100 + xs1326.append(item1328) + cond1327 = self.match_lookahead_literal("(", 0) + export_csv_columns1329 = xs1326 self.consume_literal(")") - return export_csv_columns1328 + return export_csv_columns1329 def parse_export_iceberg_config(self) -> transactions_pb2.ExportIcebergConfig: - span_start1334 = self.span_start() + span_start1335 = self.span_start() self.consume_literal("(") self.consume_literal("export_iceberg_config") - _t2099 = self.parse_iceberg_locator() - iceberg_locator1329 = _t2099 - _t2100 = self.parse_iceberg_catalog_config() - iceberg_catalog_config1330 = _t2100 - _t2101 = self.parse_export_iceberg_table_def() - export_iceberg_table_def1331 = _t2101 - _t2102 = self.parse_iceberg_table_properties() - iceberg_table_properties1332 = _t2102 + _t2101 = self.parse_iceberg_locator() + iceberg_locator1330 = _t2101 + _t2102 = self.parse_iceberg_catalog_config() + iceberg_catalog_config1331 = _t2102 + _t2103 = self.parse_export_iceberg_table_def() + export_iceberg_table_def1332 = _t2103 + _t2104 = self.parse_iceberg_table_properties() + iceberg_table_properties1333 = _t2104 if self.match_lookahead_literal("{", 0): - _t2104 = self.parse_config_dict() - _t2103 = _t2104 + _t2106 = self.parse_config_dict() + _t2105 = _t2106 else: - _t2103 = None - config_dict1333 = _t2103 + _t2105 = None + config_dict1334 = _t2105 self.consume_literal(")") - _t2105 = self.construct_export_iceberg_config_full(iceberg_locator1329, iceberg_catalog_config1330, export_iceberg_table_def1331, iceberg_table_properties1332, config_dict1333) - result1335 = _t2105 - self.record_span(span_start1334, "ExportIcebergConfig") - return result1335 + _t2107 = self.construct_export_iceberg_config_full(iceberg_locator1330, iceberg_catalog_config1331, export_iceberg_table_def1332, iceberg_table_properties1333, config_dict1334) + result1336 = _t2107 + self.record_span(span_start1335, "ExportIcebergConfig") + return result1336 def parse_export_iceberg_table_def(self) -> logic_pb2.RelationId: - span_start1337 = self.span_start() + span_start1338 = self.span_start() self.consume_literal("(") self.consume_literal("table_def") - _t2106 = self.parse_relation_id() - relation_id1336 = _t2106 + _t2108 = self.parse_relation_id() + relation_id1337 = _t2108 self.consume_literal(")") - result1338 = relation_id1336 - self.record_span(span_start1337, "RelationId") - return result1338 + result1339 = relation_id1337 + self.record_span(span_start1338, "RelationId") + return result1339 def parse_iceberg_table_properties(self) -> Sequence[tuple[str, str]]: self.consume_literal("(") self.consume_literal("table_properties") - xs1339 = [] - cond1340 = self.match_lookahead_literal("(", 0) - while cond1340: - _t2107 = self.parse_iceberg_property_entry() - item1341 = _t2107 - xs1339.append(item1341) - cond1340 = self.match_lookahead_literal("(", 0) - iceberg_property_entrys1342 = xs1339 + xs1340 = [] + cond1341 = self.match_lookahead_literal("(", 0) + while cond1341: + _t2109 = self.parse_iceberg_property_entry() + item1342 = _t2109 + xs1340.append(item1342) + cond1341 = self.match_lookahead_literal("(", 0) + iceberg_property_entrys1343 = xs1340 self.consume_literal(")") - return iceberg_property_entrys1342 + return iceberg_property_entrys1343 def parse_export_output(self) -> transactions_pb2.ExportOutput: - span_start1344 = self.span_start() + span_start1346 = self.span_start() self.consume_literal("(") self.consume_literal("export_output") - _t2108 = self.parse_export_csv_output() - export_csv_output1343 = _t2108 + _t2110 = self.parse_name() + name1344 = _t2110 + _t2111 = self.parse_export_csv_output() + export_csv_output1345 = _t2111 self.consume_literal(")") - _t2109 = transactions_pb2.ExportOutput(csv=export_csv_output1343) - result1345 = _t2109 - self.record_span(span_start1344, "ExportOutput") - return result1345 + _t2112 = transactions_pb2.ExportOutput(name=name1344, csv=export_csv_output1345) + result1347 = _t2112 + self.record_span(span_start1346, "ExportOutput") + return result1347 def parse_export_csv_output(self) -> transactions_pb2.ExportCSVOutput: - span_start1348 = self.span_start() + span_start1350 = self.span_start() self.consume_literal("(") self.consume_literal("csv") - _t2110 = self.parse_export_csv_source() - export_csv_source1346 = _t2110 - _t2111 = self.parse_csv_config() - csv_config1347 = _t2111 - self.consume_literal(")") - _t2112 = transactions_pb2.ExportCSVOutput(csv_source=export_csv_source1346, csv_config=csv_config1347) - result1349 = _t2112 - self.record_span(span_start1348, "ExportCSVOutput") - return result1349 + _t2113 = self.parse_export_csv_source() + export_csv_source1348 = _t2113 + _t2114 = self.parse_csv_config() + csv_config1349 = _t2114 + self.consume_literal(")") + _t2115 = transactions_pb2.ExportCSVOutput(csv_source=export_csv_source1348, csv_config=csv_config1349) + result1351 = _t2115 + self.record_span(span_start1350, "ExportCSVOutput") + return result1351 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 ec5ce3b5..22a6f25c 100644 --- a/sdks/python/src/lqp/gen/pretty.py +++ b/sdks/python/src/lqp/gen/pretty.py @@ -217,159 +217,159 @@ def write_debug_info(self) -> None: # --- Helper functions --- def _make_value_int32(self, v: int) -> logic_pb2.Value: - _t1764 = logic_pb2.Value(int32_value=v) - return _t1764 + _t1768 = logic_pb2.Value(int32_value=v) + return _t1768 def _make_value_int64(self, v: int) -> logic_pb2.Value: - _t1765 = logic_pb2.Value(int_value=v) - return _t1765 + _t1769 = logic_pb2.Value(int_value=v) + return _t1769 def _make_value_float64(self, v: float) -> logic_pb2.Value: - _t1766 = logic_pb2.Value(float_value=v) - return _t1766 + _t1770 = logic_pb2.Value(float_value=v) + return _t1770 def _make_value_string(self, v: str) -> logic_pb2.Value: - _t1767 = logic_pb2.Value(string_value=v) - return _t1767 + _t1771 = logic_pb2.Value(string_value=v) + return _t1771 def _make_value_boolean(self, v: bool) -> logic_pb2.Value: - _t1768 = logic_pb2.Value(boolean_value=v) - return _t1768 + _t1772 = logic_pb2.Value(boolean_value=v) + return _t1772 def _make_value_uint128(self, v: logic_pb2.UInt128Value) -> logic_pb2.Value: - _t1769 = logic_pb2.Value(uint128_value=v) - return _t1769 + _t1773 = logic_pb2.Value(uint128_value=v) + return _t1773 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: - _t1770 = self._make_value_string("auto") - result.append(("ivm.maintenance_level", _t1770,)) + _t1774 = self._make_value_string("auto") + result.append(("ivm.maintenance_level", _t1774,)) else: if msg.ivm_config.level == transactions_pb2.MaintenanceLevel.MAINTENANCE_LEVEL_ALL: - _t1771 = self._make_value_string("all") - result.append(("ivm.maintenance_level", _t1771,)) + _t1775 = self._make_value_string("all") + result.append(("ivm.maintenance_level", _t1775,)) else: if msg.ivm_config.level == transactions_pb2.MaintenanceLevel.MAINTENANCE_LEVEL_OFF: - _t1772 = self._make_value_string("off") - result.append(("ivm.maintenance_level", _t1772,)) - _t1773 = self._make_value_int64(msg.semantics_version) - result.append(("semantics_version", _t1773,)) + _t1776 = self._make_value_string("off") + result.append(("ivm.maintenance_level", _t1776,)) + _t1777 = self._make_value_int64(msg.semantics_version) + result.append(("semantics_version", _t1777,)) return sorted(result) def deconstruct_csv_config(self, msg: logic_pb2.CSVConfig) -> list[tuple[str, logic_pb2.Value]]: result = [] - _t1774 = self._make_value_int32(msg.header_row) - result.append(("csv_header_row", _t1774,)) - _t1775 = self._make_value_int64(msg.skip) - result.append(("csv_skip", _t1775,)) + _t1778 = self._make_value_int32(msg.header_row) + result.append(("csv_header_row", _t1778,)) + _t1779 = self._make_value_int64(msg.skip) + result.append(("csv_skip", _t1779,)) if msg.new_line != "": - _t1776 = self._make_value_string(msg.new_line) - result.append(("csv_new_line", _t1776,)) - _t1777 = self._make_value_string(msg.delimiter) - result.append(("csv_delimiter", _t1777,)) - _t1778 = self._make_value_string(msg.quotechar) - result.append(("csv_quotechar", _t1778,)) - _t1779 = self._make_value_string(msg.escapechar) - result.append(("csv_escapechar", _t1779,)) + _t1780 = self._make_value_string(msg.new_line) + result.append(("csv_new_line", _t1780,)) + _t1781 = self._make_value_string(msg.delimiter) + result.append(("csv_delimiter", _t1781,)) + _t1782 = self._make_value_string(msg.quotechar) + result.append(("csv_quotechar", _t1782,)) + _t1783 = self._make_value_string(msg.escapechar) + result.append(("csv_escapechar", _t1783,)) if msg.comment != "": - _t1780 = self._make_value_string(msg.comment) - result.append(("csv_comment", _t1780,)) + _t1784 = self._make_value_string(msg.comment) + result.append(("csv_comment", _t1784,)) for missing_string in msg.missing_strings: - _t1781 = self._make_value_string(missing_string) - result.append(("csv_missing_strings", _t1781,)) - _t1782 = self._make_value_string(msg.decimal_separator) - result.append(("csv_decimal_separator", _t1782,)) - _t1783 = self._make_value_string(msg.encoding) - result.append(("csv_encoding", _t1783,)) - _t1784 = self._make_value_string(msg.compression) - result.append(("csv_compression", _t1784,)) + _t1785 = self._make_value_string(missing_string) + result.append(("csv_missing_strings", _t1785,)) + _t1786 = self._make_value_string(msg.decimal_separator) + result.append(("csv_decimal_separator", _t1786,)) + _t1787 = self._make_value_string(msg.encoding) + result.append(("csv_encoding", _t1787,)) + _t1788 = self._make_value_string(msg.compression) + result.append(("csv_compression", _t1788,)) if msg.partition_size_mb != 0: - _t1785 = self._make_value_int64(msg.partition_size_mb) - result.append(("csv_partition_size_mb", _t1785,)) + _t1789 = self._make_value_int64(msg.partition_size_mb) + result.append(("csv_partition_size_mb", _t1789,)) 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: - _t1786 = None + _t1790 = None assert msg.storage_integration is not None si = msg.storage_integration result = [] if si.provider != "": - _t1787 = self._make_value_string(si.provider) - result.append(("provider", _t1787,)) + _t1791 = self._make_value_string(si.provider) + result.append(("provider", _t1791,)) if si.azure_sas_token != "": - _t1788 = self._make_value_string("***") - result.append(("azure_sas_token", _t1788,)) + _t1792 = self._make_value_string("***") + result.append(("azure_sas_token", _t1792,)) if si.s3_region != "": - _t1789 = self._make_value_string(si.s3_region) - result.append(("s3_region", _t1789,)) + _t1793 = self._make_value_string(si.s3_region) + result.append(("s3_region", _t1793,)) if si.s3_access_key_id != "": - _t1790 = self._make_value_string("***") - result.append(("s3_access_key_id", _t1790,)) + _t1794 = self._make_value_string("***") + result.append(("s3_access_key_id", _t1794,)) if si.s3_secret_access_key != "": - _t1791 = self._make_value_string("***") - result.append(("s3_secret_access_key", _t1791,)) + _t1795 = self._make_value_string("***") + result.append(("s3_secret_access_key", _t1795,)) return sorted(result) def deconstruct_betree_info_config(self, msg: logic_pb2.BeTreeInfo) -> list[tuple[str, logic_pb2.Value]]: result = [] - _t1792 = self._make_value_float64(msg.storage_config.epsilon) - result.append(("betree_config_epsilon", _t1792,)) - _t1793 = self._make_value_int64(msg.storage_config.max_pivots) - result.append(("betree_config_max_pivots", _t1793,)) - _t1794 = self._make_value_int64(msg.storage_config.max_deltas) - result.append(("betree_config_max_deltas", _t1794,)) - _t1795 = self._make_value_int64(msg.storage_config.max_leaf) - result.append(("betree_config_max_leaf", _t1795,)) + _t1796 = self._make_value_float64(msg.storage_config.epsilon) + result.append(("betree_config_epsilon", _t1796,)) + _t1797 = self._make_value_int64(msg.storage_config.max_pivots) + result.append(("betree_config_max_pivots", _t1797,)) + _t1798 = self._make_value_int64(msg.storage_config.max_deltas) + result.append(("betree_config_max_deltas", _t1798,)) + _t1799 = self._make_value_int64(msg.storage_config.max_leaf) + result.append(("betree_config_max_leaf", _t1799,)) 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 - _t1796 = self._make_value_uint128(msg.relation_locator.root_pageid) - result.append(("betree_locator_root_pageid", _t1796,)) + _t1800 = self._make_value_uint128(msg.relation_locator.root_pageid) + result.append(("betree_locator_root_pageid", _t1800,)) 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 - _t1797 = self._make_value_string(msg.relation_locator.inline_data.decode('utf-8')) - result.append(("betree_locator_inline_data", _t1797,)) - _t1798 = self._make_value_int64(msg.relation_locator.element_count) - result.append(("betree_locator_element_count", _t1798,)) - _t1799 = self._make_value_int64(msg.relation_locator.tree_height) - result.append(("betree_locator_tree_height", _t1799,)) + _t1801 = self._make_value_string(msg.relation_locator.inline_data.decode('utf-8')) + result.append(("betree_locator_inline_data", _t1801,)) + _t1802 = self._make_value_int64(msg.relation_locator.element_count) + result.append(("betree_locator_element_count", _t1802,)) + _t1803 = self._make_value_int64(msg.relation_locator.tree_height) + result.append(("betree_locator_tree_height", _t1803,)) 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 - _t1800 = self._make_value_int64(msg.partition_size) - result.append(("partition_size", _t1800,)) + _t1804 = self._make_value_int64(msg.partition_size) + result.append(("partition_size", _t1804,)) if msg.compression is not None: assert msg.compression is not None - _t1801 = self._make_value_string(msg.compression) - result.append(("compression", _t1801,)) + _t1805 = self._make_value_string(msg.compression) + result.append(("compression", _t1805,)) if msg.syntax_header_row is not None: assert msg.syntax_header_row is not None - _t1802 = self._make_value_boolean(msg.syntax_header_row) - result.append(("syntax_header_row", _t1802,)) + _t1806 = self._make_value_boolean(msg.syntax_header_row) + result.append(("syntax_header_row", _t1806,)) if msg.syntax_missing_string is not None: assert msg.syntax_missing_string is not None - _t1803 = self._make_value_string(msg.syntax_missing_string) - result.append(("syntax_missing_string", _t1803,)) + _t1807 = self._make_value_string(msg.syntax_missing_string) + result.append(("syntax_missing_string", _t1807,)) if msg.syntax_delim is not None: assert msg.syntax_delim is not None - _t1804 = self._make_value_string(msg.syntax_delim) - result.append(("syntax_delim", _t1804,)) + _t1808 = self._make_value_string(msg.syntax_delim) + result.append(("syntax_delim", _t1808,)) if msg.syntax_quotechar is not None: assert msg.syntax_quotechar is not None - _t1805 = self._make_value_string(msg.syntax_quotechar) - result.append(("syntax_quotechar", _t1805,)) + _t1809 = self._make_value_string(msg.syntax_quotechar) + result.append(("syntax_quotechar", _t1809,)) if msg.syntax_escapechar is not None: assert msg.syntax_escapechar is not None - _t1806 = self._make_value_string(msg.syntax_escapechar) - result.append(("syntax_escapechar", _t1806,)) + _t1810 = self._make_value_string(msg.syntax_escapechar) + result.append(("syntax_escapechar", _t1810,)) return sorted(result) def mask_secret_value(self, pair: tuple[str, str]) -> str: @@ -381,7 +381,7 @@ def deconstruct_iceberg_catalog_config_scope_optional(self, msg: logic_pb2.Icebe assert msg.scope is not None return msg.scope else: - _t1807 = None + _t1811 = None return None def deconstruct_iceberg_data_from_snapshot_optional(self, msg: logic_pb2.IcebergData) -> str | None: @@ -390,7 +390,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: - _t1808 = None + _t1812 = None return None def deconstruct_iceberg_data_to_snapshot_optional(self, msg: logic_pb2.IcebergData) -> str | None: @@ -399,7 +399,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: - _t1809 = None + _t1813 = None return None def deconstruct_export_iceberg_config_optional(self, msg: transactions_pb2.ExportIcebergConfig) -> Sequence[tuple[str, logic_pb2.Value]] | None: @@ -407,20 +407,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 - _t1810 = self._make_value_string(msg.prefix) - result.append(("prefix", _t1810,)) + _t1814 = self._make_value_string(msg.prefix) + result.append(("prefix", _t1814,)) 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 - _t1811 = self._make_value_int64(msg.target_file_size_bytes) - result.append(("target_file_size_bytes", _t1811,)) + _t1815 = self._make_value_int64(msg.target_file_size_bytes) + result.append(("target_file_size_bytes", _t1815,)) if msg.compression != "": - _t1812 = self._make_value_string(msg.compression) - result.append(("compression", _t1812,)) + _t1816 = self._make_value_string(msg.compression) + result.append(("compression", _t1816,)) if len(result) == 0: return None else: - _t1813 = None + _t1817 = None return sorted(result) def deconstruct_relation_id_string(self, msg: logic_pb2.RelationId) -> str: @@ -433,7 +433,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: - _t1814 = None + _t1818 = None return None def deconstruct_bindings(self, abs: logic_pb2.Abstraction) -> tuple[Sequence[logic_pb2.Binding], Sequence[logic_pb2.Binding]]: @@ -448,3991 +448,3995 @@ def deconstruct_bindings_with_arity(self, abs: logic_pb2.Abstraction, value_arit # --- Pretty-print methods --- def pretty_transaction(self, msg: transactions_pb2.Transaction): - flat818 = self._try_flat(msg, self.pretty_transaction) - if flat818 is not None: - assert flat818 is not None - self.write(flat818) + flat820 = self._try_flat(msg, self.pretty_transaction) + if flat820 is not None: + assert flat820 is not None + self.write(flat820) return None else: _dollar_dollar = msg if _dollar_dollar.HasField("configure"): - _t1618 = _dollar_dollar.configure + _t1622 = _dollar_dollar.configure else: - _t1618 = None + _t1622 = None if _dollar_dollar.HasField("sync"): - _t1619 = _dollar_dollar.sync + _t1623 = _dollar_dollar.sync else: - _t1619 = None - fields809 = (_t1618, _t1619, _dollar_dollar.epochs,) - assert fields809 is not None - unwrapped_fields810 = fields809 + _t1623 = None + fields811 = (_t1622, _t1623, _dollar_dollar.epochs,) + assert fields811 is not None + unwrapped_fields812 = fields811 self.write("(transaction") self.indent_sexp() - field811 = unwrapped_fields810[0] - if field811 is not None: - self.newline() - assert field811 is not None - opt_val812 = field811 - self.pretty_configure(opt_val812) - field813 = unwrapped_fields810[1] + field813 = unwrapped_fields812[0] if field813 is not None: self.newline() assert field813 is not None opt_val814 = field813 - self.pretty_sync(opt_val814) - field815 = unwrapped_fields810[2] - if not len(field815) == 0: + self.pretty_configure(opt_val814) + field815 = unwrapped_fields812[1] + if field815 is not None: self.newline() - for i817, elem816 in enumerate(field815): - if (i817 > 0): + assert field815 is not None + opt_val816 = field815 + self.pretty_sync(opt_val816) + field817 = unwrapped_fields812[2] + if not len(field817) == 0: + self.newline() + for i819, elem818 in enumerate(field817): + if (i819 > 0): self.newline() - self.pretty_epoch(elem816) + self.pretty_epoch(elem818) self.dedent() self.write(")") def pretty_configure(self, msg: transactions_pb2.Configure): - flat821 = self._try_flat(msg, self.pretty_configure) - if flat821 is not None: - assert flat821 is not None - self.write(flat821) + flat823 = self._try_flat(msg, self.pretty_configure) + if flat823 is not None: + assert flat823 is not None + self.write(flat823) return None else: _dollar_dollar = msg - _t1620 = self.deconstruct_configure(_dollar_dollar) - fields819 = _t1620 - assert fields819 is not None - unwrapped_fields820 = fields819 + _t1624 = self.deconstruct_configure(_dollar_dollar) + fields821 = _t1624 + assert fields821 is not None + unwrapped_fields822 = fields821 self.write("(configure") self.indent_sexp() self.newline() - self.pretty_config_dict(unwrapped_fields820) + self.pretty_config_dict(unwrapped_fields822) self.dedent() self.write(")") def pretty_config_dict(self, msg: Sequence[tuple[str, logic_pb2.Value]]): - flat825 = self._try_flat(msg, self.pretty_config_dict) - if flat825 is not None: - assert flat825 is not None - self.write(flat825) + flat827 = self._try_flat(msg, self.pretty_config_dict) + if flat827 is not None: + assert flat827 is not None + self.write(flat827) return None else: - fields822 = msg + fields824 = msg self.write("{") self.indent() - if not len(fields822) == 0: + if not len(fields824) == 0: self.newline() - for i824, elem823 in enumerate(fields822): - if (i824 > 0): + for i826, elem825 in enumerate(fields824): + if (i826 > 0): self.newline() - self.pretty_config_key_value(elem823) + self.pretty_config_key_value(elem825) self.dedent() self.write("}") def pretty_config_key_value(self, msg: tuple[str, logic_pb2.Value]): - flat830 = self._try_flat(msg, self.pretty_config_key_value) - if flat830 is not None: - assert flat830 is not None - self.write(flat830) + flat832 = self._try_flat(msg, self.pretty_config_key_value) + if flat832 is not None: + assert flat832 is not None + self.write(flat832) return None else: _dollar_dollar = msg - fields826 = (_dollar_dollar[0], _dollar_dollar[1],) - assert fields826 is not None - unwrapped_fields827 = fields826 + fields828 = (_dollar_dollar[0], _dollar_dollar[1],) + assert fields828 is not None + unwrapped_fields829 = fields828 self.write(":") - field828 = unwrapped_fields827[0] - self.write(field828) + field830 = unwrapped_fields829[0] + self.write(field830) self.write(" ") - field829 = unwrapped_fields827[1] - self.pretty_raw_value(field829) + field831 = unwrapped_fields829[1] + self.pretty_raw_value(field831) def pretty_raw_value(self, msg: logic_pb2.Value): - flat856 = self._try_flat(msg, self.pretty_raw_value) - if flat856 is not None: - assert flat856 is not None - self.write(flat856) + flat858 = self._try_flat(msg, self.pretty_raw_value) + if flat858 is not None: + assert flat858 is not None + self.write(flat858) return None else: _dollar_dollar = msg if _dollar_dollar.HasField("date_value"): - _t1621 = _dollar_dollar.date_value + _t1625 = _dollar_dollar.date_value else: - _t1621 = None - deconstruct_result854 = _t1621 - if deconstruct_result854 is not None: - assert deconstruct_result854 is not None - unwrapped855 = deconstruct_result854 - self.pretty_raw_date(unwrapped855) + _t1625 = None + deconstruct_result856 = _t1625 + if deconstruct_result856 is not None: + assert deconstruct_result856 is not None + unwrapped857 = deconstruct_result856 + self.pretty_raw_date(unwrapped857) else: _dollar_dollar = msg if _dollar_dollar.HasField("datetime_value"): - _t1622 = _dollar_dollar.datetime_value + _t1626 = _dollar_dollar.datetime_value else: - _t1622 = None - deconstruct_result852 = _t1622 - if deconstruct_result852 is not None: - assert deconstruct_result852 is not None - unwrapped853 = deconstruct_result852 - self.pretty_raw_datetime(unwrapped853) + _t1626 = None + deconstruct_result854 = _t1626 + if deconstruct_result854 is not None: + assert deconstruct_result854 is not None + unwrapped855 = deconstruct_result854 + self.pretty_raw_datetime(unwrapped855) else: _dollar_dollar = msg if _dollar_dollar.HasField("string_value"): - _t1623 = _dollar_dollar.string_value + _t1627 = _dollar_dollar.string_value else: - _t1623 = None - deconstruct_result850 = _t1623 - if deconstruct_result850 is not None: - assert deconstruct_result850 is not None - unwrapped851 = deconstruct_result850 - self.write(self.format_string_value(unwrapped851)) + _t1627 = None + deconstruct_result852 = _t1627 + if deconstruct_result852 is not None: + assert deconstruct_result852 is not None + unwrapped853 = deconstruct_result852 + self.write(self.format_string_value(unwrapped853)) else: _dollar_dollar = msg if _dollar_dollar.HasField("int32_value"): - _t1624 = _dollar_dollar.int32_value + _t1628 = _dollar_dollar.int32_value else: - _t1624 = None - deconstruct_result848 = _t1624 - if deconstruct_result848 is not None: - assert deconstruct_result848 is not None - unwrapped849 = deconstruct_result848 - self.write((str(unwrapped849) + 'i32')) + _t1628 = None + deconstruct_result850 = _t1628 + if deconstruct_result850 is not None: + assert deconstruct_result850 is not None + unwrapped851 = deconstruct_result850 + self.write((str(unwrapped851) + 'i32')) else: _dollar_dollar = msg if _dollar_dollar.HasField("int_value"): - _t1625 = _dollar_dollar.int_value + _t1629 = _dollar_dollar.int_value else: - _t1625 = None - deconstruct_result846 = _t1625 - if deconstruct_result846 is not None: - assert deconstruct_result846 is not None - unwrapped847 = deconstruct_result846 - self.write(str(unwrapped847)) + _t1629 = None + deconstruct_result848 = _t1629 + if deconstruct_result848 is not None: + assert deconstruct_result848 is not None + unwrapped849 = deconstruct_result848 + self.write(str(unwrapped849)) else: _dollar_dollar = msg if _dollar_dollar.HasField("float32_value"): - _t1626 = _dollar_dollar.float32_value + _t1630 = _dollar_dollar.float32_value else: - _t1626 = None - deconstruct_result844 = _t1626 - if deconstruct_result844 is not None: - assert deconstruct_result844 is not None - unwrapped845 = deconstruct_result844 - self.write(self.format_float32_literal(unwrapped845)) + _t1630 = None + deconstruct_result846 = _t1630 + if deconstruct_result846 is not None: + assert deconstruct_result846 is not None + unwrapped847 = deconstruct_result846 + self.write(self.format_float32_literal(unwrapped847)) else: _dollar_dollar = msg if _dollar_dollar.HasField("float_value"): - _t1627 = _dollar_dollar.float_value + _t1631 = _dollar_dollar.float_value else: - _t1627 = None - deconstruct_result842 = _t1627 - if deconstruct_result842 is not None: - assert deconstruct_result842 is not None - unwrapped843 = deconstruct_result842 - self.write(str(unwrapped843)) + _t1631 = None + deconstruct_result844 = _t1631 + if deconstruct_result844 is not None: + assert deconstruct_result844 is not None + unwrapped845 = deconstruct_result844 + self.write(str(unwrapped845)) else: _dollar_dollar = msg if _dollar_dollar.HasField("uint32_value"): - _t1628 = _dollar_dollar.uint32_value + _t1632 = _dollar_dollar.uint32_value else: - _t1628 = None - deconstruct_result840 = _t1628 - if deconstruct_result840 is not None: - assert deconstruct_result840 is not None - unwrapped841 = deconstruct_result840 - self.write((str(unwrapped841) + 'u32')) + _t1632 = None + deconstruct_result842 = _t1632 + if deconstruct_result842 is not None: + assert deconstruct_result842 is not None + unwrapped843 = deconstruct_result842 + self.write((str(unwrapped843) + 'u32')) else: _dollar_dollar = msg if _dollar_dollar.HasField("uint128_value"): - _t1629 = _dollar_dollar.uint128_value + _t1633 = _dollar_dollar.uint128_value else: - _t1629 = None - deconstruct_result838 = _t1629 - if deconstruct_result838 is not None: - assert deconstruct_result838 is not None - unwrapped839 = deconstruct_result838 - self.write(self.format_uint128(unwrapped839)) + _t1633 = None + deconstruct_result840 = _t1633 + if deconstruct_result840 is not None: + assert deconstruct_result840 is not None + unwrapped841 = deconstruct_result840 + self.write(self.format_uint128(unwrapped841)) else: _dollar_dollar = msg if _dollar_dollar.HasField("int128_value"): - _t1630 = _dollar_dollar.int128_value + _t1634 = _dollar_dollar.int128_value else: - _t1630 = None - deconstruct_result836 = _t1630 - if deconstruct_result836 is not None: - assert deconstruct_result836 is not None - unwrapped837 = deconstruct_result836 - self.write(self.format_int128(unwrapped837)) + _t1634 = None + deconstruct_result838 = _t1634 + if deconstruct_result838 is not None: + assert deconstruct_result838 is not None + unwrapped839 = deconstruct_result838 + self.write(self.format_int128(unwrapped839)) else: _dollar_dollar = msg if _dollar_dollar.HasField("decimal_value"): - _t1631 = _dollar_dollar.decimal_value + _t1635 = _dollar_dollar.decimal_value else: - _t1631 = None - deconstruct_result834 = _t1631 - if deconstruct_result834 is not None: - assert deconstruct_result834 is not None - unwrapped835 = deconstruct_result834 - self.write(self.format_decimal(unwrapped835)) + _t1635 = None + deconstruct_result836 = _t1635 + if deconstruct_result836 is not None: + assert deconstruct_result836 is not None + unwrapped837 = deconstruct_result836 + self.write(self.format_decimal(unwrapped837)) else: _dollar_dollar = msg if _dollar_dollar.HasField("boolean_value"): - _t1632 = _dollar_dollar.boolean_value + _t1636 = _dollar_dollar.boolean_value else: - _t1632 = None - deconstruct_result832 = _t1632 - if deconstruct_result832 is not None: - assert deconstruct_result832 is not None - unwrapped833 = deconstruct_result832 - self.pretty_boolean_value(unwrapped833) + _t1636 = None + deconstruct_result834 = _t1636 + if deconstruct_result834 is not None: + assert deconstruct_result834 is not None + unwrapped835 = deconstruct_result834 + self.pretty_boolean_value(unwrapped835) else: - fields831 = msg + fields833 = msg self.write("missing") def pretty_raw_date(self, msg: logic_pb2.DateValue): - flat862 = self._try_flat(msg, self.pretty_raw_date) - if flat862 is not None: - assert flat862 is not None - self.write(flat862) + flat864 = self._try_flat(msg, self.pretty_raw_date) + if flat864 is not None: + assert flat864 is not None + self.write(flat864) return None else: _dollar_dollar = msg - fields857 = (int(_dollar_dollar.year), int(_dollar_dollar.month), int(_dollar_dollar.day),) - assert fields857 is not None - unwrapped_fields858 = fields857 + fields859 = (int(_dollar_dollar.year), int(_dollar_dollar.month), int(_dollar_dollar.day),) + assert fields859 is not None + unwrapped_fields860 = fields859 self.write("(date") self.indent_sexp() self.newline() - field859 = unwrapped_fields858[0] - self.write(str(field859)) + field861 = unwrapped_fields860[0] + self.write(str(field861)) self.newline() - field860 = unwrapped_fields858[1] - self.write(str(field860)) + field862 = unwrapped_fields860[1] + self.write(str(field862)) self.newline() - field861 = unwrapped_fields858[2] - self.write(str(field861)) + field863 = unwrapped_fields860[2] + self.write(str(field863)) self.dedent() self.write(")") def pretty_raw_datetime(self, msg: logic_pb2.DateTimeValue): - flat873 = self._try_flat(msg, self.pretty_raw_datetime) - if flat873 is not None: - assert flat873 is not None - self.write(flat873) + flat875 = self._try_flat(msg, self.pretty_raw_datetime) + if flat875 is not None: + assert flat875 is not None + self.write(flat875) return None else: _dollar_dollar = msg - fields863 = (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 fields863 is not None - unwrapped_fields864 = fields863 + fields865 = (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 fields865 is not None + unwrapped_fields866 = fields865 self.write("(datetime") self.indent_sexp() self.newline() - field865 = unwrapped_fields864[0] - self.write(str(field865)) - self.newline() - field866 = unwrapped_fields864[1] - self.write(str(field866)) - self.newline() - field867 = unwrapped_fields864[2] + field867 = unwrapped_fields866[0] self.write(str(field867)) self.newline() - field868 = unwrapped_fields864[3] + field868 = unwrapped_fields866[1] self.write(str(field868)) self.newline() - field869 = unwrapped_fields864[4] + field869 = unwrapped_fields866[2] self.write(str(field869)) self.newline() - field870 = unwrapped_fields864[5] + field870 = unwrapped_fields866[3] self.write(str(field870)) - field871 = unwrapped_fields864[6] - if field871 is not None: + self.newline() + field871 = unwrapped_fields866[4] + self.write(str(field871)) + self.newline() + field872 = unwrapped_fields866[5] + self.write(str(field872)) + field873 = unwrapped_fields866[6] + if field873 is not None: self.newline() - assert field871 is not None - opt_val872 = field871 - self.write(str(opt_val872)) + assert field873 is not None + opt_val874 = field873 + self.write(str(opt_val874)) self.dedent() self.write(")") def pretty_boolean_value(self, msg: bool): _dollar_dollar = msg if _dollar_dollar: - _t1633 = () + _t1637 = () else: - _t1633 = None - deconstruct_result876 = _t1633 - if deconstruct_result876 is not None: - assert deconstruct_result876 is not None - unwrapped877 = deconstruct_result876 + _t1637 = None + deconstruct_result878 = _t1637 + if deconstruct_result878 is not None: + assert deconstruct_result878 is not None + unwrapped879 = deconstruct_result878 self.write("true") else: _dollar_dollar = msg if not _dollar_dollar: - _t1634 = () + _t1638 = () else: - _t1634 = None - deconstruct_result874 = _t1634 - if deconstruct_result874 is not None: - assert deconstruct_result874 is not None - unwrapped875 = deconstruct_result874 + _t1638 = None + deconstruct_result876 = _t1638 + if deconstruct_result876 is not None: + assert deconstruct_result876 is not None + unwrapped877 = deconstruct_result876 self.write("false") else: raise ParseError("No matching rule for boolean_value") def pretty_sync(self, msg: transactions_pb2.Sync): - flat882 = self._try_flat(msg, self.pretty_sync) - if flat882 is not None: - assert flat882 is not None - self.write(flat882) + flat884 = self._try_flat(msg, self.pretty_sync) + if flat884 is not None: + assert flat884 is not None + self.write(flat884) return None else: _dollar_dollar = msg - fields878 = _dollar_dollar.fragments - assert fields878 is not None - unwrapped_fields879 = fields878 + fields880 = _dollar_dollar.fragments + assert fields880 is not None + unwrapped_fields881 = fields880 self.write("(sync") self.indent_sexp() - if not len(unwrapped_fields879) == 0: + if not len(unwrapped_fields881) == 0: self.newline() - for i881, elem880 in enumerate(unwrapped_fields879): - if (i881 > 0): + for i883, elem882 in enumerate(unwrapped_fields881): + if (i883 > 0): self.newline() - self.pretty_fragment_id(elem880) + self.pretty_fragment_id(elem882) self.dedent() self.write(")") def pretty_fragment_id(self, msg: fragments_pb2.FragmentId): - flat885 = self._try_flat(msg, self.pretty_fragment_id) - if flat885 is not None: - assert flat885 is not None - self.write(flat885) + flat887 = self._try_flat(msg, self.pretty_fragment_id) + if flat887 is not None: + assert flat887 is not None + self.write(flat887) return None else: _dollar_dollar = msg - fields883 = self.fragment_id_to_string(_dollar_dollar) - assert fields883 is not None - unwrapped_fields884 = fields883 + fields885 = self.fragment_id_to_string(_dollar_dollar) + assert fields885 is not None + unwrapped_fields886 = fields885 self.write(":") - self.write(unwrapped_fields884) + self.write(unwrapped_fields886) def pretty_epoch(self, msg: transactions_pb2.Epoch): - flat892 = self._try_flat(msg, self.pretty_epoch) - if flat892 is not None: - assert flat892 is not None - self.write(flat892) + flat894 = self._try_flat(msg, self.pretty_epoch) + if flat894 is not None: + assert flat894 is not None + self.write(flat894) return None else: _dollar_dollar = msg if not len(_dollar_dollar.writes) == 0: - _t1635 = _dollar_dollar.writes + _t1639 = _dollar_dollar.writes else: - _t1635 = None + _t1639 = None if not len(_dollar_dollar.reads) == 0: - _t1636 = _dollar_dollar.reads + _t1640 = _dollar_dollar.reads else: - _t1636 = None - fields886 = (_t1635, _t1636,) - assert fields886 is not None - unwrapped_fields887 = fields886 + _t1640 = None + fields888 = (_t1639, _t1640,) + assert fields888 is not None + unwrapped_fields889 = fields888 self.write("(epoch") self.indent_sexp() - field888 = unwrapped_fields887[0] - if field888 is not None: - self.newline() - assert field888 is not None - opt_val889 = field888 - self.pretty_epoch_writes(opt_val889) - field890 = unwrapped_fields887[1] + field890 = unwrapped_fields889[0] if field890 is not None: self.newline() assert field890 is not None opt_val891 = field890 - self.pretty_epoch_reads(opt_val891) + self.pretty_epoch_writes(opt_val891) + field892 = unwrapped_fields889[1] + if field892 is not None: + self.newline() + assert field892 is not None + opt_val893 = field892 + self.pretty_epoch_reads(opt_val893) self.dedent() self.write(")") def pretty_epoch_writes(self, msg: Sequence[transactions_pb2.Write]): - flat896 = self._try_flat(msg, self.pretty_epoch_writes) - if flat896 is not None: - assert flat896 is not None - self.write(flat896) + flat898 = self._try_flat(msg, self.pretty_epoch_writes) + if flat898 is not None: + assert flat898 is not None + self.write(flat898) return None else: - fields893 = msg + fields895 = msg self.write("(writes") self.indent_sexp() - if not len(fields893) == 0: + if not len(fields895) == 0: self.newline() - for i895, elem894 in enumerate(fields893): - if (i895 > 0): + for i897, elem896 in enumerate(fields895): + if (i897 > 0): self.newline() - self.pretty_write(elem894) + self.pretty_write(elem896) self.dedent() self.write(")") def pretty_write(self, msg: transactions_pb2.Write): - flat905 = self._try_flat(msg, self.pretty_write) - if flat905 is not None: - assert flat905 is not None - self.write(flat905) + flat907 = self._try_flat(msg, self.pretty_write) + if flat907 is not None: + assert flat907 is not None + self.write(flat907) return None else: _dollar_dollar = msg if _dollar_dollar.HasField("define"): - _t1637 = _dollar_dollar.define + _t1641 = _dollar_dollar.define else: - _t1637 = None - deconstruct_result903 = _t1637 - if deconstruct_result903 is not None: - assert deconstruct_result903 is not None - unwrapped904 = deconstruct_result903 - self.pretty_define(unwrapped904) + _t1641 = None + deconstruct_result905 = _t1641 + if deconstruct_result905 is not None: + assert deconstruct_result905 is not None + unwrapped906 = deconstruct_result905 + self.pretty_define(unwrapped906) else: _dollar_dollar = msg if _dollar_dollar.HasField("undefine"): - _t1638 = _dollar_dollar.undefine + _t1642 = _dollar_dollar.undefine else: - _t1638 = None - deconstruct_result901 = _t1638 - if deconstruct_result901 is not None: - assert deconstruct_result901 is not None - unwrapped902 = deconstruct_result901 - self.pretty_undefine(unwrapped902) + _t1642 = None + deconstruct_result903 = _t1642 + if deconstruct_result903 is not None: + assert deconstruct_result903 is not None + unwrapped904 = deconstruct_result903 + self.pretty_undefine(unwrapped904) else: _dollar_dollar = msg if _dollar_dollar.HasField("context"): - _t1639 = _dollar_dollar.context + _t1643 = _dollar_dollar.context else: - _t1639 = None - deconstruct_result899 = _t1639 - if deconstruct_result899 is not None: - assert deconstruct_result899 is not None - unwrapped900 = deconstruct_result899 - self.pretty_context(unwrapped900) + _t1643 = None + deconstruct_result901 = _t1643 + if deconstruct_result901 is not None: + assert deconstruct_result901 is not None + unwrapped902 = deconstruct_result901 + self.pretty_context(unwrapped902) else: _dollar_dollar = msg if _dollar_dollar.HasField("snapshot"): - _t1640 = _dollar_dollar.snapshot + _t1644 = _dollar_dollar.snapshot else: - _t1640 = None - deconstruct_result897 = _t1640 - if deconstruct_result897 is not None: - assert deconstruct_result897 is not None - unwrapped898 = deconstruct_result897 - self.pretty_snapshot(unwrapped898) + _t1644 = None + deconstruct_result899 = _t1644 + if deconstruct_result899 is not None: + assert deconstruct_result899 is not None + unwrapped900 = deconstruct_result899 + self.pretty_snapshot(unwrapped900) else: raise ParseError("No matching rule for write") def pretty_define(self, msg: transactions_pb2.Define): - flat908 = self._try_flat(msg, self.pretty_define) - if flat908 is not None: - assert flat908 is not None - self.write(flat908) + flat910 = self._try_flat(msg, self.pretty_define) + if flat910 is not None: + assert flat910 is not None + self.write(flat910) return None else: _dollar_dollar = msg - fields906 = _dollar_dollar.fragment - assert fields906 is not None - unwrapped_fields907 = fields906 + fields908 = _dollar_dollar.fragment + assert fields908 is not None + unwrapped_fields909 = fields908 self.write("(define") self.indent_sexp() self.newline() - self.pretty_fragment(unwrapped_fields907) + self.pretty_fragment(unwrapped_fields909) self.dedent() self.write(")") def pretty_fragment(self, msg: fragments_pb2.Fragment): - flat915 = self._try_flat(msg, self.pretty_fragment) - if flat915 is not None: - assert flat915 is not None - self.write(flat915) + flat917 = self._try_flat(msg, self.pretty_fragment) + if flat917 is not None: + assert flat917 is not None + self.write(flat917) return None else: _dollar_dollar = msg self.start_pretty_fragment(_dollar_dollar) - fields909 = (_dollar_dollar.id, _dollar_dollar.declarations,) - assert fields909 is not None - unwrapped_fields910 = fields909 + fields911 = (_dollar_dollar.id, _dollar_dollar.declarations,) + assert fields911 is not None + unwrapped_fields912 = fields911 self.write("(fragment") self.indent_sexp() self.newline() - field911 = unwrapped_fields910[0] - self.pretty_new_fragment_id(field911) - field912 = unwrapped_fields910[1] - if not len(field912) == 0: + field913 = unwrapped_fields912[0] + self.pretty_new_fragment_id(field913) + field914 = unwrapped_fields912[1] + if not len(field914) == 0: self.newline() - for i914, elem913 in enumerate(field912): - if (i914 > 0): + for i916, elem915 in enumerate(field914): + if (i916 > 0): self.newline() - self.pretty_declaration(elem913) + self.pretty_declaration(elem915) self.dedent() self.write(")") def pretty_new_fragment_id(self, msg: fragments_pb2.FragmentId): - flat917 = self._try_flat(msg, self.pretty_new_fragment_id) - if flat917 is not None: - assert flat917 is not None - self.write(flat917) + flat919 = self._try_flat(msg, self.pretty_new_fragment_id) + if flat919 is not None: + assert flat919 is not None + self.write(flat919) return None else: - fields916 = msg - self.pretty_fragment_id(fields916) + fields918 = msg + self.pretty_fragment_id(fields918) def pretty_declaration(self, msg: logic_pb2.Declaration): - flat926 = self._try_flat(msg, self.pretty_declaration) - if flat926 is not None: - assert flat926 is not None - self.write(flat926) + flat928 = self._try_flat(msg, self.pretty_declaration) + if flat928 is not None: + assert flat928 is not None + self.write(flat928) return None else: _dollar_dollar = msg if _dollar_dollar.HasField("def"): - _t1641 = getattr(_dollar_dollar, 'def') + _t1645 = getattr(_dollar_dollar, 'def') else: - _t1641 = None - deconstruct_result924 = _t1641 - if deconstruct_result924 is not None: - assert deconstruct_result924 is not None - unwrapped925 = deconstruct_result924 - self.pretty_def(unwrapped925) + _t1645 = None + deconstruct_result926 = _t1645 + if deconstruct_result926 is not None: + assert deconstruct_result926 is not None + unwrapped927 = deconstruct_result926 + self.pretty_def(unwrapped927) else: _dollar_dollar = msg if _dollar_dollar.HasField("algorithm"): - _t1642 = _dollar_dollar.algorithm + _t1646 = _dollar_dollar.algorithm else: - _t1642 = None - deconstruct_result922 = _t1642 - if deconstruct_result922 is not None: - assert deconstruct_result922 is not None - unwrapped923 = deconstruct_result922 - self.pretty_algorithm(unwrapped923) + _t1646 = None + deconstruct_result924 = _t1646 + if deconstruct_result924 is not None: + assert deconstruct_result924 is not None + unwrapped925 = deconstruct_result924 + self.pretty_algorithm(unwrapped925) else: _dollar_dollar = msg if _dollar_dollar.HasField("constraint"): - _t1643 = _dollar_dollar.constraint + _t1647 = _dollar_dollar.constraint else: - _t1643 = None - deconstruct_result920 = _t1643 - if deconstruct_result920 is not None: - assert deconstruct_result920 is not None - unwrapped921 = deconstruct_result920 - self.pretty_constraint(unwrapped921) + _t1647 = None + deconstruct_result922 = _t1647 + if deconstruct_result922 is not None: + assert deconstruct_result922 is not None + unwrapped923 = deconstruct_result922 + self.pretty_constraint(unwrapped923) else: _dollar_dollar = msg if _dollar_dollar.HasField("data"): - _t1644 = _dollar_dollar.data + _t1648 = _dollar_dollar.data else: - _t1644 = None - deconstruct_result918 = _t1644 - if deconstruct_result918 is not None: - assert deconstruct_result918 is not None - unwrapped919 = deconstruct_result918 - self.pretty_data(unwrapped919) + _t1648 = None + deconstruct_result920 = _t1648 + if deconstruct_result920 is not None: + assert deconstruct_result920 is not None + unwrapped921 = deconstruct_result920 + self.pretty_data(unwrapped921) else: raise ParseError("No matching rule for declaration") def pretty_def(self, msg: logic_pb2.Def): - flat933 = self._try_flat(msg, self.pretty_def) - if flat933 is not None: - assert flat933 is not None - self.write(flat933) + flat935 = self._try_flat(msg, self.pretty_def) + if flat935 is not None: + assert flat935 is not None + self.write(flat935) return None else: _dollar_dollar = msg if not len(_dollar_dollar.attrs) == 0: - _t1645 = _dollar_dollar.attrs + _t1649 = _dollar_dollar.attrs else: - _t1645 = None - fields927 = (_dollar_dollar.name, _dollar_dollar.body, _t1645,) - assert fields927 is not None - unwrapped_fields928 = fields927 + _t1649 = None + fields929 = (_dollar_dollar.name, _dollar_dollar.body, _t1649,) + assert fields929 is not None + unwrapped_fields930 = fields929 self.write("(def") self.indent_sexp() self.newline() - field929 = unwrapped_fields928[0] - self.pretty_relation_id(field929) + field931 = unwrapped_fields930[0] + self.pretty_relation_id(field931) self.newline() - field930 = unwrapped_fields928[1] - self.pretty_abstraction(field930) - field931 = unwrapped_fields928[2] - if field931 is not None: + field932 = unwrapped_fields930[1] + self.pretty_abstraction(field932) + field933 = unwrapped_fields930[2] + if field933 is not None: self.newline() - assert field931 is not None - opt_val932 = field931 - self.pretty_attrs(opt_val932) + assert field933 is not None + opt_val934 = field933 + self.pretty_attrs(opt_val934) self.dedent() self.write(")") def pretty_relation_id(self, msg: logic_pb2.RelationId): - flat938 = self._try_flat(msg, self.pretty_relation_id) - if flat938 is not None: - assert flat938 is not None - self.write(flat938) + flat940 = self._try_flat(msg, self.pretty_relation_id) + if flat940 is not None: + assert flat940 is not None + self.write(flat940) return None else: _dollar_dollar = msg if self.relation_id_to_string(_dollar_dollar) is not None: - _t1647 = self.deconstruct_relation_id_string(_dollar_dollar) - _t1646 = _t1647 + _t1651 = self.deconstruct_relation_id_string(_dollar_dollar) + _t1650 = _t1651 else: - _t1646 = None - deconstruct_result936 = _t1646 - if deconstruct_result936 is not None: - assert deconstruct_result936 is not None - unwrapped937 = deconstruct_result936 + _t1650 = None + deconstruct_result938 = _t1650 + if deconstruct_result938 is not None: + assert deconstruct_result938 is not None + unwrapped939 = deconstruct_result938 self.write(":") - self.write(unwrapped937) + self.write(unwrapped939) else: _dollar_dollar = msg - _t1648 = self.deconstruct_relation_id_uint128(_dollar_dollar) - deconstruct_result934 = _t1648 - if deconstruct_result934 is not None: - assert deconstruct_result934 is not None - unwrapped935 = deconstruct_result934 - self.write(self.format_uint128(unwrapped935)) + _t1652 = self.deconstruct_relation_id_uint128(_dollar_dollar) + deconstruct_result936 = _t1652 + if deconstruct_result936 is not None: + assert deconstruct_result936 is not None + unwrapped937 = deconstruct_result936 + self.write(self.format_uint128(unwrapped937)) else: raise ParseError("No matching rule for relation_id") def pretty_abstraction(self, msg: logic_pb2.Abstraction): - flat943 = self._try_flat(msg, self.pretty_abstraction) - if flat943 is not None: - assert flat943 is not None - self.write(flat943) + flat945 = self._try_flat(msg, self.pretty_abstraction) + if flat945 is not None: + assert flat945 is not None + self.write(flat945) return None else: _dollar_dollar = msg - _t1649 = self.deconstruct_bindings(_dollar_dollar) - fields939 = (_t1649, _dollar_dollar.value,) - assert fields939 is not None - unwrapped_fields940 = fields939 + _t1653 = self.deconstruct_bindings(_dollar_dollar) + fields941 = (_t1653, _dollar_dollar.value,) + assert fields941 is not None + unwrapped_fields942 = fields941 self.write("(") self.indent() - field941 = unwrapped_fields940[0] - self.pretty_bindings(field941) + field943 = unwrapped_fields942[0] + self.pretty_bindings(field943) self.newline() - field942 = unwrapped_fields940[1] - self.pretty_formula(field942) + field944 = unwrapped_fields942[1] + self.pretty_formula(field944) self.dedent() self.write(")") def pretty_bindings(self, msg: tuple[Sequence[logic_pb2.Binding], Sequence[logic_pb2.Binding]]): - flat951 = self._try_flat(msg, self.pretty_bindings) - if flat951 is not None: - assert flat951 is not None - self.write(flat951) + flat953 = self._try_flat(msg, self.pretty_bindings) + if flat953 is not None: + assert flat953 is not None + self.write(flat953) return None else: _dollar_dollar = msg if not len(_dollar_dollar[1]) == 0: - _t1650 = _dollar_dollar[1] + _t1654 = _dollar_dollar[1] else: - _t1650 = None - fields944 = (_dollar_dollar[0], _t1650,) - assert fields944 is not None - unwrapped_fields945 = fields944 + _t1654 = None + fields946 = (_dollar_dollar[0], _t1654,) + assert fields946 is not None + unwrapped_fields947 = fields946 self.write("[") self.indent() - field946 = unwrapped_fields945[0] - for i948, elem947 in enumerate(field946): - if (i948 > 0): + field948 = unwrapped_fields947[0] + for i950, elem949 in enumerate(field948): + if (i950 > 0): self.newline() - self.pretty_binding(elem947) - field949 = unwrapped_fields945[1] - if field949 is not None: + self.pretty_binding(elem949) + field951 = unwrapped_fields947[1] + if field951 is not None: self.newline() - assert field949 is not None - opt_val950 = field949 - self.pretty_value_bindings(opt_val950) + assert field951 is not None + opt_val952 = field951 + self.pretty_value_bindings(opt_val952) self.dedent() self.write("]") def pretty_binding(self, msg: logic_pb2.Binding): - flat956 = self._try_flat(msg, self.pretty_binding) - if flat956 is not None: - assert flat956 is not None - self.write(flat956) + flat958 = self._try_flat(msg, self.pretty_binding) + if flat958 is not None: + assert flat958 is not None + self.write(flat958) return None else: _dollar_dollar = msg - fields952 = (_dollar_dollar.var.name, _dollar_dollar.type,) - assert fields952 is not None - unwrapped_fields953 = fields952 - field954 = unwrapped_fields953[0] - self.write(field954) + fields954 = (_dollar_dollar.var.name, _dollar_dollar.type,) + assert fields954 is not None + unwrapped_fields955 = fields954 + field956 = unwrapped_fields955[0] + self.write(field956) self.write("::") - field955 = unwrapped_fields953[1] - self.pretty_type(field955) + field957 = unwrapped_fields955[1] + self.pretty_type(field957) def pretty_type(self, msg: logic_pb2.Type): - flat985 = self._try_flat(msg, self.pretty_type) - if flat985 is not None: - assert flat985 is not None - self.write(flat985) + flat987 = self._try_flat(msg, self.pretty_type) + if flat987 is not None: + assert flat987 is not None + self.write(flat987) return None else: _dollar_dollar = msg if _dollar_dollar.HasField("unspecified_type"): - _t1651 = _dollar_dollar.unspecified_type + _t1655 = _dollar_dollar.unspecified_type else: - _t1651 = None - deconstruct_result983 = _t1651 - if deconstruct_result983 is not None: - assert deconstruct_result983 is not None - unwrapped984 = deconstruct_result983 - self.pretty_unspecified_type(unwrapped984) + _t1655 = None + deconstruct_result985 = _t1655 + if deconstruct_result985 is not None: + assert deconstruct_result985 is not None + unwrapped986 = deconstruct_result985 + self.pretty_unspecified_type(unwrapped986) else: _dollar_dollar = msg if _dollar_dollar.HasField("string_type"): - _t1652 = _dollar_dollar.string_type + _t1656 = _dollar_dollar.string_type else: - _t1652 = None - deconstruct_result981 = _t1652 - if deconstruct_result981 is not None: - assert deconstruct_result981 is not None - unwrapped982 = deconstruct_result981 - self.pretty_string_type(unwrapped982) + _t1656 = None + deconstruct_result983 = _t1656 + if deconstruct_result983 is not None: + assert deconstruct_result983 is not None + unwrapped984 = deconstruct_result983 + self.pretty_string_type(unwrapped984) else: _dollar_dollar = msg if _dollar_dollar.HasField("int_type"): - _t1653 = _dollar_dollar.int_type + _t1657 = _dollar_dollar.int_type else: - _t1653 = None - deconstruct_result979 = _t1653 - if deconstruct_result979 is not None: - assert deconstruct_result979 is not None - unwrapped980 = deconstruct_result979 - self.pretty_int_type(unwrapped980) + _t1657 = None + deconstruct_result981 = _t1657 + if deconstruct_result981 is not None: + assert deconstruct_result981 is not None + unwrapped982 = deconstruct_result981 + self.pretty_int_type(unwrapped982) else: _dollar_dollar = msg if _dollar_dollar.HasField("float_type"): - _t1654 = _dollar_dollar.float_type + _t1658 = _dollar_dollar.float_type else: - _t1654 = None - deconstruct_result977 = _t1654 - if deconstruct_result977 is not None: - assert deconstruct_result977 is not None - unwrapped978 = deconstruct_result977 - self.pretty_float_type(unwrapped978) + _t1658 = None + deconstruct_result979 = _t1658 + if deconstruct_result979 is not None: + assert deconstruct_result979 is not None + unwrapped980 = deconstruct_result979 + self.pretty_float_type(unwrapped980) else: _dollar_dollar = msg if _dollar_dollar.HasField("uint128_type"): - _t1655 = _dollar_dollar.uint128_type + _t1659 = _dollar_dollar.uint128_type else: - _t1655 = None - deconstruct_result975 = _t1655 - if deconstruct_result975 is not None: - assert deconstruct_result975 is not None - unwrapped976 = deconstruct_result975 - self.pretty_uint128_type(unwrapped976) + _t1659 = None + deconstruct_result977 = _t1659 + if deconstruct_result977 is not None: + assert deconstruct_result977 is not None + unwrapped978 = deconstruct_result977 + self.pretty_uint128_type(unwrapped978) else: _dollar_dollar = msg if _dollar_dollar.HasField("int128_type"): - _t1656 = _dollar_dollar.int128_type + _t1660 = _dollar_dollar.int128_type else: - _t1656 = None - deconstruct_result973 = _t1656 - if deconstruct_result973 is not None: - assert deconstruct_result973 is not None - unwrapped974 = deconstruct_result973 - self.pretty_int128_type(unwrapped974) + _t1660 = None + deconstruct_result975 = _t1660 + if deconstruct_result975 is not None: + assert deconstruct_result975 is not None + unwrapped976 = deconstruct_result975 + self.pretty_int128_type(unwrapped976) else: _dollar_dollar = msg if _dollar_dollar.HasField("date_type"): - _t1657 = _dollar_dollar.date_type + _t1661 = _dollar_dollar.date_type else: - _t1657 = None - deconstruct_result971 = _t1657 - if deconstruct_result971 is not None: - assert deconstruct_result971 is not None - unwrapped972 = deconstruct_result971 - self.pretty_date_type(unwrapped972) + _t1661 = None + deconstruct_result973 = _t1661 + if deconstruct_result973 is not None: + assert deconstruct_result973 is not None + unwrapped974 = deconstruct_result973 + self.pretty_date_type(unwrapped974) else: _dollar_dollar = msg if _dollar_dollar.HasField("datetime_type"): - _t1658 = _dollar_dollar.datetime_type + _t1662 = _dollar_dollar.datetime_type else: - _t1658 = None - deconstruct_result969 = _t1658 - if deconstruct_result969 is not None: - assert deconstruct_result969 is not None - unwrapped970 = deconstruct_result969 - self.pretty_datetime_type(unwrapped970) + _t1662 = None + deconstruct_result971 = _t1662 + if deconstruct_result971 is not None: + assert deconstruct_result971 is not None + unwrapped972 = deconstruct_result971 + self.pretty_datetime_type(unwrapped972) else: _dollar_dollar = msg if _dollar_dollar.HasField("missing_type"): - _t1659 = _dollar_dollar.missing_type + _t1663 = _dollar_dollar.missing_type else: - _t1659 = None - deconstruct_result967 = _t1659 - if deconstruct_result967 is not None: - assert deconstruct_result967 is not None - unwrapped968 = deconstruct_result967 - self.pretty_missing_type(unwrapped968) + _t1663 = None + deconstruct_result969 = _t1663 + if deconstruct_result969 is not None: + assert deconstruct_result969 is not None + unwrapped970 = deconstruct_result969 + self.pretty_missing_type(unwrapped970) else: _dollar_dollar = msg if _dollar_dollar.HasField("decimal_type"): - _t1660 = _dollar_dollar.decimal_type + _t1664 = _dollar_dollar.decimal_type else: - _t1660 = None - deconstruct_result965 = _t1660 - if deconstruct_result965 is not None: - assert deconstruct_result965 is not None - unwrapped966 = deconstruct_result965 - self.pretty_decimal_type(unwrapped966) + _t1664 = None + deconstruct_result967 = _t1664 + if deconstruct_result967 is not None: + assert deconstruct_result967 is not None + unwrapped968 = deconstruct_result967 + self.pretty_decimal_type(unwrapped968) else: _dollar_dollar = msg if _dollar_dollar.HasField("boolean_type"): - _t1661 = _dollar_dollar.boolean_type + _t1665 = _dollar_dollar.boolean_type else: - _t1661 = None - deconstruct_result963 = _t1661 - if deconstruct_result963 is not None: - assert deconstruct_result963 is not None - unwrapped964 = deconstruct_result963 - self.pretty_boolean_type(unwrapped964) + _t1665 = None + deconstruct_result965 = _t1665 + if deconstruct_result965 is not None: + assert deconstruct_result965 is not None + unwrapped966 = deconstruct_result965 + self.pretty_boolean_type(unwrapped966) else: _dollar_dollar = msg if _dollar_dollar.HasField("int32_type"): - _t1662 = _dollar_dollar.int32_type + _t1666 = _dollar_dollar.int32_type else: - _t1662 = None - deconstruct_result961 = _t1662 - if deconstruct_result961 is not None: - assert deconstruct_result961 is not None - unwrapped962 = deconstruct_result961 - self.pretty_int32_type(unwrapped962) + _t1666 = None + deconstruct_result963 = _t1666 + if deconstruct_result963 is not None: + assert deconstruct_result963 is not None + unwrapped964 = deconstruct_result963 + self.pretty_int32_type(unwrapped964) else: _dollar_dollar = msg if _dollar_dollar.HasField("float32_type"): - _t1663 = _dollar_dollar.float32_type + _t1667 = _dollar_dollar.float32_type else: - _t1663 = None - deconstruct_result959 = _t1663 - if deconstruct_result959 is not None: - assert deconstruct_result959 is not None - unwrapped960 = deconstruct_result959 - self.pretty_float32_type(unwrapped960) + _t1667 = None + deconstruct_result961 = _t1667 + if deconstruct_result961 is not None: + assert deconstruct_result961 is not None + unwrapped962 = deconstruct_result961 + self.pretty_float32_type(unwrapped962) else: _dollar_dollar = msg if _dollar_dollar.HasField("uint32_type"): - _t1664 = _dollar_dollar.uint32_type + _t1668 = _dollar_dollar.uint32_type else: - _t1664 = None - deconstruct_result957 = _t1664 - if deconstruct_result957 is not None: - assert deconstruct_result957 is not None - unwrapped958 = deconstruct_result957 - self.pretty_uint32_type(unwrapped958) + _t1668 = None + deconstruct_result959 = _t1668 + if deconstruct_result959 is not None: + assert deconstruct_result959 is not None + unwrapped960 = deconstruct_result959 + self.pretty_uint32_type(unwrapped960) else: raise ParseError("No matching rule for type") def pretty_unspecified_type(self, msg: logic_pb2.UnspecifiedType): - fields986 = msg + fields988 = msg self.write("UNKNOWN") def pretty_string_type(self, msg: logic_pb2.StringType): - fields987 = msg + fields989 = msg self.write("STRING") def pretty_int_type(self, msg: logic_pb2.IntType): - fields988 = msg + fields990 = msg self.write("INT") def pretty_float_type(self, msg: logic_pb2.FloatType): - fields989 = msg + fields991 = msg self.write("FLOAT") def pretty_uint128_type(self, msg: logic_pb2.UInt128Type): - fields990 = msg + fields992 = msg self.write("UINT128") def pretty_int128_type(self, msg: logic_pb2.Int128Type): - fields991 = msg + fields993 = msg self.write("INT128") def pretty_date_type(self, msg: logic_pb2.DateType): - fields992 = msg + fields994 = msg self.write("DATE") def pretty_datetime_type(self, msg: logic_pb2.DateTimeType): - fields993 = msg + fields995 = msg self.write("DATETIME") def pretty_missing_type(self, msg: logic_pb2.MissingType): - fields994 = msg + fields996 = msg self.write("MISSING") def pretty_decimal_type(self, msg: logic_pb2.DecimalType): - flat999 = self._try_flat(msg, self.pretty_decimal_type) - if flat999 is not None: - assert flat999 is not None - self.write(flat999) + flat1001 = self._try_flat(msg, self.pretty_decimal_type) + if flat1001 is not None: + assert flat1001 is not None + self.write(flat1001) return None else: _dollar_dollar = msg - fields995 = (int(_dollar_dollar.precision), int(_dollar_dollar.scale),) - assert fields995 is not None - unwrapped_fields996 = fields995 + fields997 = (int(_dollar_dollar.precision), int(_dollar_dollar.scale),) + assert fields997 is not None + unwrapped_fields998 = fields997 self.write("(DECIMAL") self.indent_sexp() self.newline() - field997 = unwrapped_fields996[0] - self.write(str(field997)) + field999 = unwrapped_fields998[0] + self.write(str(field999)) self.newline() - field998 = unwrapped_fields996[1] - self.write(str(field998)) + field1000 = unwrapped_fields998[1] + self.write(str(field1000)) self.dedent() self.write(")") def pretty_boolean_type(self, msg: logic_pb2.BooleanType): - fields1000 = msg + fields1002 = msg self.write("BOOLEAN") def pretty_int32_type(self, msg: logic_pb2.Int32Type): - fields1001 = msg + fields1003 = msg self.write("INT32") def pretty_float32_type(self, msg: logic_pb2.Float32Type): - fields1002 = msg + fields1004 = msg self.write("FLOAT32") def pretty_uint32_type(self, msg: logic_pb2.UInt32Type): - fields1003 = msg + fields1005 = msg self.write("UINT32") def pretty_value_bindings(self, msg: Sequence[logic_pb2.Binding]): - flat1007 = self._try_flat(msg, self.pretty_value_bindings) - if flat1007 is not None: - assert flat1007 is not None - self.write(flat1007) + flat1009 = self._try_flat(msg, self.pretty_value_bindings) + if flat1009 is not None: + assert flat1009 is not None + self.write(flat1009) return None else: - fields1004 = msg + fields1006 = msg self.write("|") - if not len(fields1004) == 0: + if not len(fields1006) == 0: self.write(" ") - for i1006, elem1005 in enumerate(fields1004): - if (i1006 > 0): + for i1008, elem1007 in enumerate(fields1006): + if (i1008 > 0): self.newline() - self.pretty_binding(elem1005) + self.pretty_binding(elem1007) def pretty_formula(self, msg: logic_pb2.Formula): - flat1034 = self._try_flat(msg, self.pretty_formula) - if flat1034 is not None: - assert flat1034 is not None - self.write(flat1034) + flat1036 = self._try_flat(msg, self.pretty_formula) + if flat1036 is not None: + assert flat1036 is not None + self.write(flat1036) return None else: _dollar_dollar = msg if (_dollar_dollar.HasField("conjunction") and len(_dollar_dollar.conjunction.args) == 0): - _t1665 = _dollar_dollar.conjunction + _t1669 = _dollar_dollar.conjunction else: - _t1665 = None - deconstruct_result1032 = _t1665 - if deconstruct_result1032 is not None: - assert deconstruct_result1032 is not None - unwrapped1033 = deconstruct_result1032 - self.pretty_true(unwrapped1033) + _t1669 = None + deconstruct_result1034 = _t1669 + if deconstruct_result1034 is not None: + assert deconstruct_result1034 is not None + unwrapped1035 = deconstruct_result1034 + self.pretty_true(unwrapped1035) else: _dollar_dollar = msg if (_dollar_dollar.HasField("disjunction") and len(_dollar_dollar.disjunction.args) == 0): - _t1666 = _dollar_dollar.disjunction + _t1670 = _dollar_dollar.disjunction else: - _t1666 = None - deconstruct_result1030 = _t1666 - if deconstruct_result1030 is not None: - assert deconstruct_result1030 is not None - unwrapped1031 = deconstruct_result1030 - self.pretty_false(unwrapped1031) + _t1670 = None + deconstruct_result1032 = _t1670 + if deconstruct_result1032 is not None: + assert deconstruct_result1032 is not None + unwrapped1033 = deconstruct_result1032 + self.pretty_false(unwrapped1033) else: _dollar_dollar = msg if _dollar_dollar.HasField("exists"): - _t1667 = _dollar_dollar.exists + _t1671 = _dollar_dollar.exists else: - _t1667 = None - deconstruct_result1028 = _t1667 - if deconstruct_result1028 is not None: - assert deconstruct_result1028 is not None - unwrapped1029 = deconstruct_result1028 - self.pretty_exists(unwrapped1029) + _t1671 = None + deconstruct_result1030 = _t1671 + if deconstruct_result1030 is not None: + assert deconstruct_result1030 is not None + unwrapped1031 = deconstruct_result1030 + self.pretty_exists(unwrapped1031) else: _dollar_dollar = msg if _dollar_dollar.HasField("reduce"): - _t1668 = _dollar_dollar.reduce + _t1672 = _dollar_dollar.reduce else: - _t1668 = None - deconstruct_result1026 = _t1668 - if deconstruct_result1026 is not None: - assert deconstruct_result1026 is not None - unwrapped1027 = deconstruct_result1026 - self.pretty_reduce(unwrapped1027) + _t1672 = None + deconstruct_result1028 = _t1672 + if deconstruct_result1028 is not None: + assert deconstruct_result1028 is not None + unwrapped1029 = deconstruct_result1028 + self.pretty_reduce(unwrapped1029) else: _dollar_dollar = msg if (_dollar_dollar.HasField("conjunction") and not len(_dollar_dollar.conjunction.args) == 0): - _t1669 = _dollar_dollar.conjunction + _t1673 = _dollar_dollar.conjunction else: - _t1669 = None - deconstruct_result1024 = _t1669 - if deconstruct_result1024 is not None: - assert deconstruct_result1024 is not None - unwrapped1025 = deconstruct_result1024 - self.pretty_conjunction(unwrapped1025) + _t1673 = None + deconstruct_result1026 = _t1673 + if deconstruct_result1026 is not None: + assert deconstruct_result1026 is not None + unwrapped1027 = deconstruct_result1026 + self.pretty_conjunction(unwrapped1027) else: _dollar_dollar = msg if (_dollar_dollar.HasField("disjunction") and not len(_dollar_dollar.disjunction.args) == 0): - _t1670 = _dollar_dollar.disjunction + _t1674 = _dollar_dollar.disjunction else: - _t1670 = None - deconstruct_result1022 = _t1670 - if deconstruct_result1022 is not None: - assert deconstruct_result1022 is not None - unwrapped1023 = deconstruct_result1022 - self.pretty_disjunction(unwrapped1023) + _t1674 = None + deconstruct_result1024 = _t1674 + if deconstruct_result1024 is not None: + assert deconstruct_result1024 is not None + unwrapped1025 = deconstruct_result1024 + self.pretty_disjunction(unwrapped1025) else: _dollar_dollar = msg if _dollar_dollar.HasField("not"): - _t1671 = getattr(_dollar_dollar, 'not') + _t1675 = getattr(_dollar_dollar, 'not') else: - _t1671 = None - deconstruct_result1020 = _t1671 - if deconstruct_result1020 is not None: - assert deconstruct_result1020 is not None - unwrapped1021 = deconstruct_result1020 - self.pretty_not(unwrapped1021) + _t1675 = None + deconstruct_result1022 = _t1675 + if deconstruct_result1022 is not None: + assert deconstruct_result1022 is not None + unwrapped1023 = deconstruct_result1022 + self.pretty_not(unwrapped1023) else: _dollar_dollar = msg if _dollar_dollar.HasField("ffi"): - _t1672 = _dollar_dollar.ffi + _t1676 = _dollar_dollar.ffi else: - _t1672 = None - deconstruct_result1018 = _t1672 - if deconstruct_result1018 is not None: - assert deconstruct_result1018 is not None - unwrapped1019 = deconstruct_result1018 - self.pretty_ffi(unwrapped1019) + _t1676 = None + deconstruct_result1020 = _t1676 + if deconstruct_result1020 is not None: + assert deconstruct_result1020 is not None + unwrapped1021 = deconstruct_result1020 + self.pretty_ffi(unwrapped1021) else: _dollar_dollar = msg if _dollar_dollar.HasField("atom"): - _t1673 = _dollar_dollar.atom + _t1677 = _dollar_dollar.atom else: - _t1673 = None - deconstruct_result1016 = _t1673 - if deconstruct_result1016 is not None: - assert deconstruct_result1016 is not None - unwrapped1017 = deconstruct_result1016 - self.pretty_atom(unwrapped1017) + _t1677 = None + deconstruct_result1018 = _t1677 + if deconstruct_result1018 is not None: + assert deconstruct_result1018 is not None + unwrapped1019 = deconstruct_result1018 + self.pretty_atom(unwrapped1019) else: _dollar_dollar = msg if _dollar_dollar.HasField("pragma"): - _t1674 = _dollar_dollar.pragma + _t1678 = _dollar_dollar.pragma else: - _t1674 = None - deconstruct_result1014 = _t1674 - if deconstruct_result1014 is not None: - assert deconstruct_result1014 is not None - unwrapped1015 = deconstruct_result1014 - self.pretty_pragma(unwrapped1015) + _t1678 = None + deconstruct_result1016 = _t1678 + if deconstruct_result1016 is not None: + assert deconstruct_result1016 is not None + unwrapped1017 = deconstruct_result1016 + self.pretty_pragma(unwrapped1017) else: _dollar_dollar = msg if _dollar_dollar.HasField("primitive"): - _t1675 = _dollar_dollar.primitive + _t1679 = _dollar_dollar.primitive else: - _t1675 = None - deconstruct_result1012 = _t1675 - if deconstruct_result1012 is not None: - assert deconstruct_result1012 is not None - unwrapped1013 = deconstruct_result1012 - self.pretty_primitive(unwrapped1013) + _t1679 = None + deconstruct_result1014 = _t1679 + if deconstruct_result1014 is not None: + assert deconstruct_result1014 is not None + unwrapped1015 = deconstruct_result1014 + self.pretty_primitive(unwrapped1015) else: _dollar_dollar = msg if _dollar_dollar.HasField("rel_atom"): - _t1676 = _dollar_dollar.rel_atom + _t1680 = _dollar_dollar.rel_atom else: - _t1676 = None - deconstruct_result1010 = _t1676 - if deconstruct_result1010 is not None: - assert deconstruct_result1010 is not None - unwrapped1011 = deconstruct_result1010 - self.pretty_rel_atom(unwrapped1011) + _t1680 = None + deconstruct_result1012 = _t1680 + if deconstruct_result1012 is not None: + assert deconstruct_result1012 is not None + unwrapped1013 = deconstruct_result1012 + self.pretty_rel_atom(unwrapped1013) else: _dollar_dollar = msg if _dollar_dollar.HasField("cast"): - _t1677 = _dollar_dollar.cast + _t1681 = _dollar_dollar.cast else: - _t1677 = None - deconstruct_result1008 = _t1677 - if deconstruct_result1008 is not None: - assert deconstruct_result1008 is not None - unwrapped1009 = deconstruct_result1008 - self.pretty_cast(unwrapped1009) + _t1681 = None + deconstruct_result1010 = _t1681 + if deconstruct_result1010 is not None: + assert deconstruct_result1010 is not None + unwrapped1011 = deconstruct_result1010 + self.pretty_cast(unwrapped1011) else: raise ParseError("No matching rule for formula") def pretty_true(self, msg: logic_pb2.Conjunction): - fields1035 = msg + fields1037 = msg self.write("(true)") def pretty_false(self, msg: logic_pb2.Disjunction): - fields1036 = msg + fields1038 = msg self.write("(false)") def pretty_exists(self, msg: logic_pb2.Exists): - flat1041 = self._try_flat(msg, self.pretty_exists) - if flat1041 is not None: - assert flat1041 is not None - self.write(flat1041) + flat1043 = self._try_flat(msg, self.pretty_exists) + if flat1043 is not None: + assert flat1043 is not None + self.write(flat1043) return None else: _dollar_dollar = msg - _t1678 = self.deconstruct_bindings(_dollar_dollar.body) - fields1037 = (_t1678, _dollar_dollar.body.value,) - assert fields1037 is not None - unwrapped_fields1038 = fields1037 + _t1682 = self.deconstruct_bindings(_dollar_dollar.body) + fields1039 = (_t1682, _dollar_dollar.body.value,) + assert fields1039 is not None + unwrapped_fields1040 = fields1039 self.write("(exists") self.indent_sexp() self.newline() - field1039 = unwrapped_fields1038[0] - self.pretty_bindings(field1039) + field1041 = unwrapped_fields1040[0] + self.pretty_bindings(field1041) self.newline() - field1040 = unwrapped_fields1038[1] - self.pretty_formula(field1040) + field1042 = unwrapped_fields1040[1] + self.pretty_formula(field1042) self.dedent() self.write(")") def pretty_reduce(self, msg: logic_pb2.Reduce): - flat1047 = self._try_flat(msg, self.pretty_reduce) - if flat1047 is not None: - assert flat1047 is not None - self.write(flat1047) + flat1049 = self._try_flat(msg, self.pretty_reduce) + if flat1049 is not None: + assert flat1049 is not None + self.write(flat1049) return None else: _dollar_dollar = msg - fields1042 = (_dollar_dollar.op, _dollar_dollar.body, _dollar_dollar.terms,) - assert fields1042 is not None - unwrapped_fields1043 = fields1042 + fields1044 = (_dollar_dollar.op, _dollar_dollar.body, _dollar_dollar.terms,) + assert fields1044 is not None + unwrapped_fields1045 = fields1044 self.write("(reduce") self.indent_sexp() self.newline() - field1044 = unwrapped_fields1043[0] - self.pretty_abstraction(field1044) + field1046 = unwrapped_fields1045[0] + self.pretty_abstraction(field1046) self.newline() - field1045 = unwrapped_fields1043[1] - self.pretty_abstraction(field1045) + field1047 = unwrapped_fields1045[1] + self.pretty_abstraction(field1047) self.newline() - field1046 = unwrapped_fields1043[2] - self.pretty_terms(field1046) + field1048 = unwrapped_fields1045[2] + self.pretty_terms(field1048) self.dedent() self.write(")") def pretty_terms(self, msg: Sequence[logic_pb2.Term]): - flat1051 = self._try_flat(msg, self.pretty_terms) - if flat1051 is not None: - assert flat1051 is not None - self.write(flat1051) + flat1053 = self._try_flat(msg, self.pretty_terms) + if flat1053 is not None: + assert flat1053 is not None + self.write(flat1053) return None else: - fields1048 = msg + fields1050 = msg self.write("(terms") self.indent_sexp() - if not len(fields1048) == 0: + if not len(fields1050) == 0: self.newline() - for i1050, elem1049 in enumerate(fields1048): - if (i1050 > 0): + for i1052, elem1051 in enumerate(fields1050): + if (i1052 > 0): self.newline() - self.pretty_term(elem1049) + self.pretty_term(elem1051) self.dedent() self.write(")") def pretty_term(self, msg: logic_pb2.Term): - flat1056 = self._try_flat(msg, self.pretty_term) - if flat1056 is not None: - assert flat1056 is not None - self.write(flat1056) + flat1058 = self._try_flat(msg, self.pretty_term) + if flat1058 is not None: + assert flat1058 is not None + self.write(flat1058) return None else: _dollar_dollar = msg if _dollar_dollar.HasField("var"): - _t1679 = _dollar_dollar.var + _t1683 = _dollar_dollar.var else: - _t1679 = None - deconstruct_result1054 = _t1679 - if deconstruct_result1054 is not None: - assert deconstruct_result1054 is not None - unwrapped1055 = deconstruct_result1054 - self.pretty_var(unwrapped1055) + _t1683 = None + deconstruct_result1056 = _t1683 + if deconstruct_result1056 is not None: + assert deconstruct_result1056 is not None + unwrapped1057 = deconstruct_result1056 + self.pretty_var(unwrapped1057) else: _dollar_dollar = msg if _dollar_dollar.HasField("constant"): - _t1680 = _dollar_dollar.constant + _t1684 = _dollar_dollar.constant else: - _t1680 = None - deconstruct_result1052 = _t1680 - if deconstruct_result1052 is not None: - assert deconstruct_result1052 is not None - unwrapped1053 = deconstruct_result1052 - self.pretty_value(unwrapped1053) + _t1684 = None + deconstruct_result1054 = _t1684 + if deconstruct_result1054 is not None: + assert deconstruct_result1054 is not None + unwrapped1055 = deconstruct_result1054 + self.pretty_value(unwrapped1055) else: raise ParseError("No matching rule for term") def pretty_var(self, msg: logic_pb2.Var): - flat1059 = self._try_flat(msg, self.pretty_var) - if flat1059 is not None: - assert flat1059 is not None - self.write(flat1059) + flat1061 = self._try_flat(msg, self.pretty_var) + if flat1061 is not None: + assert flat1061 is not None + self.write(flat1061) return None else: _dollar_dollar = msg - fields1057 = _dollar_dollar.name - assert fields1057 is not None - unwrapped_fields1058 = fields1057 - self.write(unwrapped_fields1058) + fields1059 = _dollar_dollar.name + assert fields1059 is not None + unwrapped_fields1060 = fields1059 + self.write(unwrapped_fields1060) def pretty_value(self, msg: logic_pb2.Value): - flat1085 = self._try_flat(msg, self.pretty_value) - if flat1085 is not None: - assert flat1085 is not None - self.write(flat1085) + flat1087 = self._try_flat(msg, self.pretty_value) + if flat1087 is not None: + assert flat1087 is not None + self.write(flat1087) return None else: _dollar_dollar = msg if _dollar_dollar.HasField("date_value"): - _t1681 = _dollar_dollar.date_value + _t1685 = _dollar_dollar.date_value else: - _t1681 = None - deconstruct_result1083 = _t1681 - if deconstruct_result1083 is not None: - assert deconstruct_result1083 is not None - unwrapped1084 = deconstruct_result1083 - self.pretty_date(unwrapped1084) + _t1685 = None + deconstruct_result1085 = _t1685 + if deconstruct_result1085 is not None: + assert deconstruct_result1085 is not None + unwrapped1086 = deconstruct_result1085 + self.pretty_date(unwrapped1086) else: _dollar_dollar = msg if _dollar_dollar.HasField("datetime_value"): - _t1682 = _dollar_dollar.datetime_value + _t1686 = _dollar_dollar.datetime_value else: - _t1682 = None - deconstruct_result1081 = _t1682 - if deconstruct_result1081 is not None: - assert deconstruct_result1081 is not None - unwrapped1082 = deconstruct_result1081 - self.pretty_datetime(unwrapped1082) + _t1686 = None + deconstruct_result1083 = _t1686 + if deconstruct_result1083 is not None: + assert deconstruct_result1083 is not None + unwrapped1084 = deconstruct_result1083 + self.pretty_datetime(unwrapped1084) else: _dollar_dollar = msg if _dollar_dollar.HasField("string_value"): - _t1683 = _dollar_dollar.string_value + _t1687 = _dollar_dollar.string_value else: - _t1683 = None - deconstruct_result1079 = _t1683 - if deconstruct_result1079 is not None: - assert deconstruct_result1079 is not None - unwrapped1080 = deconstruct_result1079 - self.write(self.format_string_value(unwrapped1080)) + _t1687 = None + deconstruct_result1081 = _t1687 + if deconstruct_result1081 is not None: + assert deconstruct_result1081 is not None + unwrapped1082 = deconstruct_result1081 + self.write(self.format_string_value(unwrapped1082)) else: _dollar_dollar = msg if _dollar_dollar.HasField("int32_value"): - _t1684 = _dollar_dollar.int32_value + _t1688 = _dollar_dollar.int32_value else: - _t1684 = None - deconstruct_result1077 = _t1684 - if deconstruct_result1077 is not None: - assert deconstruct_result1077 is not None - unwrapped1078 = deconstruct_result1077 - self.write((str(unwrapped1078) + 'i32')) + _t1688 = None + deconstruct_result1079 = _t1688 + if deconstruct_result1079 is not None: + assert deconstruct_result1079 is not None + unwrapped1080 = deconstruct_result1079 + self.write((str(unwrapped1080) + 'i32')) else: _dollar_dollar = msg if _dollar_dollar.HasField("int_value"): - _t1685 = _dollar_dollar.int_value + _t1689 = _dollar_dollar.int_value else: - _t1685 = None - deconstruct_result1075 = _t1685 - if deconstruct_result1075 is not None: - assert deconstruct_result1075 is not None - unwrapped1076 = deconstruct_result1075 - self.write(str(unwrapped1076)) + _t1689 = None + deconstruct_result1077 = _t1689 + if deconstruct_result1077 is not None: + assert deconstruct_result1077 is not None + unwrapped1078 = deconstruct_result1077 + self.write(str(unwrapped1078)) else: _dollar_dollar = msg if _dollar_dollar.HasField("float32_value"): - _t1686 = _dollar_dollar.float32_value + _t1690 = _dollar_dollar.float32_value else: - _t1686 = None - deconstruct_result1073 = _t1686 - if deconstruct_result1073 is not None: - assert deconstruct_result1073 is not None - unwrapped1074 = deconstruct_result1073 - self.write(self.format_float32_literal(unwrapped1074)) + _t1690 = None + deconstruct_result1075 = _t1690 + if deconstruct_result1075 is not None: + assert deconstruct_result1075 is not None + unwrapped1076 = deconstruct_result1075 + self.write(self.format_float32_literal(unwrapped1076)) else: _dollar_dollar = msg if _dollar_dollar.HasField("float_value"): - _t1687 = _dollar_dollar.float_value + _t1691 = _dollar_dollar.float_value else: - _t1687 = None - deconstruct_result1071 = _t1687 - if deconstruct_result1071 is not None: - assert deconstruct_result1071 is not None - unwrapped1072 = deconstruct_result1071 - self.write(str(unwrapped1072)) + _t1691 = None + deconstruct_result1073 = _t1691 + if deconstruct_result1073 is not None: + assert deconstruct_result1073 is not None + unwrapped1074 = deconstruct_result1073 + self.write(str(unwrapped1074)) else: _dollar_dollar = msg if _dollar_dollar.HasField("uint32_value"): - _t1688 = _dollar_dollar.uint32_value + _t1692 = _dollar_dollar.uint32_value else: - _t1688 = None - deconstruct_result1069 = _t1688 - if deconstruct_result1069 is not None: - assert deconstruct_result1069 is not None - unwrapped1070 = deconstruct_result1069 - self.write((str(unwrapped1070) + 'u32')) + _t1692 = None + deconstruct_result1071 = _t1692 + if deconstruct_result1071 is not None: + assert deconstruct_result1071 is not None + unwrapped1072 = deconstruct_result1071 + self.write((str(unwrapped1072) + 'u32')) else: _dollar_dollar = msg if _dollar_dollar.HasField("uint128_value"): - _t1689 = _dollar_dollar.uint128_value + _t1693 = _dollar_dollar.uint128_value else: - _t1689 = None - deconstruct_result1067 = _t1689 - if deconstruct_result1067 is not None: - assert deconstruct_result1067 is not None - unwrapped1068 = deconstruct_result1067 - self.write(self.format_uint128(unwrapped1068)) + _t1693 = None + deconstruct_result1069 = _t1693 + if deconstruct_result1069 is not None: + assert deconstruct_result1069 is not None + unwrapped1070 = deconstruct_result1069 + self.write(self.format_uint128(unwrapped1070)) else: _dollar_dollar = msg if _dollar_dollar.HasField("int128_value"): - _t1690 = _dollar_dollar.int128_value + _t1694 = _dollar_dollar.int128_value else: - _t1690 = None - deconstruct_result1065 = _t1690 - if deconstruct_result1065 is not None: - assert deconstruct_result1065 is not None - unwrapped1066 = deconstruct_result1065 - self.write(self.format_int128(unwrapped1066)) + _t1694 = None + deconstruct_result1067 = _t1694 + if deconstruct_result1067 is not None: + assert deconstruct_result1067 is not None + unwrapped1068 = deconstruct_result1067 + self.write(self.format_int128(unwrapped1068)) else: _dollar_dollar = msg if _dollar_dollar.HasField("decimal_value"): - _t1691 = _dollar_dollar.decimal_value + _t1695 = _dollar_dollar.decimal_value else: - _t1691 = None - deconstruct_result1063 = _t1691 - if deconstruct_result1063 is not None: - assert deconstruct_result1063 is not None - unwrapped1064 = deconstruct_result1063 - self.write(self.format_decimal(unwrapped1064)) + _t1695 = None + deconstruct_result1065 = _t1695 + if deconstruct_result1065 is not None: + assert deconstruct_result1065 is not None + unwrapped1066 = deconstruct_result1065 + self.write(self.format_decimal(unwrapped1066)) else: _dollar_dollar = msg if _dollar_dollar.HasField("boolean_value"): - _t1692 = _dollar_dollar.boolean_value + _t1696 = _dollar_dollar.boolean_value else: - _t1692 = None - deconstruct_result1061 = _t1692 - if deconstruct_result1061 is not None: - assert deconstruct_result1061 is not None - unwrapped1062 = deconstruct_result1061 - self.pretty_boolean_value(unwrapped1062) + _t1696 = None + deconstruct_result1063 = _t1696 + if deconstruct_result1063 is not None: + assert deconstruct_result1063 is not None + unwrapped1064 = deconstruct_result1063 + self.pretty_boolean_value(unwrapped1064) else: - fields1060 = msg + fields1062 = msg self.write("missing") def pretty_date(self, msg: logic_pb2.DateValue): - flat1091 = self._try_flat(msg, self.pretty_date) - if flat1091 is not None: - assert flat1091 is not None - self.write(flat1091) + flat1093 = self._try_flat(msg, self.pretty_date) + if flat1093 is not None: + assert flat1093 is not None + self.write(flat1093) return None else: _dollar_dollar = msg - fields1086 = (int(_dollar_dollar.year), int(_dollar_dollar.month), int(_dollar_dollar.day),) - assert fields1086 is not None - unwrapped_fields1087 = fields1086 + fields1088 = (int(_dollar_dollar.year), int(_dollar_dollar.month), int(_dollar_dollar.day),) + assert fields1088 is not None + unwrapped_fields1089 = fields1088 self.write("(date") self.indent_sexp() self.newline() - field1088 = unwrapped_fields1087[0] - self.write(str(field1088)) + field1090 = unwrapped_fields1089[0] + self.write(str(field1090)) self.newline() - field1089 = unwrapped_fields1087[1] - self.write(str(field1089)) + field1091 = unwrapped_fields1089[1] + self.write(str(field1091)) self.newline() - field1090 = unwrapped_fields1087[2] - self.write(str(field1090)) + field1092 = unwrapped_fields1089[2] + self.write(str(field1092)) self.dedent() self.write(")") def pretty_datetime(self, msg: logic_pb2.DateTimeValue): - flat1102 = self._try_flat(msg, self.pretty_datetime) - if flat1102 is not None: - assert flat1102 is not None - self.write(flat1102) + flat1104 = self._try_flat(msg, self.pretty_datetime) + if flat1104 is not None: + assert flat1104 is not None + self.write(flat1104) return None else: _dollar_dollar = msg - fields1092 = (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 fields1092 is not None - unwrapped_fields1093 = fields1092 + fields1094 = (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 fields1094 is not None + unwrapped_fields1095 = fields1094 self.write("(datetime") self.indent_sexp() self.newline() - field1094 = unwrapped_fields1093[0] - self.write(str(field1094)) - self.newline() - field1095 = unwrapped_fields1093[1] - self.write(str(field1095)) - self.newline() - field1096 = unwrapped_fields1093[2] + field1096 = unwrapped_fields1095[0] self.write(str(field1096)) self.newline() - field1097 = unwrapped_fields1093[3] + field1097 = unwrapped_fields1095[1] self.write(str(field1097)) self.newline() - field1098 = unwrapped_fields1093[4] + field1098 = unwrapped_fields1095[2] self.write(str(field1098)) self.newline() - field1099 = unwrapped_fields1093[5] + field1099 = unwrapped_fields1095[3] self.write(str(field1099)) - field1100 = unwrapped_fields1093[6] - if field1100 is not None: + self.newline() + field1100 = unwrapped_fields1095[4] + self.write(str(field1100)) + self.newline() + field1101 = unwrapped_fields1095[5] + self.write(str(field1101)) + field1102 = unwrapped_fields1095[6] + if field1102 is not None: self.newline() - assert field1100 is not None - opt_val1101 = field1100 - self.write(str(opt_val1101)) + assert field1102 is not None + opt_val1103 = field1102 + self.write(str(opt_val1103)) self.dedent() self.write(")") def pretty_conjunction(self, msg: logic_pb2.Conjunction): - flat1107 = self._try_flat(msg, self.pretty_conjunction) - if flat1107 is not None: - assert flat1107 is not None - self.write(flat1107) + flat1109 = self._try_flat(msg, self.pretty_conjunction) + if flat1109 is not None: + assert flat1109 is not None + self.write(flat1109) return None else: _dollar_dollar = msg - fields1103 = _dollar_dollar.args - assert fields1103 is not None - unwrapped_fields1104 = fields1103 + fields1105 = _dollar_dollar.args + assert fields1105 is not None + unwrapped_fields1106 = fields1105 self.write("(and") self.indent_sexp() - if not len(unwrapped_fields1104) == 0: + if not len(unwrapped_fields1106) == 0: self.newline() - for i1106, elem1105 in enumerate(unwrapped_fields1104): - if (i1106 > 0): + for i1108, elem1107 in enumerate(unwrapped_fields1106): + if (i1108 > 0): self.newline() - self.pretty_formula(elem1105) + self.pretty_formula(elem1107) self.dedent() self.write(")") def pretty_disjunction(self, msg: logic_pb2.Disjunction): - flat1112 = self._try_flat(msg, self.pretty_disjunction) - if flat1112 is not None: - assert flat1112 is not None - self.write(flat1112) + flat1114 = self._try_flat(msg, self.pretty_disjunction) + if flat1114 is not None: + assert flat1114 is not None + self.write(flat1114) return None else: _dollar_dollar = msg - fields1108 = _dollar_dollar.args - assert fields1108 is not None - unwrapped_fields1109 = fields1108 + fields1110 = _dollar_dollar.args + assert fields1110 is not None + unwrapped_fields1111 = fields1110 self.write("(or") self.indent_sexp() - if not len(unwrapped_fields1109) == 0: + if not len(unwrapped_fields1111) == 0: self.newline() - for i1111, elem1110 in enumerate(unwrapped_fields1109): - if (i1111 > 0): + for i1113, elem1112 in enumerate(unwrapped_fields1111): + if (i1113 > 0): self.newline() - self.pretty_formula(elem1110) + self.pretty_formula(elem1112) self.dedent() self.write(")") def pretty_not(self, msg: logic_pb2.Not): - flat1115 = self._try_flat(msg, self.pretty_not) - if flat1115 is not None: - assert flat1115 is not None - self.write(flat1115) + flat1117 = self._try_flat(msg, self.pretty_not) + if flat1117 is not None: + assert flat1117 is not None + self.write(flat1117) return None else: _dollar_dollar = msg - fields1113 = _dollar_dollar.arg - assert fields1113 is not None - unwrapped_fields1114 = fields1113 + fields1115 = _dollar_dollar.arg + assert fields1115 is not None + unwrapped_fields1116 = fields1115 self.write("(not") self.indent_sexp() self.newline() - self.pretty_formula(unwrapped_fields1114) + self.pretty_formula(unwrapped_fields1116) self.dedent() self.write(")") def pretty_ffi(self, msg: logic_pb2.FFI): - flat1121 = self._try_flat(msg, self.pretty_ffi) - if flat1121 is not None: - assert flat1121 is not None - self.write(flat1121) + flat1123 = self._try_flat(msg, self.pretty_ffi) + if flat1123 is not None: + assert flat1123 is not None + self.write(flat1123) return None else: _dollar_dollar = msg - fields1116 = (_dollar_dollar.name, _dollar_dollar.args, _dollar_dollar.terms,) - assert fields1116 is not None - unwrapped_fields1117 = fields1116 + fields1118 = (_dollar_dollar.name, _dollar_dollar.args, _dollar_dollar.terms,) + assert fields1118 is not None + unwrapped_fields1119 = fields1118 self.write("(ffi") self.indent_sexp() self.newline() - field1118 = unwrapped_fields1117[0] - self.pretty_name(field1118) + field1120 = unwrapped_fields1119[0] + self.pretty_name(field1120) self.newline() - field1119 = unwrapped_fields1117[1] - self.pretty_ffi_args(field1119) + field1121 = unwrapped_fields1119[1] + self.pretty_ffi_args(field1121) self.newline() - field1120 = unwrapped_fields1117[2] - self.pretty_terms(field1120) + field1122 = unwrapped_fields1119[2] + self.pretty_terms(field1122) self.dedent() self.write(")") def pretty_name(self, msg: str): - flat1123 = self._try_flat(msg, self.pretty_name) - if flat1123 is not None: - assert flat1123 is not None - self.write(flat1123) + flat1125 = self._try_flat(msg, self.pretty_name) + if flat1125 is not None: + assert flat1125 is not None + self.write(flat1125) return None else: - fields1122 = msg + fields1124 = msg self.write(":") - self.write(fields1122) + self.write(fields1124) def pretty_ffi_args(self, msg: Sequence[logic_pb2.Abstraction]): - flat1127 = self._try_flat(msg, self.pretty_ffi_args) - if flat1127 is not None: - assert flat1127 is not None - self.write(flat1127) + flat1129 = self._try_flat(msg, self.pretty_ffi_args) + if flat1129 is not None: + assert flat1129 is not None + self.write(flat1129) return None else: - fields1124 = msg + fields1126 = msg self.write("(args") self.indent_sexp() - if not len(fields1124) == 0: + if not len(fields1126) == 0: self.newline() - for i1126, elem1125 in enumerate(fields1124): - if (i1126 > 0): + for i1128, elem1127 in enumerate(fields1126): + if (i1128 > 0): self.newline() - self.pretty_abstraction(elem1125) + self.pretty_abstraction(elem1127) self.dedent() self.write(")") def pretty_atom(self, msg: logic_pb2.Atom): - flat1134 = self._try_flat(msg, self.pretty_atom) - if flat1134 is not None: - assert flat1134 is not None - self.write(flat1134) + flat1136 = self._try_flat(msg, self.pretty_atom) + if flat1136 is not None: + assert flat1136 is not None + self.write(flat1136) return None else: _dollar_dollar = msg - fields1128 = (_dollar_dollar.name, _dollar_dollar.terms,) - assert fields1128 is not None - unwrapped_fields1129 = fields1128 + fields1130 = (_dollar_dollar.name, _dollar_dollar.terms,) + assert fields1130 is not None + unwrapped_fields1131 = fields1130 self.write("(atom") self.indent_sexp() self.newline() - field1130 = unwrapped_fields1129[0] - self.pretty_relation_id(field1130) - field1131 = unwrapped_fields1129[1] - if not len(field1131) == 0: + field1132 = unwrapped_fields1131[0] + self.pretty_relation_id(field1132) + field1133 = unwrapped_fields1131[1] + if not len(field1133) == 0: self.newline() - for i1133, elem1132 in enumerate(field1131): - if (i1133 > 0): + for i1135, elem1134 in enumerate(field1133): + if (i1135 > 0): self.newline() - self.pretty_term(elem1132) + self.pretty_term(elem1134) self.dedent() self.write(")") def pretty_pragma(self, msg: logic_pb2.Pragma): - flat1141 = self._try_flat(msg, self.pretty_pragma) - if flat1141 is not None: - assert flat1141 is not None - self.write(flat1141) + flat1143 = self._try_flat(msg, self.pretty_pragma) + if flat1143 is not None: + assert flat1143 is not None + self.write(flat1143) return None else: _dollar_dollar = msg - fields1135 = (_dollar_dollar.name, _dollar_dollar.terms,) - assert fields1135 is not None - unwrapped_fields1136 = fields1135 + fields1137 = (_dollar_dollar.name, _dollar_dollar.terms,) + assert fields1137 is not None + unwrapped_fields1138 = fields1137 self.write("(pragma") self.indent_sexp() self.newline() - field1137 = unwrapped_fields1136[0] - self.pretty_name(field1137) - field1138 = unwrapped_fields1136[1] - if not len(field1138) == 0: + field1139 = unwrapped_fields1138[0] + self.pretty_name(field1139) + field1140 = unwrapped_fields1138[1] + if not len(field1140) == 0: self.newline() - for i1140, elem1139 in enumerate(field1138): - if (i1140 > 0): + for i1142, elem1141 in enumerate(field1140): + if (i1142 > 0): self.newline() - self.pretty_term(elem1139) + self.pretty_term(elem1141) self.dedent() self.write(")") def pretty_primitive(self, msg: logic_pb2.Primitive): - flat1157 = self._try_flat(msg, self.pretty_primitive) - if flat1157 is not None: - assert flat1157 is not None - self.write(flat1157) + flat1159 = self._try_flat(msg, self.pretty_primitive) + if flat1159 is not None: + assert flat1159 is not None + self.write(flat1159) return None else: _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_eq": - _t1693 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) + _t1697 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) else: - _t1693 = None - guard_result1156 = _t1693 - if guard_result1156 is not None: + _t1697 = None + guard_result1158 = _t1697 + if guard_result1158 is not None: self.pretty_eq(msg) else: _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_lt_monotype": - _t1694 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) + _t1698 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) else: - _t1694 = None - guard_result1155 = _t1694 - if guard_result1155 is not None: + _t1698 = None + guard_result1157 = _t1698 + if guard_result1157 is not None: self.pretty_lt(msg) else: _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_lt_eq_monotype": - _t1695 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) + _t1699 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) else: - _t1695 = None - guard_result1154 = _t1695 - if guard_result1154 is not None: + _t1699 = None + guard_result1156 = _t1699 + if guard_result1156 is not None: self.pretty_lt_eq(msg) else: _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_gt_monotype": - _t1696 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) + _t1700 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) else: - _t1696 = None - guard_result1153 = _t1696 - if guard_result1153 is not None: + _t1700 = None + guard_result1155 = _t1700 + if guard_result1155 is not None: self.pretty_gt(msg) else: _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_gt_eq_monotype": - _t1697 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) + _t1701 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) else: - _t1697 = None - guard_result1152 = _t1697 - if guard_result1152 is not None: + _t1701 = None + guard_result1154 = _t1701 + if guard_result1154 is not None: self.pretty_gt_eq(msg) else: _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_add_monotype": - _t1698 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) + _t1702 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) else: - _t1698 = None - guard_result1151 = _t1698 - if guard_result1151 is not None: + _t1702 = None + guard_result1153 = _t1702 + if guard_result1153 is not None: self.pretty_add(msg) else: _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_subtract_monotype": - _t1699 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) + _t1703 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) else: - _t1699 = None - guard_result1150 = _t1699 - if guard_result1150 is not None: + _t1703 = None + guard_result1152 = _t1703 + if guard_result1152 is not None: self.pretty_minus(msg) else: _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_multiply_monotype": - _t1700 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) + _t1704 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) else: - _t1700 = None - guard_result1149 = _t1700 - if guard_result1149 is not None: + _t1704 = None + guard_result1151 = _t1704 + if guard_result1151 is not None: self.pretty_multiply(msg) else: _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_divide_monotype": - _t1701 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) + _t1705 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) else: - _t1701 = None - guard_result1148 = _t1701 - if guard_result1148 is not None: + _t1705 = None + guard_result1150 = _t1705 + if guard_result1150 is not None: self.pretty_divide(msg) else: _dollar_dollar = msg - fields1142 = (_dollar_dollar.name, _dollar_dollar.terms,) - assert fields1142 is not None - unwrapped_fields1143 = fields1142 + fields1144 = (_dollar_dollar.name, _dollar_dollar.terms,) + assert fields1144 is not None + unwrapped_fields1145 = fields1144 self.write("(primitive") self.indent_sexp() self.newline() - field1144 = unwrapped_fields1143[0] - self.pretty_name(field1144) - field1145 = unwrapped_fields1143[1] - if not len(field1145) == 0: + field1146 = unwrapped_fields1145[0] + self.pretty_name(field1146) + field1147 = unwrapped_fields1145[1] + if not len(field1147) == 0: self.newline() - for i1147, elem1146 in enumerate(field1145): - if (i1147 > 0): + for i1149, elem1148 in enumerate(field1147): + if (i1149 > 0): self.newline() - self.pretty_rel_term(elem1146) + self.pretty_rel_term(elem1148) self.dedent() self.write(")") def pretty_eq(self, msg: logic_pb2.Primitive): - flat1162 = self._try_flat(msg, self.pretty_eq) - if flat1162 is not None: - assert flat1162 is not None - self.write(flat1162) + flat1164 = self._try_flat(msg, self.pretty_eq) + if flat1164 is not None: + assert flat1164 is not None + self.write(flat1164) return None else: _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_eq": - _t1702 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) + _t1706 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) else: - _t1702 = None - fields1158 = _t1702 - assert fields1158 is not None - unwrapped_fields1159 = fields1158 + _t1706 = None + fields1160 = _t1706 + assert fields1160 is not None + unwrapped_fields1161 = fields1160 self.write("(=") self.indent_sexp() self.newline() - field1160 = unwrapped_fields1159[0] - self.pretty_term(field1160) + field1162 = unwrapped_fields1161[0] + self.pretty_term(field1162) self.newline() - field1161 = unwrapped_fields1159[1] - self.pretty_term(field1161) + field1163 = unwrapped_fields1161[1] + self.pretty_term(field1163) self.dedent() self.write(")") def pretty_lt(self, msg: logic_pb2.Primitive): - flat1167 = self._try_flat(msg, self.pretty_lt) - if flat1167 is not None: - assert flat1167 is not None - self.write(flat1167) + flat1169 = self._try_flat(msg, self.pretty_lt) + if flat1169 is not None: + assert flat1169 is not None + self.write(flat1169) return None else: _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_lt_monotype": - _t1703 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) + _t1707 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) else: - _t1703 = None - fields1163 = _t1703 - assert fields1163 is not None - unwrapped_fields1164 = fields1163 + _t1707 = None + fields1165 = _t1707 + assert fields1165 is not None + unwrapped_fields1166 = fields1165 self.write("(<") self.indent_sexp() self.newline() - field1165 = unwrapped_fields1164[0] - self.pretty_term(field1165) + field1167 = unwrapped_fields1166[0] + self.pretty_term(field1167) self.newline() - field1166 = unwrapped_fields1164[1] - self.pretty_term(field1166) + field1168 = unwrapped_fields1166[1] + self.pretty_term(field1168) self.dedent() self.write(")") def pretty_lt_eq(self, msg: logic_pb2.Primitive): - flat1172 = self._try_flat(msg, self.pretty_lt_eq) - if flat1172 is not None: - assert flat1172 is not None - self.write(flat1172) + flat1174 = self._try_flat(msg, self.pretty_lt_eq) + if flat1174 is not None: + assert flat1174 is not None + self.write(flat1174) return None else: _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_lt_eq_monotype": - _t1704 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) + _t1708 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) else: - _t1704 = None - fields1168 = _t1704 - assert fields1168 is not None - unwrapped_fields1169 = fields1168 + _t1708 = None + fields1170 = _t1708 + assert fields1170 is not None + unwrapped_fields1171 = fields1170 self.write("(<=") self.indent_sexp() self.newline() - field1170 = unwrapped_fields1169[0] - self.pretty_term(field1170) + field1172 = unwrapped_fields1171[0] + self.pretty_term(field1172) self.newline() - field1171 = unwrapped_fields1169[1] - self.pretty_term(field1171) + field1173 = unwrapped_fields1171[1] + self.pretty_term(field1173) self.dedent() self.write(")") def pretty_gt(self, msg: logic_pb2.Primitive): - flat1177 = self._try_flat(msg, self.pretty_gt) - if flat1177 is not None: - assert flat1177 is not None - self.write(flat1177) + flat1179 = self._try_flat(msg, self.pretty_gt) + if flat1179 is not None: + assert flat1179 is not None + self.write(flat1179) return None else: _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_gt_monotype": - _t1705 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) + _t1709 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) else: - _t1705 = None - fields1173 = _t1705 - assert fields1173 is not None - unwrapped_fields1174 = fields1173 + _t1709 = None + fields1175 = _t1709 + assert fields1175 is not None + unwrapped_fields1176 = fields1175 self.write("(>") self.indent_sexp() self.newline() - field1175 = unwrapped_fields1174[0] - self.pretty_term(field1175) + field1177 = unwrapped_fields1176[0] + self.pretty_term(field1177) self.newline() - field1176 = unwrapped_fields1174[1] - self.pretty_term(field1176) + field1178 = unwrapped_fields1176[1] + self.pretty_term(field1178) self.dedent() self.write(")") def pretty_gt_eq(self, msg: logic_pb2.Primitive): - flat1182 = self._try_flat(msg, self.pretty_gt_eq) - if flat1182 is not None: - assert flat1182 is not None - self.write(flat1182) + flat1184 = self._try_flat(msg, self.pretty_gt_eq) + if flat1184 is not None: + assert flat1184 is not None + self.write(flat1184) return None else: _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_gt_eq_monotype": - _t1706 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) + _t1710 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) else: - _t1706 = None - fields1178 = _t1706 - assert fields1178 is not None - unwrapped_fields1179 = fields1178 + _t1710 = None + fields1180 = _t1710 + assert fields1180 is not None + unwrapped_fields1181 = fields1180 self.write("(>=") self.indent_sexp() self.newline() - field1180 = unwrapped_fields1179[0] - self.pretty_term(field1180) + field1182 = unwrapped_fields1181[0] + self.pretty_term(field1182) self.newline() - field1181 = unwrapped_fields1179[1] - self.pretty_term(field1181) + field1183 = unwrapped_fields1181[1] + self.pretty_term(field1183) self.dedent() self.write(")") def pretty_add(self, msg: logic_pb2.Primitive): - flat1188 = self._try_flat(msg, self.pretty_add) - if flat1188 is not None: - assert flat1188 is not None - self.write(flat1188) + flat1190 = self._try_flat(msg, self.pretty_add) + if flat1190 is not None: + assert flat1190 is not None + self.write(flat1190) return None else: _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_add_monotype": - _t1707 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) + _t1711 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) else: - _t1707 = None - fields1183 = _t1707 - assert fields1183 is not None - unwrapped_fields1184 = fields1183 + _t1711 = None + fields1185 = _t1711 + assert fields1185 is not None + unwrapped_fields1186 = fields1185 self.write("(+") self.indent_sexp() self.newline() - field1185 = unwrapped_fields1184[0] - self.pretty_term(field1185) + field1187 = unwrapped_fields1186[0] + self.pretty_term(field1187) self.newline() - field1186 = unwrapped_fields1184[1] - self.pretty_term(field1186) + field1188 = unwrapped_fields1186[1] + self.pretty_term(field1188) self.newline() - field1187 = unwrapped_fields1184[2] - self.pretty_term(field1187) + field1189 = unwrapped_fields1186[2] + self.pretty_term(field1189) self.dedent() self.write(")") def pretty_minus(self, msg: logic_pb2.Primitive): - flat1194 = self._try_flat(msg, self.pretty_minus) - if flat1194 is not None: - assert flat1194 is not None - self.write(flat1194) + flat1196 = self._try_flat(msg, self.pretty_minus) + if flat1196 is not None: + assert flat1196 is not None + self.write(flat1196) return None else: _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_subtract_monotype": - _t1708 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) + _t1712 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) else: - _t1708 = None - fields1189 = _t1708 - assert fields1189 is not None - unwrapped_fields1190 = fields1189 + _t1712 = None + fields1191 = _t1712 + assert fields1191 is not None + unwrapped_fields1192 = fields1191 self.write("(-") self.indent_sexp() self.newline() - field1191 = unwrapped_fields1190[0] - self.pretty_term(field1191) + field1193 = unwrapped_fields1192[0] + self.pretty_term(field1193) self.newline() - field1192 = unwrapped_fields1190[1] - self.pretty_term(field1192) + field1194 = unwrapped_fields1192[1] + self.pretty_term(field1194) self.newline() - field1193 = unwrapped_fields1190[2] - self.pretty_term(field1193) + field1195 = unwrapped_fields1192[2] + self.pretty_term(field1195) self.dedent() self.write(")") def pretty_multiply(self, msg: logic_pb2.Primitive): - flat1200 = self._try_flat(msg, self.pretty_multiply) - if flat1200 is not None: - assert flat1200 is not None - self.write(flat1200) + flat1202 = self._try_flat(msg, self.pretty_multiply) + if flat1202 is not None: + assert flat1202 is not None + self.write(flat1202) return None else: _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_multiply_monotype": - _t1709 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) + _t1713 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) else: - _t1709 = None - fields1195 = _t1709 - assert fields1195 is not None - unwrapped_fields1196 = fields1195 + _t1713 = None + fields1197 = _t1713 + assert fields1197 is not None + unwrapped_fields1198 = fields1197 self.write("(*") self.indent_sexp() self.newline() - field1197 = unwrapped_fields1196[0] - self.pretty_term(field1197) + field1199 = unwrapped_fields1198[0] + self.pretty_term(field1199) self.newline() - field1198 = unwrapped_fields1196[1] - self.pretty_term(field1198) + field1200 = unwrapped_fields1198[1] + self.pretty_term(field1200) self.newline() - field1199 = unwrapped_fields1196[2] - self.pretty_term(field1199) + field1201 = unwrapped_fields1198[2] + self.pretty_term(field1201) self.dedent() self.write(")") def pretty_divide(self, msg: logic_pb2.Primitive): - flat1206 = self._try_flat(msg, self.pretty_divide) - if flat1206 is not None: - assert flat1206 is not None - self.write(flat1206) + flat1208 = self._try_flat(msg, self.pretty_divide) + if flat1208 is not None: + assert flat1208 is not None + self.write(flat1208) return None else: _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_divide_monotype": - _t1710 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) + _t1714 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) else: - _t1710 = None - fields1201 = _t1710 - assert fields1201 is not None - unwrapped_fields1202 = fields1201 + _t1714 = None + fields1203 = _t1714 + assert fields1203 is not None + unwrapped_fields1204 = fields1203 self.write("(/") self.indent_sexp() self.newline() - field1203 = unwrapped_fields1202[0] - self.pretty_term(field1203) + field1205 = unwrapped_fields1204[0] + self.pretty_term(field1205) self.newline() - field1204 = unwrapped_fields1202[1] - self.pretty_term(field1204) + field1206 = unwrapped_fields1204[1] + self.pretty_term(field1206) self.newline() - field1205 = unwrapped_fields1202[2] - self.pretty_term(field1205) + field1207 = unwrapped_fields1204[2] + self.pretty_term(field1207) self.dedent() self.write(")") def pretty_rel_term(self, msg: logic_pb2.RelTerm): - flat1211 = self._try_flat(msg, self.pretty_rel_term) - if flat1211 is not None: - assert flat1211 is not None - self.write(flat1211) + flat1213 = self._try_flat(msg, self.pretty_rel_term) + if flat1213 is not None: + assert flat1213 is not None + self.write(flat1213) return None else: _dollar_dollar = msg if _dollar_dollar.HasField("specialized_value"): - _t1711 = _dollar_dollar.specialized_value + _t1715 = _dollar_dollar.specialized_value else: - _t1711 = None - deconstruct_result1209 = _t1711 - if deconstruct_result1209 is not None: - assert deconstruct_result1209 is not None - unwrapped1210 = deconstruct_result1209 - self.pretty_specialized_value(unwrapped1210) + _t1715 = None + deconstruct_result1211 = _t1715 + if deconstruct_result1211 is not None: + assert deconstruct_result1211 is not None + unwrapped1212 = deconstruct_result1211 + self.pretty_specialized_value(unwrapped1212) else: _dollar_dollar = msg if _dollar_dollar.HasField("term"): - _t1712 = _dollar_dollar.term + _t1716 = _dollar_dollar.term else: - _t1712 = None - deconstruct_result1207 = _t1712 - if deconstruct_result1207 is not None: - assert deconstruct_result1207 is not None - unwrapped1208 = deconstruct_result1207 - self.pretty_term(unwrapped1208) + _t1716 = None + deconstruct_result1209 = _t1716 + if deconstruct_result1209 is not None: + assert deconstruct_result1209 is not None + unwrapped1210 = deconstruct_result1209 + self.pretty_term(unwrapped1210) else: raise ParseError("No matching rule for rel_term") def pretty_specialized_value(self, msg: logic_pb2.Value): - flat1213 = self._try_flat(msg, self.pretty_specialized_value) - if flat1213 is not None: - assert flat1213 is not None - self.write(flat1213) + flat1215 = self._try_flat(msg, self.pretty_specialized_value) + if flat1215 is not None: + assert flat1215 is not None + self.write(flat1215) return None else: - fields1212 = msg + fields1214 = msg self.write("#") - self.pretty_raw_value(fields1212) + self.pretty_raw_value(fields1214) def pretty_rel_atom(self, msg: logic_pb2.RelAtom): - flat1220 = self._try_flat(msg, self.pretty_rel_atom) - if flat1220 is not None: - assert flat1220 is not None - self.write(flat1220) + flat1222 = self._try_flat(msg, self.pretty_rel_atom) + if flat1222 is not None: + assert flat1222 is not None + self.write(flat1222) return None else: _dollar_dollar = msg - fields1214 = (_dollar_dollar.name, _dollar_dollar.terms,) - assert fields1214 is not None - unwrapped_fields1215 = fields1214 + fields1216 = (_dollar_dollar.name, _dollar_dollar.terms,) + assert fields1216 is not None + unwrapped_fields1217 = fields1216 self.write("(relatom") self.indent_sexp() self.newline() - field1216 = unwrapped_fields1215[0] - self.pretty_name(field1216) - field1217 = unwrapped_fields1215[1] - if not len(field1217) == 0: + field1218 = unwrapped_fields1217[0] + self.pretty_name(field1218) + field1219 = unwrapped_fields1217[1] + if not len(field1219) == 0: self.newline() - for i1219, elem1218 in enumerate(field1217): - if (i1219 > 0): + for i1221, elem1220 in enumerate(field1219): + if (i1221 > 0): self.newline() - self.pretty_rel_term(elem1218) + self.pretty_rel_term(elem1220) self.dedent() self.write(")") def pretty_cast(self, msg: logic_pb2.Cast): - flat1225 = self._try_flat(msg, self.pretty_cast) - if flat1225 is not None: - assert flat1225 is not None - self.write(flat1225) + flat1227 = self._try_flat(msg, self.pretty_cast) + if flat1227 is not None: + assert flat1227 is not None + self.write(flat1227) return None else: _dollar_dollar = msg - fields1221 = (_dollar_dollar.input, _dollar_dollar.result,) - assert fields1221 is not None - unwrapped_fields1222 = fields1221 + fields1223 = (_dollar_dollar.input, _dollar_dollar.result,) + assert fields1223 is not None + unwrapped_fields1224 = fields1223 self.write("(cast") self.indent_sexp() self.newline() - field1223 = unwrapped_fields1222[0] - self.pretty_term(field1223) + field1225 = unwrapped_fields1224[0] + self.pretty_term(field1225) self.newline() - field1224 = unwrapped_fields1222[1] - self.pretty_term(field1224) + field1226 = unwrapped_fields1224[1] + self.pretty_term(field1226) self.dedent() self.write(")") def pretty_attrs(self, msg: Sequence[logic_pb2.Attribute]): - flat1229 = self._try_flat(msg, self.pretty_attrs) - if flat1229 is not None: - assert flat1229 is not None - self.write(flat1229) + flat1231 = self._try_flat(msg, self.pretty_attrs) + if flat1231 is not None: + assert flat1231 is not None + self.write(flat1231) return None else: - fields1226 = msg + fields1228 = msg self.write("(attrs") self.indent_sexp() - if not len(fields1226) == 0: + if not len(fields1228) == 0: self.newline() - for i1228, elem1227 in enumerate(fields1226): - if (i1228 > 0): + for i1230, elem1229 in enumerate(fields1228): + if (i1230 > 0): self.newline() - self.pretty_attribute(elem1227) + self.pretty_attribute(elem1229) self.dedent() self.write(")") def pretty_attribute(self, msg: logic_pb2.Attribute): - flat1236 = self._try_flat(msg, self.pretty_attribute) - if flat1236 is not None: - assert flat1236 is not None - self.write(flat1236) + flat1238 = self._try_flat(msg, self.pretty_attribute) + if flat1238 is not None: + assert flat1238 is not None + self.write(flat1238) return None else: _dollar_dollar = msg - fields1230 = (_dollar_dollar.name, _dollar_dollar.args,) - assert fields1230 is not None - unwrapped_fields1231 = fields1230 + fields1232 = (_dollar_dollar.name, _dollar_dollar.args,) + assert fields1232 is not None + unwrapped_fields1233 = fields1232 self.write("(attribute") self.indent_sexp() self.newline() - field1232 = unwrapped_fields1231[0] - self.pretty_name(field1232) - field1233 = unwrapped_fields1231[1] - if not len(field1233) == 0: + field1234 = unwrapped_fields1233[0] + self.pretty_name(field1234) + field1235 = unwrapped_fields1233[1] + if not len(field1235) == 0: self.newline() - for i1235, elem1234 in enumerate(field1233): - if (i1235 > 0): + for i1237, elem1236 in enumerate(field1235): + if (i1237 > 0): self.newline() - self.pretty_raw_value(elem1234) + self.pretty_raw_value(elem1236) self.dedent() self.write(")") def pretty_algorithm(self, msg: logic_pb2.Algorithm): - flat1245 = self._try_flat(msg, self.pretty_algorithm) - if flat1245 is not None: - assert flat1245 is not None - self.write(flat1245) + flat1247 = self._try_flat(msg, self.pretty_algorithm) + if flat1247 is not None: + assert flat1247 is not None + self.write(flat1247) return None else: _dollar_dollar = msg if not len(_dollar_dollar.attrs) == 0: - _t1713 = _dollar_dollar.attrs + _t1717 = _dollar_dollar.attrs else: - _t1713 = None - fields1237 = (getattr(_dollar_dollar, 'global'), _dollar_dollar.body, _t1713,) - assert fields1237 is not None - unwrapped_fields1238 = fields1237 + _t1717 = None + fields1239 = (getattr(_dollar_dollar, 'global'), _dollar_dollar.body, _t1717,) + assert fields1239 is not None + unwrapped_fields1240 = fields1239 self.write("(algorithm") self.indent_sexp() - field1239 = unwrapped_fields1238[0] - if not len(field1239) == 0: + field1241 = unwrapped_fields1240[0] + if not len(field1241) == 0: self.newline() - for i1241, elem1240 in enumerate(field1239): - if (i1241 > 0): + for i1243, elem1242 in enumerate(field1241): + if (i1243 > 0): self.newline() - self.pretty_relation_id(elem1240) + self.pretty_relation_id(elem1242) self.newline() - field1242 = unwrapped_fields1238[1] - self.pretty_script(field1242) - field1243 = unwrapped_fields1238[2] - if field1243 is not None: + field1244 = unwrapped_fields1240[1] + self.pretty_script(field1244) + field1245 = unwrapped_fields1240[2] + if field1245 is not None: self.newline() - assert field1243 is not None - opt_val1244 = field1243 - self.pretty_attrs(opt_val1244) + assert field1245 is not None + opt_val1246 = field1245 + self.pretty_attrs(opt_val1246) self.dedent() self.write(")") def pretty_script(self, msg: logic_pb2.Script): - flat1250 = self._try_flat(msg, self.pretty_script) - if flat1250 is not None: - assert flat1250 is not None - self.write(flat1250) + flat1252 = self._try_flat(msg, self.pretty_script) + if flat1252 is not None: + assert flat1252 is not None + self.write(flat1252) return None else: _dollar_dollar = msg - fields1246 = _dollar_dollar.constructs - assert fields1246 is not None - unwrapped_fields1247 = fields1246 + fields1248 = _dollar_dollar.constructs + assert fields1248 is not None + unwrapped_fields1249 = fields1248 self.write("(script") self.indent_sexp() - if not len(unwrapped_fields1247) == 0: + if not len(unwrapped_fields1249) == 0: self.newline() - for i1249, elem1248 in enumerate(unwrapped_fields1247): - if (i1249 > 0): + for i1251, elem1250 in enumerate(unwrapped_fields1249): + if (i1251 > 0): self.newline() - self.pretty_construct(elem1248) + self.pretty_construct(elem1250) self.dedent() self.write(")") def pretty_construct(self, msg: logic_pb2.Construct): - flat1255 = self._try_flat(msg, self.pretty_construct) - if flat1255 is not None: - assert flat1255 is not None - self.write(flat1255) + flat1257 = self._try_flat(msg, self.pretty_construct) + if flat1257 is not None: + assert flat1257 is not None + self.write(flat1257) return None else: _dollar_dollar = msg if _dollar_dollar.HasField("loop"): - _t1714 = _dollar_dollar.loop + _t1718 = _dollar_dollar.loop else: - _t1714 = None - deconstruct_result1253 = _t1714 - if deconstruct_result1253 is not None: - assert deconstruct_result1253 is not None - unwrapped1254 = deconstruct_result1253 - self.pretty_loop(unwrapped1254) + _t1718 = None + deconstruct_result1255 = _t1718 + if deconstruct_result1255 is not None: + assert deconstruct_result1255 is not None + unwrapped1256 = deconstruct_result1255 + self.pretty_loop(unwrapped1256) else: _dollar_dollar = msg if _dollar_dollar.HasField("instruction"): - _t1715 = _dollar_dollar.instruction + _t1719 = _dollar_dollar.instruction else: - _t1715 = None - deconstruct_result1251 = _t1715 - if deconstruct_result1251 is not None: - assert deconstruct_result1251 is not None - unwrapped1252 = deconstruct_result1251 - self.pretty_instruction(unwrapped1252) + _t1719 = None + deconstruct_result1253 = _t1719 + if deconstruct_result1253 is not None: + assert deconstruct_result1253 is not None + unwrapped1254 = deconstruct_result1253 + self.pretty_instruction(unwrapped1254) else: raise ParseError("No matching rule for construct") def pretty_loop(self, msg: logic_pb2.Loop): - flat1262 = self._try_flat(msg, self.pretty_loop) - if flat1262 is not None: - assert flat1262 is not None - self.write(flat1262) + flat1264 = self._try_flat(msg, self.pretty_loop) + if flat1264 is not None: + assert flat1264 is not None + self.write(flat1264) return None else: _dollar_dollar = msg if not len(_dollar_dollar.attrs) == 0: - _t1716 = _dollar_dollar.attrs + _t1720 = _dollar_dollar.attrs else: - _t1716 = None - fields1256 = (_dollar_dollar.init, _dollar_dollar.body, _t1716,) - assert fields1256 is not None - unwrapped_fields1257 = fields1256 + _t1720 = None + fields1258 = (_dollar_dollar.init, _dollar_dollar.body, _t1720,) + assert fields1258 is not None + unwrapped_fields1259 = fields1258 self.write("(loop") self.indent_sexp() self.newline() - field1258 = unwrapped_fields1257[0] - self.pretty_init(field1258) + field1260 = unwrapped_fields1259[0] + self.pretty_init(field1260) self.newline() - field1259 = unwrapped_fields1257[1] - self.pretty_script(field1259) - field1260 = unwrapped_fields1257[2] - if field1260 is not None: + field1261 = unwrapped_fields1259[1] + self.pretty_script(field1261) + field1262 = unwrapped_fields1259[2] + if field1262 is not None: self.newline() - assert field1260 is not None - opt_val1261 = field1260 - self.pretty_attrs(opt_val1261) + assert field1262 is not None + opt_val1263 = field1262 + self.pretty_attrs(opt_val1263) self.dedent() self.write(")") def pretty_init(self, msg: Sequence[logic_pb2.Instruction]): - flat1266 = self._try_flat(msg, self.pretty_init) - if flat1266 is not None: - assert flat1266 is not None - self.write(flat1266) + flat1268 = self._try_flat(msg, self.pretty_init) + if flat1268 is not None: + assert flat1268 is not None + self.write(flat1268) return None else: - fields1263 = msg + fields1265 = msg self.write("(init") self.indent_sexp() - if not len(fields1263) == 0: + if not len(fields1265) == 0: self.newline() - for i1265, elem1264 in enumerate(fields1263): - if (i1265 > 0): + for i1267, elem1266 in enumerate(fields1265): + if (i1267 > 0): self.newline() - self.pretty_instruction(elem1264) + self.pretty_instruction(elem1266) self.dedent() self.write(")") def pretty_instruction(self, msg: logic_pb2.Instruction): - flat1277 = self._try_flat(msg, self.pretty_instruction) - if flat1277 is not None: - assert flat1277 is not None - self.write(flat1277) + flat1279 = self._try_flat(msg, self.pretty_instruction) + if flat1279 is not None: + assert flat1279 is not None + self.write(flat1279) return None else: _dollar_dollar = msg if _dollar_dollar.HasField("assign"): - _t1717 = _dollar_dollar.assign + _t1721 = _dollar_dollar.assign else: - _t1717 = None - deconstruct_result1275 = _t1717 - if deconstruct_result1275 is not None: - assert deconstruct_result1275 is not None - unwrapped1276 = deconstruct_result1275 - self.pretty_assign(unwrapped1276) + _t1721 = None + deconstruct_result1277 = _t1721 + if deconstruct_result1277 is not None: + assert deconstruct_result1277 is not None + unwrapped1278 = deconstruct_result1277 + self.pretty_assign(unwrapped1278) else: _dollar_dollar = msg if _dollar_dollar.HasField("upsert"): - _t1718 = _dollar_dollar.upsert + _t1722 = _dollar_dollar.upsert else: - _t1718 = None - deconstruct_result1273 = _t1718 - if deconstruct_result1273 is not None: - assert deconstruct_result1273 is not None - unwrapped1274 = deconstruct_result1273 - self.pretty_upsert(unwrapped1274) + _t1722 = None + deconstruct_result1275 = _t1722 + if deconstruct_result1275 is not None: + assert deconstruct_result1275 is not None + unwrapped1276 = deconstruct_result1275 + self.pretty_upsert(unwrapped1276) else: _dollar_dollar = msg if _dollar_dollar.HasField("break"): - _t1719 = getattr(_dollar_dollar, 'break') + _t1723 = getattr(_dollar_dollar, 'break') else: - _t1719 = None - deconstruct_result1271 = _t1719 - if deconstruct_result1271 is not None: - assert deconstruct_result1271 is not None - unwrapped1272 = deconstruct_result1271 - self.pretty_break(unwrapped1272) + _t1723 = None + deconstruct_result1273 = _t1723 + if deconstruct_result1273 is not None: + assert deconstruct_result1273 is not None + unwrapped1274 = deconstruct_result1273 + self.pretty_break(unwrapped1274) else: _dollar_dollar = msg if _dollar_dollar.HasField("monoid_def"): - _t1720 = _dollar_dollar.monoid_def + _t1724 = _dollar_dollar.monoid_def else: - _t1720 = None - deconstruct_result1269 = _t1720 - if deconstruct_result1269 is not None: - assert deconstruct_result1269 is not None - unwrapped1270 = deconstruct_result1269 - self.pretty_monoid_def(unwrapped1270) + _t1724 = None + deconstruct_result1271 = _t1724 + if deconstruct_result1271 is not None: + assert deconstruct_result1271 is not None + unwrapped1272 = deconstruct_result1271 + self.pretty_monoid_def(unwrapped1272) else: _dollar_dollar = msg if _dollar_dollar.HasField("monus_def"): - _t1721 = _dollar_dollar.monus_def + _t1725 = _dollar_dollar.monus_def else: - _t1721 = None - deconstruct_result1267 = _t1721 - if deconstruct_result1267 is not None: - assert deconstruct_result1267 is not None - unwrapped1268 = deconstruct_result1267 - self.pretty_monus_def(unwrapped1268) + _t1725 = None + deconstruct_result1269 = _t1725 + if deconstruct_result1269 is not None: + assert deconstruct_result1269 is not None + unwrapped1270 = deconstruct_result1269 + self.pretty_monus_def(unwrapped1270) else: raise ParseError("No matching rule for instruction") def pretty_assign(self, msg: logic_pb2.Assign): - flat1284 = self._try_flat(msg, self.pretty_assign) - if flat1284 is not None: - assert flat1284 is not None - self.write(flat1284) + flat1286 = self._try_flat(msg, self.pretty_assign) + if flat1286 is not None: + assert flat1286 is not None + self.write(flat1286) return None else: _dollar_dollar = msg if not len(_dollar_dollar.attrs) == 0: - _t1722 = _dollar_dollar.attrs + _t1726 = _dollar_dollar.attrs else: - _t1722 = None - fields1278 = (_dollar_dollar.name, _dollar_dollar.body, _t1722,) - assert fields1278 is not None - unwrapped_fields1279 = fields1278 + _t1726 = None + fields1280 = (_dollar_dollar.name, _dollar_dollar.body, _t1726,) + assert fields1280 is not None + unwrapped_fields1281 = fields1280 self.write("(assign") self.indent_sexp() self.newline() - field1280 = unwrapped_fields1279[0] - self.pretty_relation_id(field1280) + field1282 = unwrapped_fields1281[0] + self.pretty_relation_id(field1282) self.newline() - field1281 = unwrapped_fields1279[1] - self.pretty_abstraction(field1281) - field1282 = unwrapped_fields1279[2] - if field1282 is not None: + field1283 = unwrapped_fields1281[1] + self.pretty_abstraction(field1283) + field1284 = unwrapped_fields1281[2] + if field1284 is not None: self.newline() - assert field1282 is not None - opt_val1283 = field1282 - self.pretty_attrs(opt_val1283) + assert field1284 is not None + opt_val1285 = field1284 + self.pretty_attrs(opt_val1285) self.dedent() self.write(")") def pretty_upsert(self, msg: logic_pb2.Upsert): - flat1291 = self._try_flat(msg, self.pretty_upsert) - if flat1291 is not None: - assert flat1291 is not None - self.write(flat1291) + flat1293 = self._try_flat(msg, self.pretty_upsert) + if flat1293 is not None: + assert flat1293 is not None + self.write(flat1293) return None else: _dollar_dollar = msg if not len(_dollar_dollar.attrs) == 0: - _t1723 = _dollar_dollar.attrs + _t1727 = _dollar_dollar.attrs else: - _t1723 = None - fields1285 = (_dollar_dollar.name, (_dollar_dollar.body, _dollar_dollar.value_arity,), _t1723,) - assert fields1285 is not None - unwrapped_fields1286 = fields1285 + _t1727 = None + fields1287 = (_dollar_dollar.name, (_dollar_dollar.body, _dollar_dollar.value_arity,), _t1727,) + assert fields1287 is not None + unwrapped_fields1288 = fields1287 self.write("(upsert") self.indent_sexp() self.newline() - field1287 = unwrapped_fields1286[0] - self.pretty_relation_id(field1287) + field1289 = unwrapped_fields1288[0] + self.pretty_relation_id(field1289) self.newline() - field1288 = unwrapped_fields1286[1] - self.pretty_abstraction_with_arity(field1288) - field1289 = unwrapped_fields1286[2] - if field1289 is not None: + field1290 = unwrapped_fields1288[1] + self.pretty_abstraction_with_arity(field1290) + field1291 = unwrapped_fields1288[2] + if field1291 is not None: self.newline() - assert field1289 is not None - opt_val1290 = field1289 - self.pretty_attrs(opt_val1290) + assert field1291 is not None + opt_val1292 = field1291 + self.pretty_attrs(opt_val1292) self.dedent() self.write(")") def pretty_abstraction_with_arity(self, msg: tuple[logic_pb2.Abstraction, int]): - flat1296 = self._try_flat(msg, self.pretty_abstraction_with_arity) - if flat1296 is not None: - assert flat1296 is not None - self.write(flat1296) + flat1298 = self._try_flat(msg, self.pretty_abstraction_with_arity) + if flat1298 is not None: + assert flat1298 is not None + self.write(flat1298) return None else: _dollar_dollar = msg - _t1724 = self.deconstruct_bindings_with_arity(_dollar_dollar[0], _dollar_dollar[1]) - fields1292 = (_t1724, _dollar_dollar[0].value,) - assert fields1292 is not None - unwrapped_fields1293 = fields1292 + _t1728 = self.deconstruct_bindings_with_arity(_dollar_dollar[0], _dollar_dollar[1]) + fields1294 = (_t1728, _dollar_dollar[0].value,) + assert fields1294 is not None + unwrapped_fields1295 = fields1294 self.write("(") self.indent() - field1294 = unwrapped_fields1293[0] - self.pretty_bindings(field1294) + field1296 = unwrapped_fields1295[0] + self.pretty_bindings(field1296) self.newline() - field1295 = unwrapped_fields1293[1] - self.pretty_formula(field1295) + field1297 = unwrapped_fields1295[1] + self.pretty_formula(field1297) self.dedent() self.write(")") def pretty_break(self, msg: logic_pb2.Break): - flat1303 = self._try_flat(msg, self.pretty_break) - if flat1303 is not None: - assert flat1303 is not None - self.write(flat1303) + flat1305 = self._try_flat(msg, self.pretty_break) + if flat1305 is not None: + assert flat1305 is not None + self.write(flat1305) return None else: _dollar_dollar = msg if not len(_dollar_dollar.attrs) == 0: - _t1725 = _dollar_dollar.attrs + _t1729 = _dollar_dollar.attrs else: - _t1725 = None - fields1297 = (_dollar_dollar.name, _dollar_dollar.body, _t1725,) - assert fields1297 is not None - unwrapped_fields1298 = fields1297 + _t1729 = None + fields1299 = (_dollar_dollar.name, _dollar_dollar.body, _t1729,) + assert fields1299 is not None + unwrapped_fields1300 = fields1299 self.write("(break") self.indent_sexp() self.newline() - field1299 = unwrapped_fields1298[0] - self.pretty_relation_id(field1299) + field1301 = unwrapped_fields1300[0] + self.pretty_relation_id(field1301) self.newline() - field1300 = unwrapped_fields1298[1] - self.pretty_abstraction(field1300) - field1301 = unwrapped_fields1298[2] - if field1301 is not None: + field1302 = unwrapped_fields1300[1] + self.pretty_abstraction(field1302) + field1303 = unwrapped_fields1300[2] + if field1303 is not None: self.newline() - assert field1301 is not None - opt_val1302 = field1301 - self.pretty_attrs(opt_val1302) + assert field1303 is not None + opt_val1304 = field1303 + self.pretty_attrs(opt_val1304) self.dedent() self.write(")") def pretty_monoid_def(self, msg: logic_pb2.MonoidDef): - flat1311 = self._try_flat(msg, self.pretty_monoid_def) - if flat1311 is not None: - assert flat1311 is not None - self.write(flat1311) + flat1313 = self._try_flat(msg, self.pretty_monoid_def) + if flat1313 is not None: + assert flat1313 is not None + self.write(flat1313) return None else: _dollar_dollar = msg if not len(_dollar_dollar.attrs) == 0: - _t1726 = _dollar_dollar.attrs + _t1730 = _dollar_dollar.attrs else: - _t1726 = None - fields1304 = (_dollar_dollar.monoid, _dollar_dollar.name, (_dollar_dollar.body, _dollar_dollar.value_arity,), _t1726,) - assert fields1304 is not None - unwrapped_fields1305 = fields1304 + _t1730 = None + fields1306 = (_dollar_dollar.monoid, _dollar_dollar.name, (_dollar_dollar.body, _dollar_dollar.value_arity,), _t1730,) + assert fields1306 is not None + unwrapped_fields1307 = fields1306 self.write("(monoid") self.indent_sexp() self.newline() - field1306 = unwrapped_fields1305[0] - self.pretty_monoid(field1306) + field1308 = unwrapped_fields1307[0] + self.pretty_monoid(field1308) self.newline() - field1307 = unwrapped_fields1305[1] - self.pretty_relation_id(field1307) + field1309 = unwrapped_fields1307[1] + self.pretty_relation_id(field1309) self.newline() - field1308 = unwrapped_fields1305[2] - self.pretty_abstraction_with_arity(field1308) - field1309 = unwrapped_fields1305[3] - if field1309 is not None: + field1310 = unwrapped_fields1307[2] + self.pretty_abstraction_with_arity(field1310) + field1311 = unwrapped_fields1307[3] + if field1311 is not None: self.newline() - assert field1309 is not None - opt_val1310 = field1309 - self.pretty_attrs(opt_val1310) + assert field1311 is not None + opt_val1312 = field1311 + self.pretty_attrs(opt_val1312) self.dedent() self.write(")") def pretty_monoid(self, msg: logic_pb2.Monoid): - flat1320 = self._try_flat(msg, self.pretty_monoid) - if flat1320 is not None: - assert flat1320 is not None - self.write(flat1320) + flat1322 = self._try_flat(msg, self.pretty_monoid) + if flat1322 is not None: + assert flat1322 is not None + self.write(flat1322) return None else: _dollar_dollar = msg if _dollar_dollar.HasField("or_monoid"): - _t1727 = _dollar_dollar.or_monoid + _t1731 = _dollar_dollar.or_monoid else: - _t1727 = None - deconstruct_result1318 = _t1727 - if deconstruct_result1318 is not None: - assert deconstruct_result1318 is not None - unwrapped1319 = deconstruct_result1318 - self.pretty_or_monoid(unwrapped1319) + _t1731 = None + deconstruct_result1320 = _t1731 + if deconstruct_result1320 is not None: + assert deconstruct_result1320 is not None + unwrapped1321 = deconstruct_result1320 + self.pretty_or_monoid(unwrapped1321) else: _dollar_dollar = msg if _dollar_dollar.HasField("min_monoid"): - _t1728 = _dollar_dollar.min_monoid + _t1732 = _dollar_dollar.min_monoid else: - _t1728 = None - deconstruct_result1316 = _t1728 - if deconstruct_result1316 is not None: - assert deconstruct_result1316 is not None - unwrapped1317 = deconstruct_result1316 - self.pretty_min_monoid(unwrapped1317) + _t1732 = None + deconstruct_result1318 = _t1732 + if deconstruct_result1318 is not None: + assert deconstruct_result1318 is not None + unwrapped1319 = deconstruct_result1318 + self.pretty_min_monoid(unwrapped1319) else: _dollar_dollar = msg if _dollar_dollar.HasField("max_monoid"): - _t1729 = _dollar_dollar.max_monoid + _t1733 = _dollar_dollar.max_monoid else: - _t1729 = None - deconstruct_result1314 = _t1729 - if deconstruct_result1314 is not None: - assert deconstruct_result1314 is not None - unwrapped1315 = deconstruct_result1314 - self.pretty_max_monoid(unwrapped1315) + _t1733 = None + deconstruct_result1316 = _t1733 + if deconstruct_result1316 is not None: + assert deconstruct_result1316 is not None + unwrapped1317 = deconstruct_result1316 + self.pretty_max_monoid(unwrapped1317) else: _dollar_dollar = msg if _dollar_dollar.HasField("sum_monoid"): - _t1730 = _dollar_dollar.sum_monoid + _t1734 = _dollar_dollar.sum_monoid else: - _t1730 = None - deconstruct_result1312 = _t1730 - if deconstruct_result1312 is not None: - assert deconstruct_result1312 is not None - unwrapped1313 = deconstruct_result1312 - self.pretty_sum_monoid(unwrapped1313) + _t1734 = None + deconstruct_result1314 = _t1734 + if deconstruct_result1314 is not None: + assert deconstruct_result1314 is not None + unwrapped1315 = deconstruct_result1314 + self.pretty_sum_monoid(unwrapped1315) else: raise ParseError("No matching rule for monoid") def pretty_or_monoid(self, msg: logic_pb2.OrMonoid): - fields1321 = msg + fields1323 = msg self.write("(or)") def pretty_min_monoid(self, msg: logic_pb2.MinMonoid): - flat1324 = self._try_flat(msg, self.pretty_min_monoid) - if flat1324 is not None: - assert flat1324 is not None - self.write(flat1324) + flat1326 = self._try_flat(msg, self.pretty_min_monoid) + if flat1326 is not None: + assert flat1326 is not None + self.write(flat1326) return None else: _dollar_dollar = msg - fields1322 = _dollar_dollar.type - assert fields1322 is not None - unwrapped_fields1323 = fields1322 + fields1324 = _dollar_dollar.type + assert fields1324 is not None + unwrapped_fields1325 = fields1324 self.write("(min") self.indent_sexp() self.newline() - self.pretty_type(unwrapped_fields1323) + self.pretty_type(unwrapped_fields1325) self.dedent() self.write(")") def pretty_max_monoid(self, msg: logic_pb2.MaxMonoid): - flat1327 = self._try_flat(msg, self.pretty_max_monoid) - if flat1327 is not None: - assert flat1327 is not None - self.write(flat1327) + flat1329 = self._try_flat(msg, self.pretty_max_monoid) + if flat1329 is not None: + assert flat1329 is not None + self.write(flat1329) return None else: _dollar_dollar = msg - fields1325 = _dollar_dollar.type - assert fields1325 is not None - unwrapped_fields1326 = fields1325 + fields1327 = _dollar_dollar.type + assert fields1327 is not None + unwrapped_fields1328 = fields1327 self.write("(max") self.indent_sexp() self.newline() - self.pretty_type(unwrapped_fields1326) + self.pretty_type(unwrapped_fields1328) self.dedent() self.write(")") def pretty_sum_monoid(self, msg: logic_pb2.SumMonoid): - flat1330 = self._try_flat(msg, self.pretty_sum_monoid) - if flat1330 is not None: - assert flat1330 is not None - self.write(flat1330) + flat1332 = self._try_flat(msg, self.pretty_sum_monoid) + if flat1332 is not None: + assert flat1332 is not None + self.write(flat1332) return None else: _dollar_dollar = msg - fields1328 = _dollar_dollar.type - assert fields1328 is not None - unwrapped_fields1329 = fields1328 + fields1330 = _dollar_dollar.type + assert fields1330 is not None + unwrapped_fields1331 = fields1330 self.write("(sum") self.indent_sexp() self.newline() - self.pretty_type(unwrapped_fields1329) + self.pretty_type(unwrapped_fields1331) self.dedent() self.write(")") def pretty_monus_def(self, msg: logic_pb2.MonusDef): - flat1338 = self._try_flat(msg, self.pretty_monus_def) - if flat1338 is not None: - assert flat1338 is not None - self.write(flat1338) + flat1340 = self._try_flat(msg, self.pretty_monus_def) + if flat1340 is not None: + assert flat1340 is not None + self.write(flat1340) return None else: _dollar_dollar = msg if not len(_dollar_dollar.attrs) == 0: - _t1731 = _dollar_dollar.attrs + _t1735 = _dollar_dollar.attrs else: - _t1731 = None - fields1331 = (_dollar_dollar.monoid, _dollar_dollar.name, (_dollar_dollar.body, _dollar_dollar.value_arity,), _t1731,) - assert fields1331 is not None - unwrapped_fields1332 = fields1331 + _t1735 = None + fields1333 = (_dollar_dollar.monoid, _dollar_dollar.name, (_dollar_dollar.body, _dollar_dollar.value_arity,), _t1735,) + assert fields1333 is not None + unwrapped_fields1334 = fields1333 self.write("(monus") self.indent_sexp() self.newline() - field1333 = unwrapped_fields1332[0] - self.pretty_monoid(field1333) + field1335 = unwrapped_fields1334[0] + self.pretty_monoid(field1335) self.newline() - field1334 = unwrapped_fields1332[1] - self.pretty_relation_id(field1334) + field1336 = unwrapped_fields1334[1] + self.pretty_relation_id(field1336) self.newline() - field1335 = unwrapped_fields1332[2] - self.pretty_abstraction_with_arity(field1335) - field1336 = unwrapped_fields1332[3] - if field1336 is not None: + field1337 = unwrapped_fields1334[2] + self.pretty_abstraction_with_arity(field1337) + field1338 = unwrapped_fields1334[3] + if field1338 is not None: self.newline() - assert field1336 is not None - opt_val1337 = field1336 - self.pretty_attrs(opt_val1337) + assert field1338 is not None + opt_val1339 = field1338 + self.pretty_attrs(opt_val1339) self.dedent() self.write(")") def pretty_constraint(self, msg: logic_pb2.Constraint): - flat1345 = self._try_flat(msg, self.pretty_constraint) - if flat1345 is not None: - assert flat1345 is not None - self.write(flat1345) + flat1347 = self._try_flat(msg, self.pretty_constraint) + if flat1347 is not None: + assert flat1347 is not None + self.write(flat1347) return None else: _dollar_dollar = msg - fields1339 = (_dollar_dollar.name, _dollar_dollar.functional_dependency.guard, _dollar_dollar.functional_dependency.keys, _dollar_dollar.functional_dependency.values,) - assert fields1339 is not None - unwrapped_fields1340 = fields1339 + fields1341 = (_dollar_dollar.name, _dollar_dollar.functional_dependency.guard, _dollar_dollar.functional_dependency.keys, _dollar_dollar.functional_dependency.values,) + assert fields1341 is not None + unwrapped_fields1342 = fields1341 self.write("(functional_dependency") self.indent_sexp() self.newline() - field1341 = unwrapped_fields1340[0] - self.pretty_relation_id(field1341) + field1343 = unwrapped_fields1342[0] + self.pretty_relation_id(field1343) self.newline() - field1342 = unwrapped_fields1340[1] - self.pretty_abstraction(field1342) + field1344 = unwrapped_fields1342[1] + self.pretty_abstraction(field1344) self.newline() - field1343 = unwrapped_fields1340[2] - self.pretty_functional_dependency_keys(field1343) + field1345 = unwrapped_fields1342[2] + self.pretty_functional_dependency_keys(field1345) self.newline() - field1344 = unwrapped_fields1340[3] - self.pretty_functional_dependency_values(field1344) + field1346 = unwrapped_fields1342[3] + self.pretty_functional_dependency_values(field1346) self.dedent() self.write(")") def pretty_functional_dependency_keys(self, msg: Sequence[logic_pb2.Var]): - flat1349 = self._try_flat(msg, self.pretty_functional_dependency_keys) - if flat1349 is not None: - assert flat1349 is not None - self.write(flat1349) + flat1351 = self._try_flat(msg, self.pretty_functional_dependency_keys) + if flat1351 is not None: + assert flat1351 is not None + self.write(flat1351) return None else: - fields1346 = msg + fields1348 = msg self.write("(keys") self.indent_sexp() - if not len(fields1346) == 0: + if not len(fields1348) == 0: self.newline() - for i1348, elem1347 in enumerate(fields1346): - if (i1348 > 0): + for i1350, elem1349 in enumerate(fields1348): + if (i1350 > 0): self.newline() - self.pretty_var(elem1347) + self.pretty_var(elem1349) self.dedent() self.write(")") def pretty_functional_dependency_values(self, msg: Sequence[logic_pb2.Var]): - flat1353 = self._try_flat(msg, self.pretty_functional_dependency_values) - if flat1353 is not None: - assert flat1353 is not None - self.write(flat1353) + flat1355 = self._try_flat(msg, self.pretty_functional_dependency_values) + if flat1355 is not None: + assert flat1355 is not None + self.write(flat1355) return None else: - fields1350 = msg + fields1352 = msg self.write("(values") self.indent_sexp() - if not len(fields1350) == 0: + if not len(fields1352) == 0: self.newline() - for i1352, elem1351 in enumerate(fields1350): - if (i1352 > 0): + for i1354, elem1353 in enumerate(fields1352): + if (i1354 > 0): self.newline() - self.pretty_var(elem1351) + self.pretty_var(elem1353) self.dedent() self.write(")") def pretty_data(self, msg: logic_pb2.Data): - flat1362 = self._try_flat(msg, self.pretty_data) - if flat1362 is not None: - assert flat1362 is not None - self.write(flat1362) + flat1364 = self._try_flat(msg, self.pretty_data) + if flat1364 is not None: + assert flat1364 is not None + self.write(flat1364) return None else: _dollar_dollar = msg if _dollar_dollar.HasField("edb"): - _t1732 = _dollar_dollar.edb + _t1736 = _dollar_dollar.edb else: - _t1732 = None - deconstruct_result1360 = _t1732 - if deconstruct_result1360 is not None: - assert deconstruct_result1360 is not None - unwrapped1361 = deconstruct_result1360 - self.pretty_edb(unwrapped1361) + _t1736 = None + deconstruct_result1362 = _t1736 + if deconstruct_result1362 is not None: + assert deconstruct_result1362 is not None + unwrapped1363 = deconstruct_result1362 + self.pretty_edb(unwrapped1363) else: _dollar_dollar = msg if _dollar_dollar.HasField("betree_relation"): - _t1733 = _dollar_dollar.betree_relation + _t1737 = _dollar_dollar.betree_relation else: - _t1733 = None - deconstruct_result1358 = _t1733 - if deconstruct_result1358 is not None: - assert deconstruct_result1358 is not None - unwrapped1359 = deconstruct_result1358 - self.pretty_betree_relation(unwrapped1359) + _t1737 = None + deconstruct_result1360 = _t1737 + if deconstruct_result1360 is not None: + assert deconstruct_result1360 is not None + unwrapped1361 = deconstruct_result1360 + self.pretty_betree_relation(unwrapped1361) else: _dollar_dollar = msg if _dollar_dollar.HasField("csv_data"): - _t1734 = _dollar_dollar.csv_data + _t1738 = _dollar_dollar.csv_data else: - _t1734 = None - deconstruct_result1356 = _t1734 - if deconstruct_result1356 is not None: - assert deconstruct_result1356 is not None - unwrapped1357 = deconstruct_result1356 - self.pretty_csv_data(unwrapped1357) + _t1738 = None + deconstruct_result1358 = _t1738 + if deconstruct_result1358 is not None: + assert deconstruct_result1358 is not None + unwrapped1359 = deconstruct_result1358 + self.pretty_csv_data(unwrapped1359) else: _dollar_dollar = msg if _dollar_dollar.HasField("iceberg_data"): - _t1735 = _dollar_dollar.iceberg_data + _t1739 = _dollar_dollar.iceberg_data else: - _t1735 = None - deconstruct_result1354 = _t1735 - if deconstruct_result1354 is not None: - assert deconstruct_result1354 is not None - unwrapped1355 = deconstruct_result1354 - self.pretty_iceberg_data(unwrapped1355) + _t1739 = None + deconstruct_result1356 = _t1739 + if deconstruct_result1356 is not None: + assert deconstruct_result1356 is not None + unwrapped1357 = deconstruct_result1356 + self.pretty_iceberg_data(unwrapped1357) else: raise ParseError("No matching rule for data") def pretty_edb(self, msg: logic_pb2.EDB): - flat1368 = self._try_flat(msg, self.pretty_edb) - if flat1368 is not None: - assert flat1368 is not None - self.write(flat1368) + flat1370 = self._try_flat(msg, self.pretty_edb) + if flat1370 is not None: + assert flat1370 is not None + self.write(flat1370) return None else: _dollar_dollar = msg - fields1363 = (_dollar_dollar.target_id, _dollar_dollar.path, _dollar_dollar.types,) - assert fields1363 is not None - unwrapped_fields1364 = fields1363 + fields1365 = (_dollar_dollar.target_id, _dollar_dollar.path, _dollar_dollar.types,) + assert fields1365 is not None + unwrapped_fields1366 = fields1365 self.write("(edb") self.indent_sexp() self.newline() - field1365 = unwrapped_fields1364[0] - self.pretty_relation_id(field1365) + field1367 = unwrapped_fields1366[0] + self.pretty_relation_id(field1367) self.newline() - field1366 = unwrapped_fields1364[1] - self.pretty_edb_path(field1366) + field1368 = unwrapped_fields1366[1] + self.pretty_edb_path(field1368) self.newline() - field1367 = unwrapped_fields1364[2] - self.pretty_edb_types(field1367) + field1369 = unwrapped_fields1366[2] + self.pretty_edb_types(field1369) self.dedent() self.write(")") def pretty_edb_path(self, msg: Sequence[str]): - flat1372 = self._try_flat(msg, self.pretty_edb_path) - if flat1372 is not None: - assert flat1372 is not None - self.write(flat1372) + flat1374 = self._try_flat(msg, self.pretty_edb_path) + if flat1374 is not None: + assert flat1374 is not None + self.write(flat1374) return None else: - fields1369 = msg + fields1371 = msg self.write("[") self.indent() - for i1371, elem1370 in enumerate(fields1369): - if (i1371 > 0): + for i1373, elem1372 in enumerate(fields1371): + if (i1373 > 0): self.newline() - self.write(self.format_string_value(elem1370)) + self.write(self.format_string_value(elem1372)) self.dedent() self.write("]") def pretty_edb_types(self, msg: Sequence[logic_pb2.Type]): - flat1376 = self._try_flat(msg, self.pretty_edb_types) - if flat1376 is not None: - assert flat1376 is not None - self.write(flat1376) + flat1378 = self._try_flat(msg, self.pretty_edb_types) + if flat1378 is not None: + assert flat1378 is not None + self.write(flat1378) return None else: - fields1373 = msg + fields1375 = msg self.write("[") self.indent() - for i1375, elem1374 in enumerate(fields1373): - if (i1375 > 0): + for i1377, elem1376 in enumerate(fields1375): + if (i1377 > 0): self.newline() - self.pretty_type(elem1374) + self.pretty_type(elem1376) self.dedent() self.write("]") def pretty_betree_relation(self, msg: logic_pb2.BeTreeRelation): - flat1381 = self._try_flat(msg, self.pretty_betree_relation) - if flat1381 is not None: - assert flat1381 is not None - self.write(flat1381) + flat1383 = self._try_flat(msg, self.pretty_betree_relation) + if flat1383 is not None: + assert flat1383 is not None + self.write(flat1383) return None else: _dollar_dollar = msg - fields1377 = (_dollar_dollar.name, _dollar_dollar.relation_info,) - assert fields1377 is not None - unwrapped_fields1378 = fields1377 + fields1379 = (_dollar_dollar.name, _dollar_dollar.relation_info,) + assert fields1379 is not None + unwrapped_fields1380 = fields1379 self.write("(betree_relation") self.indent_sexp() self.newline() - field1379 = unwrapped_fields1378[0] - self.pretty_relation_id(field1379) + field1381 = unwrapped_fields1380[0] + self.pretty_relation_id(field1381) self.newline() - field1380 = unwrapped_fields1378[1] - self.pretty_betree_info(field1380) + field1382 = unwrapped_fields1380[1] + self.pretty_betree_info(field1382) self.dedent() self.write(")") def pretty_betree_info(self, msg: logic_pb2.BeTreeInfo): - flat1387 = self._try_flat(msg, self.pretty_betree_info) - if flat1387 is not None: - assert flat1387 is not None - self.write(flat1387) + flat1389 = self._try_flat(msg, self.pretty_betree_info) + if flat1389 is not None: + assert flat1389 is not None + self.write(flat1389) return None else: _dollar_dollar = msg - _t1736 = self.deconstruct_betree_info_config(_dollar_dollar) - fields1382 = (_dollar_dollar.key_types, _dollar_dollar.value_types, _t1736,) - assert fields1382 is not None - unwrapped_fields1383 = fields1382 + _t1740 = self.deconstruct_betree_info_config(_dollar_dollar) + fields1384 = (_dollar_dollar.key_types, _dollar_dollar.value_types, _t1740,) + assert fields1384 is not None + unwrapped_fields1385 = fields1384 self.write("(betree_info") self.indent_sexp() self.newline() - field1384 = unwrapped_fields1383[0] - self.pretty_betree_info_key_types(field1384) + field1386 = unwrapped_fields1385[0] + self.pretty_betree_info_key_types(field1386) self.newline() - field1385 = unwrapped_fields1383[1] - self.pretty_betree_info_value_types(field1385) + field1387 = unwrapped_fields1385[1] + self.pretty_betree_info_value_types(field1387) self.newline() - field1386 = unwrapped_fields1383[2] - self.pretty_config_dict(field1386) + field1388 = unwrapped_fields1385[2] + self.pretty_config_dict(field1388) self.dedent() self.write(")") def pretty_betree_info_key_types(self, msg: Sequence[logic_pb2.Type]): - flat1391 = self._try_flat(msg, self.pretty_betree_info_key_types) - if flat1391 is not None: - assert flat1391 is not None - self.write(flat1391) + flat1393 = self._try_flat(msg, self.pretty_betree_info_key_types) + if flat1393 is not None: + assert flat1393 is not None + self.write(flat1393) return None else: - fields1388 = msg + fields1390 = msg self.write("(key_types") self.indent_sexp() - if not len(fields1388) == 0: + if not len(fields1390) == 0: self.newline() - for i1390, elem1389 in enumerate(fields1388): - if (i1390 > 0): + for i1392, elem1391 in enumerate(fields1390): + if (i1392 > 0): self.newline() - self.pretty_type(elem1389) + self.pretty_type(elem1391) self.dedent() self.write(")") def pretty_betree_info_value_types(self, msg: Sequence[logic_pb2.Type]): - flat1395 = self._try_flat(msg, self.pretty_betree_info_value_types) - if flat1395 is not None: - assert flat1395 is not None - self.write(flat1395) + flat1397 = self._try_flat(msg, self.pretty_betree_info_value_types) + if flat1397 is not None: + assert flat1397 is not None + self.write(flat1397) return None else: - fields1392 = msg + fields1394 = msg self.write("(value_types") self.indent_sexp() - if not len(fields1392) == 0: + if not len(fields1394) == 0: self.newline() - for i1394, elem1393 in enumerate(fields1392): - if (i1394 > 0): + for i1396, elem1395 in enumerate(fields1394): + if (i1396 > 0): self.newline() - self.pretty_type(elem1393) + self.pretty_type(elem1395) self.dedent() self.write(")") def pretty_csv_data(self, msg: logic_pb2.CSVData): - flat1402 = self._try_flat(msg, self.pretty_csv_data) - if flat1402 is not None: - assert flat1402 is not None - self.write(flat1402) + flat1404 = self._try_flat(msg, self.pretty_csv_data) + if flat1404 is not None: + assert flat1404 is not None + self.write(flat1404) return None else: _dollar_dollar = msg - fields1396 = (_dollar_dollar.locator, _dollar_dollar.config, _dollar_dollar.columns, _dollar_dollar.asof,) - assert fields1396 is not None - unwrapped_fields1397 = fields1396 + fields1398 = (_dollar_dollar.locator, _dollar_dollar.config, _dollar_dollar.columns, _dollar_dollar.asof,) + assert fields1398 is not None + unwrapped_fields1399 = fields1398 self.write("(csv_data") self.indent_sexp() self.newline() - field1398 = unwrapped_fields1397[0] - self.pretty_csvlocator(field1398) + field1400 = unwrapped_fields1399[0] + self.pretty_csvlocator(field1400) self.newline() - field1399 = unwrapped_fields1397[1] - self.pretty_csv_config(field1399) + field1401 = unwrapped_fields1399[1] + self.pretty_csv_config(field1401) self.newline() - field1400 = unwrapped_fields1397[2] - self.pretty_gnf_columns(field1400) + field1402 = unwrapped_fields1399[2] + self.pretty_gnf_columns(field1402) self.newline() - field1401 = unwrapped_fields1397[3] - self.pretty_csv_asof(field1401) + field1403 = unwrapped_fields1399[3] + self.pretty_csv_asof(field1403) self.dedent() self.write(")") def pretty_csvlocator(self, msg: logic_pb2.CSVLocator): - flat1409 = self._try_flat(msg, self.pretty_csvlocator) - if flat1409 is not None: - assert flat1409 is not None - self.write(flat1409) + flat1411 = self._try_flat(msg, self.pretty_csvlocator) + if flat1411 is not None: + assert flat1411 is not None + self.write(flat1411) return None else: _dollar_dollar = msg if not len(_dollar_dollar.paths) == 0: - _t1737 = _dollar_dollar.paths + _t1741 = _dollar_dollar.paths else: - _t1737 = None + _t1741 = None if _dollar_dollar.inline_data.decode('utf-8') != "": - _t1738 = _dollar_dollar.inline_data.decode('utf-8') + _t1742 = _dollar_dollar.inline_data.decode('utf-8') else: - _t1738 = None - fields1403 = (_t1737, _t1738,) - assert fields1403 is not None - unwrapped_fields1404 = fields1403 + _t1742 = None + fields1405 = (_t1741, _t1742,) + assert fields1405 is not None + unwrapped_fields1406 = fields1405 self.write("(csv_locator") self.indent_sexp() - field1405 = unwrapped_fields1404[0] - if field1405 is not None: - self.newline() - assert field1405 is not None - opt_val1406 = field1405 - self.pretty_csv_locator_paths(opt_val1406) - field1407 = unwrapped_fields1404[1] + field1407 = unwrapped_fields1406[0] if field1407 is not None: self.newline() assert field1407 is not None opt_val1408 = field1407 - self.pretty_csv_locator_inline_data(opt_val1408) + self.pretty_csv_locator_paths(opt_val1408) + field1409 = unwrapped_fields1406[1] + if field1409 is not None: + self.newline() + assert field1409 is not None + opt_val1410 = field1409 + self.pretty_csv_locator_inline_data(opt_val1410) self.dedent() self.write(")") def pretty_csv_locator_paths(self, msg: Sequence[str]): - flat1413 = self._try_flat(msg, self.pretty_csv_locator_paths) - if flat1413 is not None: - assert flat1413 is not None - self.write(flat1413) + flat1415 = self._try_flat(msg, self.pretty_csv_locator_paths) + if flat1415 is not None: + assert flat1415 is not None + self.write(flat1415) return None else: - fields1410 = msg + fields1412 = msg self.write("(paths") self.indent_sexp() - if not len(fields1410) == 0: + if not len(fields1412) == 0: self.newline() - for i1412, elem1411 in enumerate(fields1410): - if (i1412 > 0): + for i1414, elem1413 in enumerate(fields1412): + if (i1414 > 0): self.newline() - self.write(self.format_string_value(elem1411)) + self.write(self.format_string_value(elem1413)) self.dedent() self.write(")") def pretty_csv_locator_inline_data(self, msg: str): - flat1415 = self._try_flat(msg, self.pretty_csv_locator_inline_data) - if flat1415 is not None: - assert flat1415 is not None - self.write(flat1415) + flat1417 = self._try_flat(msg, self.pretty_csv_locator_inline_data) + if flat1417 is not None: + assert flat1417 is not None + self.write(flat1417) return None else: - fields1414 = msg + fields1416 = msg self.write("(inline_data") self.indent_sexp() self.newline() - self.write(self.format_string_value(fields1414)) + self.write(self.format_string_value(fields1416)) self.dedent() self.write(")") def pretty_csv_config(self, msg: logic_pb2.CSVConfig): - flat1421 = self._try_flat(msg, self.pretty_csv_config) - if flat1421 is not None: - assert flat1421 is not None - self.write(flat1421) + flat1423 = self._try_flat(msg, self.pretty_csv_config) + if flat1423 is not None: + assert flat1423 is not None + self.write(flat1423) return None else: _dollar_dollar = msg - _t1739 = self.deconstruct_csv_config(_dollar_dollar) - _t1740 = self.deconstruct_csv_storage_integration_optional(_dollar_dollar) - fields1416 = (_t1739, _t1740,) - assert fields1416 is not None - unwrapped_fields1417 = fields1416 + _t1743 = self.deconstruct_csv_config(_dollar_dollar) + _t1744 = self.deconstruct_csv_storage_integration_optional(_dollar_dollar) + fields1418 = (_t1743, _t1744,) + assert fields1418 is not None + unwrapped_fields1419 = fields1418 self.write("(csv_config") self.indent_sexp() self.newline() - field1418 = unwrapped_fields1417[0] - self.pretty_config_dict(field1418) - field1419 = unwrapped_fields1417[1] - if field1419 is not None: + field1420 = unwrapped_fields1419[0] + self.pretty_config_dict(field1420) + field1421 = unwrapped_fields1419[1] + if field1421 is not None: self.newline() - assert field1419 is not None - opt_val1420 = field1419 - self.pretty__storage_integration(opt_val1420) + assert field1421 is not None + opt_val1422 = field1421 + self.pretty__storage_integration(opt_val1422) self.dedent() self.write(")") def pretty__storage_integration(self, msg: Sequence[tuple[str, logic_pb2.Value]]): - flat1423 = self._try_flat(msg, self.pretty__storage_integration) - if flat1423 is not None: - assert flat1423 is not None - self.write(flat1423) + flat1425 = self._try_flat(msg, self.pretty__storage_integration) + if flat1425 is not None: + assert flat1425 is not None + self.write(flat1425) return None else: - fields1422 = msg + fields1424 = msg self.write("(storage_integration") self.indent_sexp() self.newline() - self.pretty_config_dict(fields1422) + self.pretty_config_dict(fields1424) self.dedent() self.write(")") def pretty_gnf_columns(self, msg: Sequence[logic_pb2.GNFColumn]): - flat1427 = self._try_flat(msg, self.pretty_gnf_columns) - if flat1427 is not None: - assert flat1427 is not None - self.write(flat1427) + flat1429 = self._try_flat(msg, self.pretty_gnf_columns) + if flat1429 is not None: + assert flat1429 is not None + self.write(flat1429) return None else: - fields1424 = msg + fields1426 = msg self.write("(columns") self.indent_sexp() - if not len(fields1424) == 0: + if not len(fields1426) == 0: self.newline() - for i1426, elem1425 in enumerate(fields1424): - if (i1426 > 0): + for i1428, elem1427 in enumerate(fields1426): + if (i1428 > 0): self.newline() - self.pretty_gnf_column(elem1425) + self.pretty_gnf_column(elem1427) self.dedent() self.write(")") def pretty_gnf_column(self, msg: logic_pb2.GNFColumn): - flat1436 = self._try_flat(msg, self.pretty_gnf_column) - if flat1436 is not None: - assert flat1436 is not None - self.write(flat1436) + flat1438 = self._try_flat(msg, self.pretty_gnf_column) + if flat1438 is not None: + assert flat1438 is not None + self.write(flat1438) return None else: _dollar_dollar = msg if _dollar_dollar.HasField("target_id"): - _t1741 = _dollar_dollar.target_id + _t1745 = _dollar_dollar.target_id else: - _t1741 = None - fields1428 = (_dollar_dollar.column_path, _t1741, _dollar_dollar.types,) - assert fields1428 is not None - unwrapped_fields1429 = fields1428 + _t1745 = None + fields1430 = (_dollar_dollar.column_path, _t1745, _dollar_dollar.types,) + assert fields1430 is not None + unwrapped_fields1431 = fields1430 self.write("(column") self.indent_sexp() self.newline() - field1430 = unwrapped_fields1429[0] - self.pretty_gnf_column_path(field1430) - field1431 = unwrapped_fields1429[1] - if field1431 is not None: + field1432 = unwrapped_fields1431[0] + self.pretty_gnf_column_path(field1432) + field1433 = unwrapped_fields1431[1] + if field1433 is not None: self.newline() - assert field1431 is not None - opt_val1432 = field1431 - self.pretty_relation_id(opt_val1432) + assert field1433 is not None + opt_val1434 = field1433 + self.pretty_relation_id(opt_val1434) self.newline() self.write("[") - field1433 = unwrapped_fields1429[2] - for i1435, elem1434 in enumerate(field1433): - if (i1435 > 0): + field1435 = unwrapped_fields1431[2] + for i1437, elem1436 in enumerate(field1435): + if (i1437 > 0): self.newline() - self.pretty_type(elem1434) + self.pretty_type(elem1436) self.write("]") self.dedent() self.write(")") def pretty_gnf_column_path(self, msg: Sequence[str]): - flat1443 = self._try_flat(msg, self.pretty_gnf_column_path) - if flat1443 is not None: - assert flat1443 is not None - self.write(flat1443) + flat1445 = self._try_flat(msg, self.pretty_gnf_column_path) + if flat1445 is not None: + assert flat1445 is not None + self.write(flat1445) return None else: _dollar_dollar = msg if len(_dollar_dollar) == 1: - _t1742 = _dollar_dollar[0] + _t1746 = _dollar_dollar[0] else: - _t1742 = None - deconstruct_result1441 = _t1742 - if deconstruct_result1441 is not None: - assert deconstruct_result1441 is not None - unwrapped1442 = deconstruct_result1441 - self.write(self.format_string_value(unwrapped1442)) + _t1746 = None + deconstruct_result1443 = _t1746 + if deconstruct_result1443 is not None: + assert deconstruct_result1443 is not None + unwrapped1444 = deconstruct_result1443 + self.write(self.format_string_value(unwrapped1444)) else: _dollar_dollar = msg if len(_dollar_dollar) != 1: - _t1743 = _dollar_dollar + _t1747 = _dollar_dollar else: - _t1743 = None - deconstruct_result1437 = _t1743 - if deconstruct_result1437 is not None: - assert deconstruct_result1437 is not None - unwrapped1438 = deconstruct_result1437 + _t1747 = None + deconstruct_result1439 = _t1747 + if deconstruct_result1439 is not None: + assert deconstruct_result1439 is not None + unwrapped1440 = deconstruct_result1439 self.write("[") self.indent() - for i1440, elem1439 in enumerate(unwrapped1438): - if (i1440 > 0): + for i1442, elem1441 in enumerate(unwrapped1440): + if (i1442 > 0): self.newline() - self.write(self.format_string_value(elem1439)) + self.write(self.format_string_value(elem1441)) self.dedent() self.write("]") else: raise ParseError("No matching rule for gnf_column_path") def pretty_csv_asof(self, msg: str): - flat1445 = self._try_flat(msg, self.pretty_csv_asof) - if flat1445 is not None: - assert flat1445 is not None - self.write(flat1445) + flat1447 = self._try_flat(msg, self.pretty_csv_asof) + if flat1447 is not None: + assert flat1447 is not None + self.write(flat1447) return None else: - fields1444 = msg + fields1446 = msg self.write("(asof") self.indent_sexp() self.newline() - self.write(self.format_string_value(fields1444)) + self.write(self.format_string_value(fields1446)) self.dedent() self.write(")") def pretty_iceberg_data(self, msg: logic_pb2.IcebergData): - flat1456 = self._try_flat(msg, self.pretty_iceberg_data) - if flat1456 is not None: - assert flat1456 is not None - self.write(flat1456) + flat1458 = self._try_flat(msg, self.pretty_iceberg_data) + if flat1458 is not None: + assert flat1458 is not None + self.write(flat1458) return None else: _dollar_dollar = msg - _t1744 = self.deconstruct_iceberg_data_from_snapshot_optional(_dollar_dollar) - _t1745 = self.deconstruct_iceberg_data_to_snapshot_optional(_dollar_dollar) - fields1446 = (_dollar_dollar.locator, _dollar_dollar.config, _dollar_dollar.columns, _t1744, _t1745, _dollar_dollar.returns_delta,) - assert fields1446 is not None - unwrapped_fields1447 = fields1446 + _t1748 = self.deconstruct_iceberg_data_from_snapshot_optional(_dollar_dollar) + _t1749 = self.deconstruct_iceberg_data_to_snapshot_optional(_dollar_dollar) + fields1448 = (_dollar_dollar.locator, _dollar_dollar.config, _dollar_dollar.columns, _t1748, _t1749, _dollar_dollar.returns_delta,) + assert fields1448 is not None + unwrapped_fields1449 = fields1448 self.write("(iceberg_data") self.indent_sexp() self.newline() - field1448 = unwrapped_fields1447[0] - self.pretty_iceberg_locator(field1448) + field1450 = unwrapped_fields1449[0] + self.pretty_iceberg_locator(field1450) self.newline() - field1449 = unwrapped_fields1447[1] - self.pretty_iceberg_catalog_config(field1449) + field1451 = unwrapped_fields1449[1] + self.pretty_iceberg_catalog_config(field1451) self.newline() - field1450 = unwrapped_fields1447[2] - self.pretty_gnf_columns(field1450) - field1451 = unwrapped_fields1447[3] - if field1451 is not None: - self.newline() - assert field1451 is not None - opt_val1452 = field1451 - self.pretty_iceberg_from_snapshot(opt_val1452) - field1453 = unwrapped_fields1447[4] + field1452 = unwrapped_fields1449[2] + self.pretty_gnf_columns(field1452) + field1453 = unwrapped_fields1449[3] if field1453 is not None: self.newline() assert field1453 is not None opt_val1454 = field1453 - self.pretty_iceberg_to_snapshot(opt_val1454) + self.pretty_iceberg_from_snapshot(opt_val1454) + field1455 = unwrapped_fields1449[4] + if field1455 is not None: + self.newline() + assert field1455 is not None + opt_val1456 = field1455 + self.pretty_iceberg_to_snapshot(opt_val1456) self.newline() - field1455 = unwrapped_fields1447[5] - self.pretty_boolean_value(field1455) + field1457 = unwrapped_fields1449[5] + self.pretty_boolean_value(field1457) self.dedent() self.write(")") def pretty_iceberg_locator(self, msg: logic_pb2.IcebergLocator): - flat1462 = self._try_flat(msg, self.pretty_iceberg_locator) - if flat1462 is not None: - assert flat1462 is not None - self.write(flat1462) + flat1464 = self._try_flat(msg, self.pretty_iceberg_locator) + if flat1464 is not None: + assert flat1464 is not None + self.write(flat1464) return None else: _dollar_dollar = msg - fields1457 = (_dollar_dollar.table_name, _dollar_dollar.namespace, _dollar_dollar.warehouse,) - assert fields1457 is not None - unwrapped_fields1458 = fields1457 + fields1459 = (_dollar_dollar.table_name, _dollar_dollar.namespace, _dollar_dollar.warehouse,) + assert fields1459 is not None + unwrapped_fields1460 = fields1459 self.write("(iceberg_locator") self.indent_sexp() self.newline() - field1459 = unwrapped_fields1458[0] - self.pretty_iceberg_locator_table_name(field1459) + field1461 = unwrapped_fields1460[0] + self.pretty_iceberg_locator_table_name(field1461) self.newline() - field1460 = unwrapped_fields1458[1] - self.pretty_iceberg_locator_namespace(field1460) + field1462 = unwrapped_fields1460[1] + self.pretty_iceberg_locator_namespace(field1462) self.newline() - field1461 = unwrapped_fields1458[2] - self.pretty_iceberg_locator_warehouse(field1461) + field1463 = unwrapped_fields1460[2] + self.pretty_iceberg_locator_warehouse(field1463) self.dedent() self.write(")") def pretty_iceberg_locator_table_name(self, msg: str): - flat1464 = self._try_flat(msg, self.pretty_iceberg_locator_table_name) - if flat1464 is not None: - assert flat1464 is not None - self.write(flat1464) + flat1466 = self._try_flat(msg, self.pretty_iceberg_locator_table_name) + if flat1466 is not None: + assert flat1466 is not None + self.write(flat1466) return None else: - fields1463 = msg + fields1465 = msg self.write("(table_name") self.indent_sexp() self.newline() - self.write(self.format_string_value(fields1463)) + self.write(self.format_string_value(fields1465)) self.dedent() self.write(")") def pretty_iceberg_locator_namespace(self, msg: Sequence[str]): - flat1468 = self._try_flat(msg, self.pretty_iceberg_locator_namespace) - if flat1468 is not None: - assert flat1468 is not None - self.write(flat1468) + flat1470 = self._try_flat(msg, self.pretty_iceberg_locator_namespace) + if flat1470 is not None: + assert flat1470 is not None + self.write(flat1470) return None else: - fields1465 = msg + fields1467 = msg self.write("(namespace") self.indent_sexp() - if not len(fields1465) == 0: + if not len(fields1467) == 0: self.newline() - for i1467, elem1466 in enumerate(fields1465): - if (i1467 > 0): + for i1469, elem1468 in enumerate(fields1467): + if (i1469 > 0): self.newline() - self.write(self.format_string_value(elem1466)) + self.write(self.format_string_value(elem1468)) self.dedent() self.write(")") def pretty_iceberg_locator_warehouse(self, msg: str): - flat1470 = self._try_flat(msg, self.pretty_iceberg_locator_warehouse) - if flat1470 is not None: - assert flat1470 is not None - self.write(flat1470) + flat1472 = self._try_flat(msg, self.pretty_iceberg_locator_warehouse) + if flat1472 is not None: + assert flat1472 is not None + self.write(flat1472) return None else: - fields1469 = msg + fields1471 = msg self.write("(warehouse") self.indent_sexp() self.newline() - self.write(self.format_string_value(fields1469)) + self.write(self.format_string_value(fields1471)) self.dedent() self.write(")") def pretty_iceberg_catalog_config(self, msg: logic_pb2.IcebergCatalogConfig): - flat1478 = self._try_flat(msg, self.pretty_iceberg_catalog_config) - if flat1478 is not None: - assert flat1478 is not None - self.write(flat1478) + flat1480 = self._try_flat(msg, self.pretty_iceberg_catalog_config) + if flat1480 is not None: + assert flat1480 is not None + self.write(flat1480) return None else: _dollar_dollar = msg - _t1746 = self.deconstruct_iceberg_catalog_config_scope_optional(_dollar_dollar) - fields1471 = (_dollar_dollar.catalog_uri, _t1746, sorted(_dollar_dollar.properties.items()), sorted(_dollar_dollar.auth_properties.items()),) - assert fields1471 is not None - unwrapped_fields1472 = fields1471 + _t1750 = self.deconstruct_iceberg_catalog_config_scope_optional(_dollar_dollar) + fields1473 = (_dollar_dollar.catalog_uri, _t1750, sorted(_dollar_dollar.properties.items()), sorted(_dollar_dollar.auth_properties.items()),) + assert fields1473 is not None + unwrapped_fields1474 = fields1473 self.write("(iceberg_catalog_config") self.indent_sexp() self.newline() - field1473 = unwrapped_fields1472[0] - self.pretty_iceberg_catalog_uri(field1473) - field1474 = unwrapped_fields1472[1] - if field1474 is not None: + field1475 = unwrapped_fields1474[0] + self.pretty_iceberg_catalog_uri(field1475) + field1476 = unwrapped_fields1474[1] + if field1476 is not None: self.newline() - assert field1474 is not None - opt_val1475 = field1474 - self.pretty_iceberg_catalog_config_scope(opt_val1475) + assert field1476 is not None + opt_val1477 = field1476 + self.pretty_iceberg_catalog_config_scope(opt_val1477) self.newline() - field1476 = unwrapped_fields1472[2] - self.pretty_iceberg_properties(field1476) + field1478 = unwrapped_fields1474[2] + self.pretty_iceberg_properties(field1478) self.newline() - field1477 = unwrapped_fields1472[3] - self.pretty_iceberg_auth_properties(field1477) + field1479 = unwrapped_fields1474[3] + self.pretty_iceberg_auth_properties(field1479) self.dedent() self.write(")") def pretty_iceberg_catalog_uri(self, msg: str): - flat1480 = self._try_flat(msg, self.pretty_iceberg_catalog_uri) - if flat1480 is not None: - assert flat1480 is not None - self.write(flat1480) + flat1482 = self._try_flat(msg, self.pretty_iceberg_catalog_uri) + if flat1482 is not None: + assert flat1482 is not None + self.write(flat1482) return None else: - fields1479 = msg + fields1481 = msg self.write("(catalog_uri") self.indent_sexp() self.newline() - self.write(self.format_string_value(fields1479)) + self.write(self.format_string_value(fields1481)) self.dedent() self.write(")") def pretty_iceberg_catalog_config_scope(self, msg: str): - flat1482 = self._try_flat(msg, self.pretty_iceberg_catalog_config_scope) - if flat1482 is not None: - assert flat1482 is not None - self.write(flat1482) + flat1484 = self._try_flat(msg, self.pretty_iceberg_catalog_config_scope) + if flat1484 is not None: + assert flat1484 is not None + self.write(flat1484) return None else: - fields1481 = msg + fields1483 = msg self.write("(scope") self.indent_sexp() self.newline() - self.write(self.format_string_value(fields1481)) + self.write(self.format_string_value(fields1483)) self.dedent() self.write(")") def pretty_iceberg_properties(self, msg: Sequence[tuple[str, str]]): - flat1486 = self._try_flat(msg, self.pretty_iceberg_properties) - if flat1486 is not None: - assert flat1486 is not None - self.write(flat1486) + flat1488 = self._try_flat(msg, self.pretty_iceberg_properties) + if flat1488 is not None: + assert flat1488 is not None + self.write(flat1488) return None else: - fields1483 = msg + fields1485 = msg self.write("(properties") self.indent_sexp() - if not len(fields1483) == 0: + if not len(fields1485) == 0: self.newline() - for i1485, elem1484 in enumerate(fields1483): - if (i1485 > 0): + for i1487, elem1486 in enumerate(fields1485): + if (i1487 > 0): self.newline() - self.pretty_iceberg_property_entry(elem1484) + self.pretty_iceberg_property_entry(elem1486) self.dedent() self.write(")") def pretty_iceberg_property_entry(self, msg: tuple[str, str]): - flat1491 = self._try_flat(msg, self.pretty_iceberg_property_entry) - if flat1491 is not None: - assert flat1491 is not None - self.write(flat1491) + flat1493 = self._try_flat(msg, self.pretty_iceberg_property_entry) + if flat1493 is not None: + assert flat1493 is not None + self.write(flat1493) return None else: _dollar_dollar = msg - fields1487 = (_dollar_dollar[0], _dollar_dollar[1],) - assert fields1487 is not None - unwrapped_fields1488 = fields1487 + fields1489 = (_dollar_dollar[0], _dollar_dollar[1],) + assert fields1489 is not None + unwrapped_fields1490 = fields1489 self.write("(prop") self.indent_sexp() self.newline() - field1489 = unwrapped_fields1488[0] - self.write(self.format_string_value(field1489)) + field1491 = unwrapped_fields1490[0] + self.write(self.format_string_value(field1491)) self.newline() - field1490 = unwrapped_fields1488[1] - self.write(self.format_string_value(field1490)) + field1492 = unwrapped_fields1490[1] + self.write(self.format_string_value(field1492)) self.dedent() self.write(")") def pretty_iceberg_auth_properties(self, msg: Sequence[tuple[str, str]]): - flat1495 = self._try_flat(msg, self.pretty_iceberg_auth_properties) - if flat1495 is not None: - assert flat1495 is not None - self.write(flat1495) + flat1497 = self._try_flat(msg, self.pretty_iceberg_auth_properties) + if flat1497 is not None: + assert flat1497 is not None + self.write(flat1497) return None else: - fields1492 = msg + fields1494 = msg self.write("(auth_properties") self.indent_sexp() - if not len(fields1492) == 0: + if not len(fields1494) == 0: self.newline() - for i1494, elem1493 in enumerate(fields1492): - if (i1494 > 0): + for i1496, elem1495 in enumerate(fields1494): + if (i1496 > 0): self.newline() - self.pretty_iceberg_masked_property_entry(elem1493) + self.pretty_iceberg_masked_property_entry(elem1495) self.dedent() self.write(")") def pretty_iceberg_masked_property_entry(self, msg: tuple[str, str]): - flat1500 = self._try_flat(msg, self.pretty_iceberg_masked_property_entry) - if flat1500 is not None: - assert flat1500 is not None - self.write(flat1500) + flat1502 = self._try_flat(msg, self.pretty_iceberg_masked_property_entry) + if flat1502 is not None: + assert flat1502 is not None + self.write(flat1502) return None else: _dollar_dollar = msg - _t1747 = self.mask_secret_value(_dollar_dollar) - fields1496 = (_dollar_dollar[0], _t1747,) - assert fields1496 is not None - unwrapped_fields1497 = fields1496 + _t1751 = self.mask_secret_value(_dollar_dollar) + fields1498 = (_dollar_dollar[0], _t1751,) + assert fields1498 is not None + unwrapped_fields1499 = fields1498 self.write("(prop") self.indent_sexp() self.newline() - field1498 = unwrapped_fields1497[0] - self.write(self.format_string_value(field1498)) + field1500 = unwrapped_fields1499[0] + self.write(self.format_string_value(field1500)) self.newline() - field1499 = unwrapped_fields1497[1] - self.write(self.format_string_value(field1499)) + field1501 = unwrapped_fields1499[1] + self.write(self.format_string_value(field1501)) self.dedent() self.write(")") def pretty_iceberg_from_snapshot(self, msg: str): - flat1502 = self._try_flat(msg, self.pretty_iceberg_from_snapshot) - if flat1502 is not None: - assert flat1502 is not None - self.write(flat1502) + flat1504 = self._try_flat(msg, self.pretty_iceberg_from_snapshot) + if flat1504 is not None: + assert flat1504 is not None + self.write(flat1504) return None else: - fields1501 = msg + fields1503 = msg self.write("(from_snapshot") self.indent_sexp() self.newline() - self.write(self.format_string_value(fields1501)) + self.write(self.format_string_value(fields1503)) self.dedent() self.write(")") def pretty_iceberg_to_snapshot(self, msg: str): - flat1504 = self._try_flat(msg, self.pretty_iceberg_to_snapshot) - if flat1504 is not None: - assert flat1504 is not None - self.write(flat1504) + flat1506 = self._try_flat(msg, self.pretty_iceberg_to_snapshot) + if flat1506 is not None: + assert flat1506 is not None + self.write(flat1506) return None else: - fields1503 = msg + fields1505 = msg self.write("(to_snapshot") self.indent_sexp() self.newline() - self.write(self.format_string_value(fields1503)) + self.write(self.format_string_value(fields1505)) self.dedent() self.write(")") def pretty_undefine(self, msg: transactions_pb2.Undefine): - flat1507 = self._try_flat(msg, self.pretty_undefine) - if flat1507 is not None: - assert flat1507 is not None - self.write(flat1507) + flat1509 = self._try_flat(msg, self.pretty_undefine) + if flat1509 is not None: + assert flat1509 is not None + self.write(flat1509) return None else: _dollar_dollar = msg - fields1505 = _dollar_dollar.fragment_id - assert fields1505 is not None - unwrapped_fields1506 = fields1505 + fields1507 = _dollar_dollar.fragment_id + assert fields1507 is not None + unwrapped_fields1508 = fields1507 self.write("(undefine") self.indent_sexp() self.newline() - self.pretty_fragment_id(unwrapped_fields1506) + self.pretty_fragment_id(unwrapped_fields1508) self.dedent() self.write(")") def pretty_context(self, msg: transactions_pb2.Context): - flat1512 = self._try_flat(msg, self.pretty_context) - if flat1512 is not None: - assert flat1512 is not None - self.write(flat1512) + flat1514 = self._try_flat(msg, self.pretty_context) + if flat1514 is not None: + assert flat1514 is not None + self.write(flat1514) return None else: _dollar_dollar = msg - fields1508 = _dollar_dollar.relations - assert fields1508 is not None - unwrapped_fields1509 = fields1508 + fields1510 = _dollar_dollar.relations + assert fields1510 is not None + unwrapped_fields1511 = fields1510 self.write("(context") self.indent_sexp() - if not len(unwrapped_fields1509) == 0: + if not len(unwrapped_fields1511) == 0: self.newline() - for i1511, elem1510 in enumerate(unwrapped_fields1509): - if (i1511 > 0): + for i1513, elem1512 in enumerate(unwrapped_fields1511): + if (i1513 > 0): self.newline() - self.pretty_relation_id(elem1510) + self.pretty_relation_id(elem1512) self.dedent() self.write(")") def pretty_snapshot(self, msg: transactions_pb2.Snapshot): - flat1519 = self._try_flat(msg, self.pretty_snapshot) - if flat1519 is not None: - assert flat1519 is not None - self.write(flat1519) + flat1521 = self._try_flat(msg, self.pretty_snapshot) + if flat1521 is not None: + assert flat1521 is not None + self.write(flat1521) return None else: _dollar_dollar = msg - fields1513 = (_dollar_dollar.prefix, _dollar_dollar.mappings,) - assert fields1513 is not None - unwrapped_fields1514 = fields1513 + fields1515 = (_dollar_dollar.prefix, _dollar_dollar.mappings,) + assert fields1515 is not None + unwrapped_fields1516 = fields1515 self.write("(snapshot") self.indent_sexp() self.newline() - field1515 = unwrapped_fields1514[0] - self.pretty_edb_path(field1515) - field1516 = unwrapped_fields1514[1] - if not len(field1516) == 0: + field1517 = unwrapped_fields1516[0] + self.pretty_edb_path(field1517) + field1518 = unwrapped_fields1516[1] + if not len(field1518) == 0: self.newline() - for i1518, elem1517 in enumerate(field1516): - if (i1518 > 0): + for i1520, elem1519 in enumerate(field1518): + if (i1520 > 0): self.newline() - self.pretty_snapshot_mapping(elem1517) + self.pretty_snapshot_mapping(elem1519) self.dedent() self.write(")") def pretty_snapshot_mapping(self, msg: transactions_pb2.SnapshotMapping): - flat1524 = self._try_flat(msg, self.pretty_snapshot_mapping) - if flat1524 is not None: - assert flat1524 is not None - self.write(flat1524) + flat1526 = self._try_flat(msg, self.pretty_snapshot_mapping) + if flat1526 is not None: + assert flat1526 is not None + self.write(flat1526) return None else: _dollar_dollar = msg - fields1520 = (_dollar_dollar.destination_path, _dollar_dollar.source_relation,) - assert fields1520 is not None - unwrapped_fields1521 = fields1520 - field1522 = unwrapped_fields1521[0] - self.pretty_edb_path(field1522) + fields1522 = (_dollar_dollar.destination_path, _dollar_dollar.source_relation,) + assert fields1522 is not None + unwrapped_fields1523 = fields1522 + field1524 = unwrapped_fields1523[0] + self.pretty_edb_path(field1524) self.write(" ") - field1523 = unwrapped_fields1521[1] - self.pretty_relation_id(field1523) + field1525 = unwrapped_fields1523[1] + self.pretty_relation_id(field1525) def pretty_epoch_reads(self, msg: Sequence[transactions_pb2.Read]): - flat1528 = self._try_flat(msg, self.pretty_epoch_reads) - if flat1528 is not None: - assert flat1528 is not None - self.write(flat1528) + flat1530 = self._try_flat(msg, self.pretty_epoch_reads) + if flat1530 is not None: + assert flat1530 is not None + self.write(flat1530) return None else: - fields1525 = msg + fields1527 = msg self.write("(reads") self.indent_sexp() - if not len(fields1525) == 0: + if not len(fields1527) == 0: self.newline() - for i1527, elem1526 in enumerate(fields1525): - if (i1527 > 0): + for i1529, elem1528 in enumerate(fields1527): + if (i1529 > 0): self.newline() - self.pretty_read(elem1526) + self.pretty_read(elem1528) self.dedent() self.write(")") def pretty_read(self, msg: transactions_pb2.Read): - flat1541 = self._try_flat(msg, self.pretty_read) - if flat1541 is not None: - assert flat1541 is not None - self.write(flat1541) + flat1543 = self._try_flat(msg, self.pretty_read) + if flat1543 is not None: + assert flat1543 is not None + self.write(flat1543) return None else: _dollar_dollar = msg if _dollar_dollar.HasField("demand"): - _t1748 = _dollar_dollar.demand + _t1752 = _dollar_dollar.demand else: - _t1748 = None - deconstruct_result1539 = _t1748 - if deconstruct_result1539 is not None: - assert deconstruct_result1539 is not None - unwrapped1540 = deconstruct_result1539 - self.pretty_demand(unwrapped1540) + _t1752 = None + deconstruct_result1541 = _t1752 + if deconstruct_result1541 is not None: + assert deconstruct_result1541 is not None + unwrapped1542 = deconstruct_result1541 + self.pretty_demand(unwrapped1542) else: _dollar_dollar = msg if _dollar_dollar.HasField("output"): - _t1749 = _dollar_dollar.output + _t1753 = _dollar_dollar.output else: - _t1749 = None - deconstruct_result1537 = _t1749 - if deconstruct_result1537 is not None: - assert deconstruct_result1537 is not None - unwrapped1538 = deconstruct_result1537 - self.pretty_output(unwrapped1538) + _t1753 = None + deconstruct_result1539 = _t1753 + if deconstruct_result1539 is not None: + assert deconstruct_result1539 is not None + unwrapped1540 = deconstruct_result1539 + self.pretty_output(unwrapped1540) else: _dollar_dollar = msg if _dollar_dollar.HasField("what_if"): - _t1750 = _dollar_dollar.what_if + _t1754 = _dollar_dollar.what_if else: - _t1750 = None - deconstruct_result1535 = _t1750 - if deconstruct_result1535 is not None: - assert deconstruct_result1535 is not None - unwrapped1536 = deconstruct_result1535 - self.pretty_what_if(unwrapped1536) + _t1754 = None + deconstruct_result1537 = _t1754 + if deconstruct_result1537 is not None: + assert deconstruct_result1537 is not None + unwrapped1538 = deconstruct_result1537 + self.pretty_what_if(unwrapped1538) else: _dollar_dollar = msg if _dollar_dollar.HasField("abort"): - _t1751 = _dollar_dollar.abort + _t1755 = _dollar_dollar.abort else: - _t1751 = None - deconstruct_result1533 = _t1751 - if deconstruct_result1533 is not None: - assert deconstruct_result1533 is not None - unwrapped1534 = deconstruct_result1533 - self.pretty_abort(unwrapped1534) + _t1755 = None + deconstruct_result1535 = _t1755 + if deconstruct_result1535 is not None: + assert deconstruct_result1535 is not None + unwrapped1536 = deconstruct_result1535 + self.pretty_abort(unwrapped1536) else: _dollar_dollar = msg if _dollar_dollar.HasField("export"): - _t1752 = _dollar_dollar.export + _t1756 = _dollar_dollar.export else: - _t1752 = None - deconstruct_result1531 = _t1752 - if deconstruct_result1531 is not None: - assert deconstruct_result1531 is not None - unwrapped1532 = deconstruct_result1531 - self.pretty_export(unwrapped1532) + _t1756 = None + deconstruct_result1533 = _t1756 + if deconstruct_result1533 is not None: + assert deconstruct_result1533 is not None + unwrapped1534 = deconstruct_result1533 + self.pretty_export(unwrapped1534) else: _dollar_dollar = msg if _dollar_dollar.HasField("export_output"): - _t1753 = _dollar_dollar.export_output + _t1757 = _dollar_dollar.export_output else: - _t1753 = None - deconstruct_result1529 = _t1753 - if deconstruct_result1529 is not None: - assert deconstruct_result1529 is not None - unwrapped1530 = deconstruct_result1529 - self.pretty_export_output(unwrapped1530) + _t1757 = None + deconstruct_result1531 = _t1757 + if deconstruct_result1531 is not None: + assert deconstruct_result1531 is not None + unwrapped1532 = deconstruct_result1531 + self.pretty_export_output(unwrapped1532) else: raise ParseError("No matching rule for read") def pretty_demand(self, msg: transactions_pb2.Demand): - flat1544 = self._try_flat(msg, self.pretty_demand) - if flat1544 is not None: - assert flat1544 is not None - self.write(flat1544) + flat1546 = self._try_flat(msg, self.pretty_demand) + if flat1546 is not None: + assert flat1546 is not None + self.write(flat1546) return None else: _dollar_dollar = msg - fields1542 = _dollar_dollar.relation_id - assert fields1542 is not None - unwrapped_fields1543 = fields1542 + fields1544 = _dollar_dollar.relation_id + assert fields1544 is not None + unwrapped_fields1545 = fields1544 self.write("(demand") self.indent_sexp() self.newline() - self.pretty_relation_id(unwrapped_fields1543) + self.pretty_relation_id(unwrapped_fields1545) self.dedent() self.write(")") def pretty_output(self, msg: transactions_pb2.Output): - flat1549 = self._try_flat(msg, self.pretty_output) - if flat1549 is not None: - assert flat1549 is not None - self.write(flat1549) + flat1551 = self._try_flat(msg, self.pretty_output) + if flat1551 is not None: + assert flat1551 is not None + self.write(flat1551) return None else: _dollar_dollar = msg - fields1545 = (_dollar_dollar.name, _dollar_dollar.relation_id,) - assert fields1545 is not None - unwrapped_fields1546 = fields1545 + fields1547 = (_dollar_dollar.name, _dollar_dollar.relation_id,) + assert fields1547 is not None + unwrapped_fields1548 = fields1547 self.write("(output") self.indent_sexp() self.newline() - field1547 = unwrapped_fields1546[0] - self.pretty_name(field1547) + field1549 = unwrapped_fields1548[0] + self.pretty_name(field1549) self.newline() - field1548 = unwrapped_fields1546[1] - self.pretty_relation_id(field1548) + field1550 = unwrapped_fields1548[1] + self.pretty_relation_id(field1550) self.dedent() self.write(")") def pretty_what_if(self, msg: transactions_pb2.WhatIf): - flat1554 = self._try_flat(msg, self.pretty_what_if) - if flat1554 is not None: - assert flat1554 is not None - self.write(flat1554) + flat1556 = self._try_flat(msg, self.pretty_what_if) + if flat1556 is not None: + assert flat1556 is not None + self.write(flat1556) return None else: _dollar_dollar = msg - fields1550 = (_dollar_dollar.branch, _dollar_dollar.epoch,) - assert fields1550 is not None - unwrapped_fields1551 = fields1550 + fields1552 = (_dollar_dollar.branch, _dollar_dollar.epoch,) + assert fields1552 is not None + unwrapped_fields1553 = fields1552 self.write("(what_if") self.indent_sexp() self.newline() - field1552 = unwrapped_fields1551[0] - self.pretty_name(field1552) + field1554 = unwrapped_fields1553[0] + self.pretty_name(field1554) self.newline() - field1553 = unwrapped_fields1551[1] - self.pretty_epoch(field1553) + field1555 = unwrapped_fields1553[1] + self.pretty_epoch(field1555) self.dedent() self.write(")") def pretty_abort(self, msg: transactions_pb2.Abort): - flat1560 = self._try_flat(msg, self.pretty_abort) - if flat1560 is not None: - assert flat1560 is not None - self.write(flat1560) + flat1562 = self._try_flat(msg, self.pretty_abort) + if flat1562 is not None: + assert flat1562 is not None + self.write(flat1562) return None else: _dollar_dollar = msg if _dollar_dollar.name != "abort": - _t1754 = _dollar_dollar.name + _t1758 = _dollar_dollar.name else: - _t1754 = None - fields1555 = (_t1754, _dollar_dollar.relation_id,) - assert fields1555 is not None - unwrapped_fields1556 = fields1555 + _t1758 = None + fields1557 = (_t1758, _dollar_dollar.relation_id,) + assert fields1557 is not None + unwrapped_fields1558 = fields1557 self.write("(abort") self.indent_sexp() - field1557 = unwrapped_fields1556[0] - if field1557 is not None: + field1559 = unwrapped_fields1558[0] + if field1559 is not None: self.newline() - assert field1557 is not None - opt_val1558 = field1557 - self.pretty_name(opt_val1558) + assert field1559 is not None + opt_val1560 = field1559 + self.pretty_name(opt_val1560) self.newline() - field1559 = unwrapped_fields1556[1] - self.pretty_relation_id(field1559) + field1561 = unwrapped_fields1558[1] + self.pretty_relation_id(field1561) self.dedent() self.write(")") def pretty_export(self, msg: transactions_pb2.Export): - flat1565 = self._try_flat(msg, self.pretty_export) - if flat1565 is not None: - assert flat1565 is not None - self.write(flat1565) + flat1567 = self._try_flat(msg, self.pretty_export) + if flat1567 is not None: + assert flat1567 is not None + self.write(flat1567) return None else: _dollar_dollar = msg if _dollar_dollar.HasField("csv_config"): - _t1755 = _dollar_dollar.csv_config + _t1759 = _dollar_dollar.csv_config else: - _t1755 = None - deconstruct_result1563 = _t1755 - if deconstruct_result1563 is not None: - assert deconstruct_result1563 is not None - unwrapped1564 = deconstruct_result1563 + _t1759 = None + deconstruct_result1565 = _t1759 + if deconstruct_result1565 is not None: + assert deconstruct_result1565 is not None + unwrapped1566 = deconstruct_result1565 self.write("(export") self.indent_sexp() self.newline() - self.pretty_export_csv_config(unwrapped1564) + self.pretty_export_csv_config(unwrapped1566) self.dedent() self.write(")") else: _dollar_dollar = msg if _dollar_dollar.HasField("iceberg_config"): - _t1756 = _dollar_dollar.iceberg_config + _t1760 = _dollar_dollar.iceberg_config else: - _t1756 = None - deconstruct_result1561 = _t1756 - if deconstruct_result1561 is not None: - assert deconstruct_result1561 is not None - unwrapped1562 = deconstruct_result1561 + _t1760 = None + deconstruct_result1563 = _t1760 + if deconstruct_result1563 is not None: + assert deconstruct_result1563 is not None + unwrapped1564 = deconstruct_result1563 self.write("(export_iceberg") self.indent_sexp() self.newline() - self.pretty_export_iceberg_config(unwrapped1562) + self.pretty_export_iceberg_config(unwrapped1564) self.dedent() self.write(")") else: raise ParseError("No matching rule for export") def pretty_export_csv_config(self, msg: transactions_pb2.ExportCSVConfig): - flat1576 = self._try_flat(msg, self.pretty_export_csv_config) - if flat1576 is not None: - assert flat1576 is not None - self.write(flat1576) + flat1578 = self._try_flat(msg, self.pretty_export_csv_config) + if flat1578 is not None: + assert flat1578 is not None + self.write(flat1578) return None else: _dollar_dollar = msg if len(_dollar_dollar.data_columns) == 0: - _t1757 = (_dollar_dollar.path, _dollar_dollar.csv_source, _dollar_dollar.csv_config,) + _t1761 = (_dollar_dollar.path, _dollar_dollar.csv_source, _dollar_dollar.csv_config,) else: - _t1757 = None - deconstruct_result1571 = _t1757 - if deconstruct_result1571 is not None: - assert deconstruct_result1571 is not None - unwrapped1572 = deconstruct_result1571 + _t1761 = None + deconstruct_result1573 = _t1761 + if deconstruct_result1573 is not None: + assert deconstruct_result1573 is not None + unwrapped1574 = deconstruct_result1573 self.write("(export_csv_config_v2") self.indent_sexp() self.newline() - field1573 = unwrapped1572[0] - self.pretty_export_csv_path(field1573) + field1575 = unwrapped1574[0] + self.pretty_export_csv_path(field1575) self.newline() - field1574 = unwrapped1572[1] - self.pretty_export_csv_source(field1574) + field1576 = unwrapped1574[1] + self.pretty_export_csv_source(field1576) self.newline() - field1575 = unwrapped1572[2] - self.pretty_csv_config(field1575) + field1577 = unwrapped1574[2] + self.pretty_csv_config(field1577) self.dedent() self.write(")") else: _dollar_dollar = msg if len(_dollar_dollar.data_columns) != 0: - _t1759 = self.deconstruct_export_csv_config(_dollar_dollar) - _t1758 = (_dollar_dollar.path, _dollar_dollar.data_columns, _t1759,) + _t1763 = self.deconstruct_export_csv_config(_dollar_dollar) + _t1762 = (_dollar_dollar.path, _dollar_dollar.data_columns, _t1763,) else: - _t1758 = None - deconstruct_result1566 = _t1758 - if deconstruct_result1566 is not None: - assert deconstruct_result1566 is not None - unwrapped1567 = deconstruct_result1566 + _t1762 = None + deconstruct_result1568 = _t1762 + if deconstruct_result1568 is not None: + assert deconstruct_result1568 is not None + unwrapped1569 = deconstruct_result1568 self.write("(export_csv_config") self.indent_sexp() self.newline() - field1568 = unwrapped1567[0] - self.pretty_export_csv_path(field1568) + field1570 = unwrapped1569[0] + self.pretty_export_csv_path(field1570) self.newline() - field1569 = unwrapped1567[1] - self.pretty_export_csv_columns_list(field1569) + field1571 = unwrapped1569[1] + self.pretty_export_csv_columns_list(field1571) self.newline() - field1570 = unwrapped1567[2] - self.pretty_config_dict(field1570) + field1572 = unwrapped1569[2] + self.pretty_config_dict(field1572) self.dedent() self.write(")") else: raise ParseError("No matching rule for export_csv_config") def pretty_export_csv_path(self, msg: str): - flat1578 = self._try_flat(msg, self.pretty_export_csv_path) - if flat1578 is not None: - assert flat1578 is not None - self.write(flat1578) + flat1580 = self._try_flat(msg, self.pretty_export_csv_path) + if flat1580 is not None: + assert flat1580 is not None + self.write(flat1580) return None else: - fields1577 = msg + fields1579 = msg self.write("(path") self.indent_sexp() self.newline() - self.write(self.format_string_value(fields1577)) + self.write(self.format_string_value(fields1579)) self.dedent() self.write(")") def pretty_export_csv_source(self, msg: transactions_pb2.ExportCSVSource): - flat1585 = self._try_flat(msg, self.pretty_export_csv_source) - if flat1585 is not None: - assert flat1585 is not None - self.write(flat1585) + flat1587 = self._try_flat(msg, self.pretty_export_csv_source) + if flat1587 is not None: + assert flat1587 is not None + self.write(flat1587) return None else: _dollar_dollar = msg if _dollar_dollar.HasField("gnf_columns"): - _t1760 = _dollar_dollar.gnf_columns.columns + _t1764 = _dollar_dollar.gnf_columns.columns else: - _t1760 = None - deconstruct_result1581 = _t1760 - if deconstruct_result1581 is not None: - assert deconstruct_result1581 is not None - unwrapped1582 = deconstruct_result1581 + _t1764 = None + deconstruct_result1583 = _t1764 + if deconstruct_result1583 is not None: + assert deconstruct_result1583 is not None + unwrapped1584 = deconstruct_result1583 self.write("(gnf_columns") self.indent_sexp() - if not len(unwrapped1582) == 0: + if not len(unwrapped1584) == 0: self.newline() - for i1584, elem1583 in enumerate(unwrapped1582): - if (i1584 > 0): + for i1586, elem1585 in enumerate(unwrapped1584): + if (i1586 > 0): self.newline() - self.pretty_export_csv_column(elem1583) + self.pretty_export_csv_column(elem1585) self.dedent() self.write(")") else: _dollar_dollar = msg if _dollar_dollar.HasField("table_def"): - _t1761 = _dollar_dollar.table_def + _t1765 = _dollar_dollar.table_def else: - _t1761 = None - deconstruct_result1579 = _t1761 - if deconstruct_result1579 is not None: - assert deconstruct_result1579 is not None - unwrapped1580 = deconstruct_result1579 + _t1765 = None + deconstruct_result1581 = _t1765 + if deconstruct_result1581 is not None: + assert deconstruct_result1581 is not None + unwrapped1582 = deconstruct_result1581 self.write("(table_def") self.indent_sexp() self.newline() - self.pretty_relation_id(unwrapped1580) + self.pretty_relation_id(unwrapped1582) self.dedent() self.write(")") else: raise ParseError("No matching rule for export_csv_source") def pretty_export_csv_column(self, msg: transactions_pb2.ExportCSVColumn): - flat1590 = self._try_flat(msg, self.pretty_export_csv_column) - if flat1590 is not None: - assert flat1590 is not None - self.write(flat1590) + flat1592 = self._try_flat(msg, self.pretty_export_csv_column) + if flat1592 is not None: + assert flat1592 is not None + self.write(flat1592) return None else: _dollar_dollar = msg - fields1586 = (_dollar_dollar.column_name, _dollar_dollar.column_data,) - assert fields1586 is not None - unwrapped_fields1587 = fields1586 + fields1588 = (_dollar_dollar.column_name, _dollar_dollar.column_data,) + assert fields1588 is not None + unwrapped_fields1589 = fields1588 self.write("(column") self.indent_sexp() self.newline() - field1588 = unwrapped_fields1587[0] - self.write(self.format_string_value(field1588)) + field1590 = unwrapped_fields1589[0] + self.write(self.format_string_value(field1590)) self.newline() - field1589 = unwrapped_fields1587[1] - self.pretty_relation_id(field1589) + field1591 = unwrapped_fields1589[1] + self.pretty_relation_id(field1591) self.dedent() self.write(")") def pretty_export_csv_columns_list(self, msg: Sequence[transactions_pb2.ExportCSVColumn]): - flat1594 = self._try_flat(msg, self.pretty_export_csv_columns_list) - if flat1594 is not None: - assert flat1594 is not None - self.write(flat1594) + flat1596 = self._try_flat(msg, self.pretty_export_csv_columns_list) + if flat1596 is not None: + assert flat1596 is not None + self.write(flat1596) return None else: - fields1591 = msg + fields1593 = msg self.write("(columns") self.indent_sexp() - if not len(fields1591) == 0: + if not len(fields1593) == 0: self.newline() - for i1593, elem1592 in enumerate(fields1591): - if (i1593 > 0): + for i1595, elem1594 in enumerate(fields1593): + if (i1595 > 0): self.newline() - self.pretty_export_csv_column(elem1592) + self.pretty_export_csv_column(elem1594) self.dedent() self.write(")") def pretty_export_iceberg_config(self, msg: transactions_pb2.ExportIcebergConfig): - flat1603 = self._try_flat(msg, self.pretty_export_iceberg_config) - if flat1603 is not None: - assert flat1603 is not None - self.write(flat1603) + flat1605 = self._try_flat(msg, self.pretty_export_iceberg_config) + if flat1605 is not None: + assert flat1605 is not None + self.write(flat1605) return None else: _dollar_dollar = msg - _t1762 = self.deconstruct_export_iceberg_config_optional(_dollar_dollar) - fields1595 = (_dollar_dollar.locator, _dollar_dollar.config, _dollar_dollar.table_def, sorted(_dollar_dollar.table_properties.items()), _t1762,) - assert fields1595 is not None - unwrapped_fields1596 = fields1595 + _t1766 = self.deconstruct_export_iceberg_config_optional(_dollar_dollar) + fields1597 = (_dollar_dollar.locator, _dollar_dollar.config, _dollar_dollar.table_def, sorted(_dollar_dollar.table_properties.items()), _t1766,) + assert fields1597 is not None + unwrapped_fields1598 = fields1597 self.write("(export_iceberg_config") self.indent_sexp() self.newline() - field1597 = unwrapped_fields1596[0] - self.pretty_iceberg_locator(field1597) + field1599 = unwrapped_fields1598[0] + self.pretty_iceberg_locator(field1599) self.newline() - field1598 = unwrapped_fields1596[1] - self.pretty_iceberg_catalog_config(field1598) + field1600 = unwrapped_fields1598[1] + self.pretty_iceberg_catalog_config(field1600) self.newline() - field1599 = unwrapped_fields1596[2] - self.pretty_export_iceberg_table_def(field1599) + field1601 = unwrapped_fields1598[2] + self.pretty_export_iceberg_table_def(field1601) self.newline() - field1600 = unwrapped_fields1596[3] - self.pretty_iceberg_table_properties(field1600) - field1601 = unwrapped_fields1596[4] - if field1601 is not None: + field1602 = unwrapped_fields1598[3] + self.pretty_iceberg_table_properties(field1602) + field1603 = unwrapped_fields1598[4] + if field1603 is not None: self.newline() - assert field1601 is not None - opt_val1602 = field1601 - self.pretty_config_dict(opt_val1602) + assert field1603 is not None + opt_val1604 = field1603 + self.pretty_config_dict(opt_val1604) self.dedent() self.write(")") def pretty_export_iceberg_table_def(self, msg: logic_pb2.RelationId): - flat1605 = self._try_flat(msg, self.pretty_export_iceberg_table_def) - if flat1605 is not None: - assert flat1605 is not None - self.write(flat1605) + flat1607 = self._try_flat(msg, self.pretty_export_iceberg_table_def) + if flat1607 is not None: + assert flat1607 is not None + self.write(flat1607) return None else: - fields1604 = msg + fields1606 = msg self.write("(table_def") self.indent_sexp() self.newline() - self.pretty_relation_id(fields1604) + self.pretty_relation_id(fields1606) self.dedent() self.write(")") def pretty_iceberg_table_properties(self, msg: Sequence[tuple[str, str]]): - flat1609 = self._try_flat(msg, self.pretty_iceberg_table_properties) - if flat1609 is not None: - assert flat1609 is not None - self.write(flat1609) + flat1611 = self._try_flat(msg, self.pretty_iceberg_table_properties) + if flat1611 is not None: + assert flat1611 is not None + self.write(flat1611) return None else: - fields1606 = msg + fields1608 = msg self.write("(table_properties") self.indent_sexp() - if not len(fields1606) == 0: + if not len(fields1608) == 0: self.newline() - for i1608, elem1607 in enumerate(fields1606): - if (i1608 > 0): + for i1610, elem1609 in enumerate(fields1608): + if (i1610 > 0): self.newline() - self.pretty_iceberg_property_entry(elem1607) + self.pretty_iceberg_property_entry(elem1609) self.dedent() self.write(")") def pretty_export_output(self, msg: transactions_pb2.ExportOutput): - flat1612 = self._try_flat(msg, self.pretty_export_output) - if flat1612 is not None: - assert flat1612 is not None - self.write(flat1612) + flat1616 = self._try_flat(msg, self.pretty_export_output) + if flat1616 is not None: + assert flat1616 is not None + self.write(flat1616) return None else: _dollar_dollar = msg if _dollar_dollar.HasField("csv"): - _t1763 = _dollar_dollar.csv + _t1767 = (_dollar_dollar.name, _dollar_dollar.csv,) else: - _t1763 = None - fields1610 = _t1763 - assert fields1610 is not None - unwrapped_fields1611 = fields1610 + _t1767 = None + fields1612 = _t1767 + assert fields1612 is not None + unwrapped_fields1613 = fields1612 self.write("(export_output") self.indent_sexp() self.newline() - self.pretty_export_csv_output(unwrapped_fields1611) + field1614 = unwrapped_fields1613[0] + self.pretty_name(field1614) + self.newline() + field1615 = unwrapped_fields1613[1] + self.pretty_export_csv_output(field1615) self.dedent() self.write(")") def pretty_export_csv_output(self, msg: transactions_pb2.ExportCSVOutput): - flat1617 = self._try_flat(msg, self.pretty_export_csv_output) - if flat1617 is not None: - assert flat1617 is not None - self.write(flat1617) + flat1621 = self._try_flat(msg, self.pretty_export_csv_output) + if flat1621 is not None: + assert flat1621 is not None + self.write(flat1621) return None else: _dollar_dollar = msg - fields1613 = (_dollar_dollar.csv_source, _dollar_dollar.csv_config,) - assert fields1613 is not None - unwrapped_fields1614 = fields1613 + fields1617 = (_dollar_dollar.csv_source, _dollar_dollar.csv_config,) + assert fields1617 is not None + unwrapped_fields1618 = fields1617 self.write("(csv") self.indent_sexp() self.newline() - field1615 = unwrapped_fields1614[0] - self.pretty_export_csv_source(field1615) + field1619 = unwrapped_fields1618[0] + self.pretty_export_csv_source(field1619) self.newline() - field1616 = unwrapped_fields1614[1] - self.pretty_csv_config(field1616) + field1620 = unwrapped_fields1618[1] + self.pretty_csv_config(field1620) self.dedent() self.write(")") @@ -4445,8 +4449,8 @@ def pretty_debug_info(self, msg: fragments_pb2.DebugInfo): for _idx, _rid in enumerate(msg.ids): self.newline() self.write("(") - _t1815 = logic_pb2.UInt128Value(low=_rid.id_low, high=_rid.id_high) - self.pprint_dispatch(_t1815) + _t1819 = logic_pb2.UInt128Value(low=_rid.id_low, high=_rid.id_high) + self.pprint_dispatch(_t1819) 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 85e5708b..afa54bca 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\"\xee\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\x65xport\x12H\n\rexport_output\x18\x06 \x01(\x0b\x32!.relationalai.lqp.v1.ExportOutputH\x00R\x0c\x65xportOutputB\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\"\x95\x01\n\x0f\x45xportCSVOutput\x12\x43\n\ncsv_source\x18\x01 \x01(\x0b\x32$.relationalai.lqp.v1.ExportCSVSourceR\tcsvSource\x12=\n\ncsv_config\x18\x02 \x01(\x0b\x32\x1e.relationalai.lqp.v1.CSVConfigR\tcsvConfig\"Y\n\x0c\x45xportOutput\x12\x38\n\x03\x63sv\x18\x01 \x01(\x0b\x32$.relationalai.lqp.v1.ExportCSVOutputH\x00R\x03\x63svB\x0f\n\rexport_output*\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\"\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\"\xee\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\x65xport\x12H\n\rexport_output\x18\x06 \x01(\x0b\x32!.relationalai.lqp.v1.ExportOutputH\x00R\x0c\x65xportOutputB\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\"\x95\x01\n\x0f\x45xportCSVOutput\x12\x43\n\ncsv_source\x18\x01 \x01(\x0b\x32$.relationalai.lqp.v1.ExportCSVSourceR\tcsvSource\x12=\n\ncsv_config\x18\x02 \x01(\x0b\x32\x1e.relationalai.lqp.v1.CSVConfigR\tcsvConfig\"m\n\x0c\x45xportOutput\x12\x12\n\x04name\x18\x01 \x01(\tR\x04name\x12\x38\n\x03\x63sv\x18\x02 \x01(\x0b\x32$.relationalai.lqp.v1.ExportCSVOutputH\x00R\x03\x63svB\x0f\n\rexport_output*\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=4215 - _globals['_MAINTENANCELEVEL']._serialized_end=4350 + _globals['_MAINTENANCELEVEL']._serialized_start=4235 + _globals['_MAINTENANCELEVEL']._serialized_end=4370 _globals['_TRANSACTION']._serialized_start=134 _globals['_TRANSACTION']._serialized_end=322 _globals['_CONFIGURE']._serialized_start=324 @@ -87,5 +87,5 @@ _globals['_EXPORTCSVOUTPUT']._serialized_start=3972 _globals['_EXPORTCSVOUTPUT']._serialized_end=4121 _globals['_EXPORTOUTPUT']._serialized_start=4123 - _globals['_EXPORTOUTPUT']._serialized_end=4212 + _globals['_EXPORTOUTPUT']._serialized_end=4232 # @@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 be5666fe..4f3e5183 100644 --- a/sdks/python/src/lqp/proto/v1/transactions_pb2.pyi +++ b/sdks/python/src/lqp/proto/v1/transactions_pb2.pyi @@ -240,7 +240,9 @@ class ExportCSVOutput(_message.Message): def __init__(self, csv_source: _Optional[_Union[ExportCSVSource, _Mapping]] = ..., csv_config: _Optional[_Union[_logic_pb2.CSVConfig, _Mapping]] = ...) -> None: ... class ExportOutput(_message.Message): - __slots__ = ("csv",) + __slots__ = ("name", "csv") + NAME_FIELD_NUMBER: _ClassVar[int] CSV_FIELD_NUMBER: _ClassVar[int] + name: str csv: ExportCSVOutput - def __init__(self, csv: _Optional[_Union[ExportCSVOutput, _Mapping]] = ...) -> None: ... + def __init__(self, name: _Optional[str] = ..., csv: _Optional[_Union[ExportCSVOutput, _Mapping]] = ...) -> None: ... diff --git a/tests/bin/csv_output.bin b/tests/bin/csv_output.bin index 5a11ccf122e52b8be26939376c1b7ab90efcd698..f61d119ba67d7e3336111d0114bf52db2aaedda3 100644 GIT binary patch delta 29 kcmX@kc!`mT>*PeHUVa-RD=yC5%J}@!l7i9_p^1}C0E_quy8r+H delta 18 Zcmcb_c$|@mYu`ksUKT?meXfb~OaM0t1&IIv diff --git a/tests/lqp/csv_output.lqp b/tests/lqp/csv_output.lqp index cea04fe9..79547a84 100644 --- a/tests/lqp/csv_output.lqp +++ b/tests/lqp/csv_output.lqp @@ -8,7 +8,7 @@ (+ 1 1 x)))))) (reads - (export_output + (export_output :my_output (csv (table_def :test) (csv_config {})))))) diff --git a/tests/pretty/csv_output.lqp b/tests/pretty/csv_output.lqp index 07132c1e..a44b5e65 100644 --- a/tests/pretty/csv_output.lqp +++ b/tests/pretty/csv_output.lqp @@ -4,6 +4,7 @@ (writes (define (fragment :frag (def :test ([x::INT] (+ 1 1 x)))))) (reads (export_output + :my_output (csv (table_def :test) (csv_config diff --git a/tests/pretty_debug/csv_output.lqp b/tests/pretty_debug/csv_output.lqp index ba62e0b3..f75e427a 100644 --- a/tests/pretty_debug/csv_output.lqp +++ b/tests/pretty_debug/csv_output.lqp @@ -6,6 +6,7 @@ (fragment :frag (def 0xa3bf4f1b2b0b822cd15d6c15b0f00a08 ([x::INT] (+ 1 1 x)))))) (reads (export_output + :my_output (csv (table_def 0xa3bf4f1b2b0b822cd15d6c15b0f00a08) (csv_config