diff --git a/meta/src/meta/grammar.y b/meta/src/meta/grammar.y index f4ad9640..acc267bc 100644 --- a/meta/src/meta/grammar.y +++ b/meta/src/meta/grammar.y @@ -1261,9 +1261,11 @@ snapshot_mapping $2: logic.RelationId = $$.source_relation snapshot - : "(" "snapshot" snapshot_mapping* ")" - construct: $$ = transactions.Snapshot(mappings=$3) - deconstruct: $3: Sequence[transactions.SnapshotMapping] = $$.mappings + : "(" "snapshot" edb_path snapshot_mapping* ")" + construct: $$ = transactions.Snapshot(prefix=$3, mappings=$4) + deconstruct: + $3: Sequence[String] = $$.prefix + $4: Sequence[transactions.SnapshotMapping] = $$.mappings epoch_reads : "(" "reads" read* ")" diff --git a/proto/relationalai/lqp/v1/transactions.proto b/proto/relationalai/lqp/v1/transactions.proto index 5f74a47c..68f92849 100644 --- a/proto/relationalai/lqp/v1/transactions.proto +++ b/proto/relationalai/lqp/v1/transactions.proto @@ -64,16 +64,20 @@ message Context { repeated RelationId relations = 1; } -// A single (destination, source) pair within a Snapshot action. +// A single (destination, source) pair within a Snapshot action. The destination_path is +// relative to the Snapshot's prefix. message SnapshotMapping { repeated string destination_path = 1; RelationId source_relation = 2; } // Demand the source IDBs, take immutable snapshots, and turn them into EDBs under the -// given paths (specified as sequences of strings, see EDB). +// given paths (specified as sequences of strings, see EDB). If a prefix is specified, +// the engine should treat this as a complete snapshot of all EDBs under that prefix, +// removing any pre-existing EDBs for the same prefix that are not in the mappings. message Snapshot { repeated SnapshotMapping mappings = 1; + repeated string prefix = 2; } // diff --git a/sdks/go/src/lqp/v1/transactions.pb.go b/sdks/go/src/lqp/v1/transactions.pb.go index f2d06619..b330b6bd 100644 --- a/sdks/go/src/lqp/v1/transactions.pb.go +++ b/sdks/go/src/lqp/v1/transactions.pb.go @@ -571,7 +571,8 @@ func (x *Context) GetRelations() []*RelationId { return nil } -// A single (destination, source) pair within a Snapshot action. +// A single (destination, source) pair within a Snapshot action. The destination_path is +// relative to the Snapshot's prefix. type SnapshotMapping struct { state protoimpl.MessageState `protogen:"open.v1"` DestinationPath []string `protobuf:"bytes,1,rep,name=destination_path,json=destinationPath,proto3" json:"destination_path,omitempty"` @@ -625,10 +626,13 @@ func (x *SnapshotMapping) GetSourceRelation() *RelationId { } // Demand the source IDBs, take immutable snapshots, and turn them into EDBs under the -// given paths (specified as sequences of strings, see EDB). +// given paths (specified as sequences of strings, see EDB). If a prefix is specified, +// the engine should treat this as a complete snapshot of all EDBs under that prefix, +// removing any pre-existing EDBs for the same prefix that are not in the mappings. type Snapshot struct { state protoimpl.MessageState `protogen:"open.v1"` Mappings []*SnapshotMapping `protobuf:"bytes,1,rep,name=mappings,proto3" json:"mappings,omitempty"` + Prefix []string `protobuf:"bytes,2,rep,name=prefix,proto3" json:"prefix,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } @@ -670,6 +674,13 @@ func (x *Snapshot) GetMappings() []*SnapshotMapping { return nil } +func (x *Snapshot) GetPrefix() []string { + if x != nil { + return x.Prefix + } + return nil +} + type ExportCSVConfig struct { state protoimpl.MessageState `protogen:"open.v1"` Path string `protobuf:"bytes,1,opt,name=path,proto3" json:"path,omitempty"` @@ -1622,187 +1633,189 @@ var file_relationalai_lqp_v1_transactions_proto_rawDesc = string([]byte{ 0x6f, 0x6e, 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, 0x0e, 0x73, 0x6f, 0x75, 0x72, 0x63, - 0x65, 0x52, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x4c, 0x0a, 0x08, 0x53, 0x6e, 0x61, + 0x65, 0x52, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x64, 0x0a, 0x08, 0x53, 0x6e, 0x61, 0x70, 0x73, 0x68, 0x6f, 0x74, 0x12, 0x40, 0x0a, 0x08, 0x6d, 0x61, 0x70, 0x70, 0x69, 0x6e, 0x67, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x6e, 0x61, 0x70, 0x73, 0x68, 0x6f, 0x74, 0x4d, 0x61, 0x70, 0x70, 0x69, 0x6e, 0x67, 0x52, 0x08, 0x6d, - 0x61, 0x70, 0x70, 0x69, 0x6e, 0x67, 0x73, 0x22, 0xc8, 0x05, 0x0a, 0x0f, 0x45, 0x78, 0x70, 0x6f, - 0x72, 0x74, 0x43, 0x53, 0x56, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x12, 0x12, 0x0a, 0x04, 0x70, - 0x61, 0x74, 0x68, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x70, 0x61, 0x74, 0x68, 0x12, - 0x43, 0x0a, 0x0a, 0x63, 0x73, 0x76, 0x5f, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x18, 0x0a, 0x20, - 0x01, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, - 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x45, 0x78, 0x70, 0x6f, 0x72, 0x74, - 0x43, 0x53, 0x56, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x52, 0x09, 0x63, 0x73, 0x76, 0x53, 0x6f, - 0x75, 0x72, 0x63, 0x65, 0x12, 0x3d, 0x0a, 0x0a, 0x63, 0x73, 0x76, 0x5f, 0x63, 0x6f, 0x6e, 0x66, - 0x69, 0x67, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, - 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x43, - 0x53, 0x56, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x52, 0x09, 0x63, 0x73, 0x76, 0x43, 0x6f, 0x6e, - 0x66, 0x69, 0x67, 0x12, 0x47, 0x0a, 0x0c, 0x64, 0x61, 0x74, 0x61, 0x5f, 0x63, 0x6f, 0x6c, 0x75, - 0x6d, 0x6e, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x72, 0x65, 0x6c, 0x61, - 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, - 0x45, 0x78, 0x70, 0x6f, 0x72, 0x74, 0x43, 0x53, 0x56, 0x43, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x52, - 0x0b, 0x64, 0x61, 0x74, 0x61, 0x43, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x73, 0x12, 0x2a, 0x0a, 0x0e, - 0x70, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x18, 0x03, - 0x20, 0x01, 0x28, 0x03, 0x48, 0x00, 0x52, 0x0d, 0x70, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, - 0x6e, 0x53, 0x69, 0x7a, 0x65, 0x88, 0x01, 0x01, 0x12, 0x25, 0x0a, 0x0b, 0x63, 0x6f, 0x6d, 0x70, - 0x72, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x48, 0x01, 0x52, - 0x0b, 0x63, 0x6f, 0x6d, 0x70, 0x72, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x88, 0x01, 0x01, 0x12, - 0x2f, 0x0a, 0x11, 0x73, 0x79, 0x6e, 0x74, 0x61, 0x78, 0x5f, 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, - 0x5f, 0x72, 0x6f, 0x77, 0x18, 0x05, 0x20, 0x01, 0x28, 0x08, 0x48, 0x02, 0x52, 0x0f, 0x73, 0x79, - 0x6e, 0x74, 0x61, 0x78, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x52, 0x6f, 0x77, 0x88, 0x01, 0x01, - 0x12, 0x37, 0x0a, 0x15, 0x73, 0x79, 0x6e, 0x74, 0x61, 0x78, 0x5f, 0x6d, 0x69, 0x73, 0x73, 0x69, - 0x6e, 0x67, 0x5f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x48, - 0x03, 0x52, 0x13, 0x73, 0x79, 0x6e, 0x74, 0x61, 0x78, 0x4d, 0x69, 0x73, 0x73, 0x69, 0x6e, 0x67, - 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x88, 0x01, 0x01, 0x12, 0x26, 0x0a, 0x0c, 0x73, 0x79, 0x6e, - 0x74, 0x61, 0x78, 0x5f, 0x64, 0x65, 0x6c, 0x69, 0x6d, 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, 0x48, - 0x04, 0x52, 0x0b, 0x73, 0x79, 0x6e, 0x74, 0x61, 0x78, 0x44, 0x65, 0x6c, 0x69, 0x6d, 0x88, 0x01, - 0x01, 0x12, 0x2e, 0x0a, 0x10, 0x73, 0x79, 0x6e, 0x74, 0x61, 0x78, 0x5f, 0x71, 0x75, 0x6f, 0x74, - 0x65, 0x63, 0x68, 0x61, 0x72, 0x18, 0x08, 0x20, 0x01, 0x28, 0x09, 0x48, 0x05, 0x52, 0x0f, 0x73, - 0x79, 0x6e, 0x74, 0x61, 0x78, 0x51, 0x75, 0x6f, 0x74, 0x65, 0x63, 0x68, 0x61, 0x72, 0x88, 0x01, - 0x01, 0x12, 0x30, 0x0a, 0x11, 0x73, 0x79, 0x6e, 0x74, 0x61, 0x78, 0x5f, 0x65, 0x73, 0x63, 0x61, - 0x70, 0x65, 0x63, 0x68, 0x61, 0x72, 0x18, 0x09, 0x20, 0x01, 0x28, 0x09, 0x48, 0x06, 0x52, 0x10, - 0x73, 0x79, 0x6e, 0x74, 0x61, 0x78, 0x45, 0x73, 0x63, 0x61, 0x70, 0x65, 0x63, 0x68, 0x61, 0x72, - 0x88, 0x01, 0x01, 0x42, 0x11, 0x0a, 0x0f, 0x5f, 0x70, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, - 0x6e, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x42, 0x0e, 0x0a, 0x0c, 0x5f, 0x63, 0x6f, 0x6d, 0x70, 0x72, - 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x42, 0x14, 0x0a, 0x12, 0x5f, 0x73, 0x79, 0x6e, 0x74, 0x61, - 0x78, 0x5f, 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x5f, 0x72, 0x6f, 0x77, 0x42, 0x18, 0x0a, 0x16, - 0x5f, 0x73, 0x79, 0x6e, 0x74, 0x61, 0x78, 0x5f, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6e, 0x67, 0x5f, - 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x42, 0x0f, 0x0a, 0x0d, 0x5f, 0x73, 0x79, 0x6e, 0x74, 0x61, - 0x78, 0x5f, 0x64, 0x65, 0x6c, 0x69, 0x6d, 0x42, 0x13, 0x0a, 0x11, 0x5f, 0x73, 0x79, 0x6e, 0x74, - 0x61, 0x78, 0x5f, 0x71, 0x75, 0x6f, 0x74, 0x65, 0x63, 0x68, 0x61, 0x72, 0x42, 0x14, 0x0a, 0x12, - 0x5f, 0x73, 0x79, 0x6e, 0x74, 0x61, 0x78, 0x5f, 0x65, 0x73, 0x63, 0x61, 0x70, 0x65, 0x63, 0x68, - 0x61, 0x72, 0x22, 0x74, 0x0a, 0x0f, 0x45, 0x78, 0x70, 0x6f, 0x72, 0x74, 0x43, 0x53, 0x56, 0x43, - 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x12, 0x1f, 0x0a, 0x0b, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x5f, - 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x63, 0x6f, 0x6c, 0x75, - 0x6d, 0x6e, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x40, 0x0a, 0x0b, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, - 0x5f, 0x64, 0x61, 0x74, 0x61, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x72, 0x65, + 0x61, 0x70, 0x70, 0x69, 0x6e, 0x67, 0x73, 0x12, 0x16, 0x0a, 0x06, 0x70, 0x72, 0x65, 0x66, 0x69, + 0x78, 0x18, 0x02, 0x20, 0x03, 0x28, 0x09, 0x52, 0x06, 0x70, 0x72, 0x65, 0x66, 0x69, 0x78, 0x22, + 0xc8, 0x05, 0x0a, 0x0f, 0x45, 0x78, 0x70, 0x6f, 0x72, 0x74, 0x43, 0x53, 0x56, 0x43, 0x6f, 0x6e, + 0x66, 0x69, 0x67, 0x12, 0x12, 0x0a, 0x04, 0x70, 0x61, 0x74, 0x68, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x04, 0x70, 0x61, 0x74, 0x68, 0x12, 0x43, 0x0a, 0x0a, 0x63, 0x73, 0x76, 0x5f, 0x73, + 0x6f, 0x75, 0x72, 0x63, 0x65, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, - 0x31, 0x2e, 0x52, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x52, 0x0a, 0x63, 0x6f, - 0x6c, 0x75, 0x6d, 0x6e, 0x44, 0x61, 0x74, 0x61, 0x22, 0x52, 0x0a, 0x10, 0x45, 0x78, 0x70, 0x6f, - 0x72, 0x74, 0x43, 0x53, 0x56, 0x43, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x73, 0x12, 0x3e, 0x0a, 0x07, - 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x24, 0x2e, - 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, - 0x2e, 0x76, 0x31, 0x2e, 0x45, 0x78, 0x70, 0x6f, 0x72, 0x74, 0x43, 0x53, 0x56, 0x43, 0x6f, 0x6c, - 0x75, 0x6d, 0x6e, 0x52, 0x07, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x73, 0x22, 0xa9, 0x01, 0x0a, - 0x0f, 0x45, 0x78, 0x70, 0x6f, 0x72, 0x74, 0x43, 0x53, 0x56, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, - 0x12, 0x48, 0x0a, 0x0b, 0x67, 0x6e, 0x66, 0x5f, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x73, 0x18, - 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x25, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x31, 0x2e, 0x45, 0x78, 0x70, 0x6f, 0x72, 0x74, 0x43, 0x53, 0x56, 0x53, 0x6f, 0x75, 0x72, 0x63, + 0x65, 0x52, 0x09, 0x63, 0x73, 0x76, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x12, 0x3d, 0x0a, 0x0a, + 0x63, 0x73, 0x76, 0x5f, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x1e, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, + 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x53, 0x56, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, + 0x52, 0x09, 0x63, 0x73, 0x76, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x12, 0x47, 0x0a, 0x0c, 0x64, + 0x61, 0x74, 0x61, 0x5f, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, + 0x0b, 0x32, 0x24, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, + 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x45, 0x78, 0x70, 0x6f, 0x72, 0x74, 0x43, 0x53, + 0x56, 0x43, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x52, 0x0b, 0x64, 0x61, 0x74, 0x61, 0x43, 0x6f, 0x6c, + 0x75, 0x6d, 0x6e, 0x73, 0x12, 0x2a, 0x0a, 0x0e, 0x70, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, + 0x6e, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x03, 0x48, 0x00, 0x52, 0x0d, + 0x70, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x69, 0x7a, 0x65, 0x88, 0x01, 0x01, + 0x12, 0x25, 0x0a, 0x0b, 0x63, 0x6f, 0x6d, 0x70, 0x72, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x18, + 0x04, 0x20, 0x01, 0x28, 0x09, 0x48, 0x01, 0x52, 0x0b, 0x63, 0x6f, 0x6d, 0x70, 0x72, 0x65, 0x73, + 0x73, 0x69, 0x6f, 0x6e, 0x88, 0x01, 0x01, 0x12, 0x2f, 0x0a, 0x11, 0x73, 0x79, 0x6e, 0x74, 0x61, + 0x78, 0x5f, 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x5f, 0x72, 0x6f, 0x77, 0x18, 0x05, 0x20, 0x01, + 0x28, 0x08, 0x48, 0x02, 0x52, 0x0f, 0x73, 0x79, 0x6e, 0x74, 0x61, 0x78, 0x48, 0x65, 0x61, 0x64, + 0x65, 0x72, 0x52, 0x6f, 0x77, 0x88, 0x01, 0x01, 0x12, 0x37, 0x0a, 0x15, 0x73, 0x79, 0x6e, 0x74, + 0x61, 0x78, 0x5f, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6e, 0x67, 0x5f, 0x73, 0x74, 0x72, 0x69, 0x6e, + 0x67, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x48, 0x03, 0x52, 0x13, 0x73, 0x79, 0x6e, 0x74, 0x61, + 0x78, 0x4d, 0x69, 0x73, 0x73, 0x69, 0x6e, 0x67, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x88, 0x01, + 0x01, 0x12, 0x26, 0x0a, 0x0c, 0x73, 0x79, 0x6e, 0x74, 0x61, 0x78, 0x5f, 0x64, 0x65, 0x6c, 0x69, + 0x6d, 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, 0x48, 0x04, 0x52, 0x0b, 0x73, 0x79, 0x6e, 0x74, 0x61, + 0x78, 0x44, 0x65, 0x6c, 0x69, 0x6d, 0x88, 0x01, 0x01, 0x12, 0x2e, 0x0a, 0x10, 0x73, 0x79, 0x6e, + 0x74, 0x61, 0x78, 0x5f, 0x71, 0x75, 0x6f, 0x74, 0x65, 0x63, 0x68, 0x61, 0x72, 0x18, 0x08, 0x20, + 0x01, 0x28, 0x09, 0x48, 0x05, 0x52, 0x0f, 0x73, 0x79, 0x6e, 0x74, 0x61, 0x78, 0x51, 0x75, 0x6f, + 0x74, 0x65, 0x63, 0x68, 0x61, 0x72, 0x88, 0x01, 0x01, 0x12, 0x30, 0x0a, 0x11, 0x73, 0x79, 0x6e, + 0x74, 0x61, 0x78, 0x5f, 0x65, 0x73, 0x63, 0x61, 0x70, 0x65, 0x63, 0x68, 0x61, 0x72, 0x18, 0x09, + 0x20, 0x01, 0x28, 0x09, 0x48, 0x06, 0x52, 0x10, 0x73, 0x79, 0x6e, 0x74, 0x61, 0x78, 0x45, 0x73, + 0x63, 0x61, 0x70, 0x65, 0x63, 0x68, 0x61, 0x72, 0x88, 0x01, 0x01, 0x42, 0x11, 0x0a, 0x0f, 0x5f, + 0x70, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x42, 0x0e, + 0x0a, 0x0c, 0x5f, 0x63, 0x6f, 0x6d, 0x70, 0x72, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x42, 0x14, + 0x0a, 0x12, 0x5f, 0x73, 0x79, 0x6e, 0x74, 0x61, 0x78, 0x5f, 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, + 0x5f, 0x72, 0x6f, 0x77, 0x42, 0x18, 0x0a, 0x16, 0x5f, 0x73, 0x79, 0x6e, 0x74, 0x61, 0x78, 0x5f, + 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6e, 0x67, 0x5f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x42, 0x0f, + 0x0a, 0x0d, 0x5f, 0x73, 0x79, 0x6e, 0x74, 0x61, 0x78, 0x5f, 0x64, 0x65, 0x6c, 0x69, 0x6d, 0x42, + 0x13, 0x0a, 0x11, 0x5f, 0x73, 0x79, 0x6e, 0x74, 0x61, 0x78, 0x5f, 0x71, 0x75, 0x6f, 0x74, 0x65, + 0x63, 0x68, 0x61, 0x72, 0x42, 0x14, 0x0a, 0x12, 0x5f, 0x73, 0x79, 0x6e, 0x74, 0x61, 0x78, 0x5f, + 0x65, 0x73, 0x63, 0x61, 0x70, 0x65, 0x63, 0x68, 0x61, 0x72, 0x22, 0x74, 0x0a, 0x0f, 0x45, 0x78, + 0x70, 0x6f, 0x72, 0x74, 0x43, 0x53, 0x56, 0x43, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x12, 0x1f, 0x0a, + 0x0b, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x0a, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x40, + 0x0a, 0x0b, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x5f, 0x64, 0x61, 0x74, 0x61, 0x18, 0x02, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, + 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, 0x6c, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x49, 0x64, 0x52, 0x0a, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x44, 0x61, 0x74, 0x61, + 0x22, 0x52, 0x0a, 0x10, 0x45, 0x78, 0x70, 0x6f, 0x72, 0x74, 0x43, 0x53, 0x56, 0x43, 0x6f, 0x6c, + 0x75, 0x6d, 0x6e, 0x73, 0x12, 0x3e, 0x0a, 0x07, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x73, 0x18, + 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x45, 0x78, 0x70, 0x6f, - 0x72, 0x74, 0x43, 0x53, 0x56, 0x43, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x73, 0x48, 0x00, 0x52, 0x0a, - 0x67, 0x6e, 0x66, 0x43, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x73, 0x12, 0x3e, 0x0a, 0x09, 0x74, 0x61, - 0x62, 0x6c, 0x65, 0x5f, 0x64, 0x65, 0x66, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, + 0x72, 0x74, 0x43, 0x53, 0x56, 0x43, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x52, 0x07, 0x63, 0x6f, 0x6c, + 0x75, 0x6d, 0x6e, 0x73, 0x22, 0xa9, 0x01, 0x0a, 0x0f, 0x45, 0x78, 0x70, 0x6f, 0x72, 0x74, 0x43, + 0x53, 0x56, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x12, 0x48, 0x0a, 0x0b, 0x67, 0x6e, 0x66, 0x5f, + 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x25, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, - 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x48, 0x00, - 0x52, 0x08, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x44, 0x65, 0x66, 0x42, 0x0c, 0x0a, 0x0a, 0x63, 0x73, - 0x76, 0x5f, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x22, 0x3e, 0x0a, 0x0c, 0x45, 0x78, 0x70, 0x6f, - 0x72, 0x74, 0x43, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, - 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x1a, 0x0a, 0x08, - 0x6e, 0x75, 0x6c, 0x6c, 0x61, 0x62, 0x6c, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x08, - 0x6e, 0x75, 0x6c, 0x6c, 0x61, 0x62, 0x6c, 0x65, 0x22, 0xdf, 0x04, 0x0a, 0x13, 0x45, 0x78, 0x70, - 0x6f, 0x72, 0x74, 0x49, 0x63, 0x65, 0x62, 0x65, 0x72, 0x67, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, - 0x12, 0x3d, 0x0a, 0x07, 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x6f, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, - 0x0b, 0x32, 0x23, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, - 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x49, 0x63, 0x65, 0x62, 0x65, 0x72, 0x67, 0x4c, - 0x6f, 0x63, 0x61, 0x74, 0x6f, 0x72, 0x52, 0x07, 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x6f, 0x72, 0x12, - 0x41, 0x0a, 0x06, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, - 0x29, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, - 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x49, 0x63, 0x65, 0x62, 0x65, 0x72, 0x67, 0x43, 0x61, 0x74, - 0x61, 0x6c, 0x6f, 0x67, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x52, 0x06, 0x63, 0x6f, 0x6e, 0x66, - 0x69, 0x67, 0x12, 0x3c, 0x0a, 0x09, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x5f, 0x64, 0x65, 0x66, 0x18, - 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x2e, 0x76, 0x31, 0x2e, 0x45, 0x78, 0x70, 0x6f, 0x72, 0x74, 0x43, 0x53, 0x56, 0x43, 0x6f, 0x6c, + 0x75, 0x6d, 0x6e, 0x73, 0x48, 0x00, 0x52, 0x0a, 0x67, 0x6e, 0x66, 0x43, 0x6f, 0x6c, 0x75, 0x6d, + 0x6e, 0x73, 0x12, 0x3e, 0x0a, 0x09, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x5f, 0x64, 0x65, 0x66, 0x18, + 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, 0x6c, 0x61, - 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x52, 0x08, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x44, 0x65, 0x66, - 0x12, 0x3b, 0x0a, 0x07, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x73, 0x18, 0x04, 0x20, 0x03, 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, 0x43, 0x6f, - 0x6c, 0x75, 0x6d, 0x6e, 0x52, 0x07, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x73, 0x12, 0x1b, 0x0a, - 0x06, 0x70, 0x72, 0x65, 0x66, 0x69, 0x78, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x48, 0x00, 0x52, - 0x06, 0x70, 0x72, 0x65, 0x66, 0x69, 0x78, 0x88, 0x01, 0x01, 0x12, 0x38, 0x0a, 0x16, 0x74, 0x61, - 0x72, 0x67, 0x65, 0x74, 0x5f, 0x66, 0x69, 0x6c, 0x65, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x5f, 0x62, - 0x79, 0x74, 0x65, 0x73, 0x18, 0x06, 0x20, 0x01, 0x28, 0x03, 0x48, 0x01, 0x52, 0x13, 0x74, 0x61, - 0x72, 0x67, 0x65, 0x74, 0x46, 0x69, 0x6c, 0x65, 0x53, 0x69, 0x7a, 0x65, 0x42, 0x79, 0x74, 0x65, - 0x73, 0x88, 0x01, 0x01, 0x12, 0x20, 0x0a, 0x0b, 0x63, 0x6f, 0x6d, 0x70, 0x72, 0x65, 0x73, 0x73, - 0x69, 0x6f, 0x6e, 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x63, 0x6f, 0x6d, 0x70, 0x72, - 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x68, 0x0a, 0x10, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x5f, - 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x18, 0x08, 0x20, 0x03, 0x28, 0x0b, - 0x32, 0x3d, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, - 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x45, 0x78, 0x70, 0x6f, 0x72, 0x74, 0x49, 0x63, 0x65, - 0x62, 0x65, 0x72, 0x67, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x2e, 0x54, 0x61, 0x62, 0x6c, 0x65, - 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, - 0x0f, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, - 0x1a, 0x42, 0x0a, 0x14, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, - 0x69, 0x65, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, - 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, - 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, - 0x3a, 0x02, 0x38, 0x01, 0x42, 0x09, 0x0a, 0x07, 0x5f, 0x70, 0x72, 0x65, 0x66, 0x69, 0x78, 0x42, - 0x19, 0x0a, 0x17, 0x5f, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x5f, 0x66, 0x69, 0x6c, 0x65, 0x5f, - 0x73, 0x69, 0x7a, 0x65, 0x5f, 0x62, 0x79, 0x74, 0x65, 0x73, 0x22, 0xa4, 0x02, 0x0a, 0x04, 0x52, - 0x65, 0x61, 0x64, 0x12, 0x35, 0x0a, 0x06, 0x64, 0x65, 0x6d, 0x61, 0x6e, 0x64, 0x18, 0x01, 0x20, - 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, - 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x65, 0x6d, 0x61, 0x6e, 0x64, - 0x48, 0x00, 0x52, 0x06, 0x64, 0x65, 0x6d, 0x61, 0x6e, 0x64, 0x12, 0x35, 0x0a, 0x06, 0x6f, 0x75, - 0x74, 0x70, 0x75, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x72, 0x65, 0x6c, - 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, - 0x2e, 0x4f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x48, 0x00, 0x52, 0x06, 0x6f, 0x75, 0x74, 0x70, 0x75, - 0x74, 0x12, 0x36, 0x0a, 0x07, 0x77, 0x68, 0x61, 0x74, 0x5f, 0x69, 0x66, 0x18, 0x03, 0x20, 0x01, - 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, - 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x57, 0x68, 0x61, 0x74, 0x49, 0x66, 0x48, - 0x00, 0x52, 0x06, 0x77, 0x68, 0x61, 0x74, 0x49, 0x66, 0x12, 0x32, 0x0a, 0x05, 0x61, 0x62, 0x6f, - 0x72, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, - 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x41, - 0x62, 0x6f, 0x72, 0x74, 0x48, 0x00, 0x52, 0x05, 0x61, 0x62, 0x6f, 0x72, 0x74, 0x12, 0x35, 0x0a, - 0x06, 0x65, 0x78, 0x70, 0x6f, 0x72, 0x74, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, - 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, - 0x2e, 0x76, 0x31, 0x2e, 0x45, 0x78, 0x70, 0x6f, 0x72, 0x74, 0x48, 0x00, 0x52, 0x06, 0x65, 0x78, - 0x70, 0x6f, 0x72, 0x74, 0x42, 0x0b, 0x0a, 0x09, 0x72, 0x65, 0x61, 0x64, 0x5f, 0x74, 0x79, 0x70, - 0x65, 0x22, 0x4a, 0x0a, 0x06, 0x44, 0x65, 0x6d, 0x61, 0x6e, 0x64, 0x12, 0x40, 0x0a, 0x0b, 0x72, - 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, - 0x32, 0x1f, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, - 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, - 0x64, 0x52, 0x0a, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x22, 0x5e, 0x0a, - 0x06, 0x4f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, - 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x40, 0x0a, 0x0b, 0x72, - 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, - 0x32, 0x1f, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, - 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 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, + 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x48, 0x00, 0x52, 0x08, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x44, + 0x65, 0x66, 0x42, 0x0c, 0x0a, 0x0a, 0x63, 0x73, 0x76, 0x5f, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, + 0x22, 0x3e, 0x0a, 0x0c, 0x45, 0x78, 0x70, 0x6f, 0x72, 0x74, 0x43, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 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, + 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x1a, 0x0a, 0x08, 0x6e, 0x75, 0x6c, 0x6c, 0x61, 0x62, 0x6c, 0x65, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x08, 0x6e, 0x75, 0x6c, 0x6c, 0x61, 0x62, 0x6c, 0x65, + 0x22, 0xdf, 0x04, 0x0a, 0x13, 0x45, 0x78, 0x70, 0x6f, 0x72, 0x74, 0x49, 0x63, 0x65, 0x62, 0x65, + 0x72, 0x67, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x12, 0x3d, 0x0a, 0x07, 0x6c, 0x6f, 0x63, 0x61, + 0x74, 0x6f, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, - 0x52, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x52, 0x0a, 0x72, 0x65, 0x6c, 0x61, - 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x2a, 0x87, 0x01, 0x0a, 0x10, 0x4d, 0x61, 0x69, 0x6e, 0x74, - 0x65, 0x6e, 0x61, 0x6e, 0x63, 0x65, 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x12, 0x21, 0x0a, 0x1d, 0x4d, - 0x41, 0x49, 0x4e, 0x54, 0x45, 0x4e, 0x41, 0x4e, 0x43, 0x45, 0x5f, 0x4c, 0x45, 0x56, 0x45, 0x4c, - 0x5f, 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, 0x10, 0x00, 0x12, 0x19, - 0x0a, 0x15, 0x4d, 0x41, 0x49, 0x4e, 0x54, 0x45, 0x4e, 0x41, 0x4e, 0x43, 0x45, 0x5f, 0x4c, 0x45, - 0x56, 0x45, 0x4c, 0x5f, 0x4f, 0x46, 0x46, 0x10, 0x01, 0x12, 0x1a, 0x0a, 0x16, 0x4d, 0x41, 0x49, - 0x4e, 0x54, 0x45, 0x4e, 0x41, 0x4e, 0x43, 0x45, 0x5f, 0x4c, 0x45, 0x56, 0x45, 0x4c, 0x5f, 0x41, - 0x55, 0x54, 0x4f, 0x10, 0x02, 0x12, 0x19, 0x0a, 0x15, 0x4d, 0x41, 0x49, 0x4e, 0x54, 0x45, 0x4e, - 0x41, 0x4e, 0x43, 0x45, 0x5f, 0x4c, 0x45, 0x56, 0x45, 0x4c, 0x5f, 0x41, 0x4c, 0x4c, 0x10, 0x03, - 0x42, 0x43, 0x5a, 0x41, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x52, - 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x41, 0x49, 0x2f, 0x6c, 0x6f, 0x67, 0x69, - 0x63, 0x61, 0x6c, 0x2d, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2d, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, - 0x6f, 0x6c, 0x2f, 0x73, 0x64, 0x6b, 0x73, 0x2f, 0x67, 0x6f, 0x2f, 0x73, 0x72, 0x63, 0x2f, 0x6c, - 0x71, 0x70, 0x2f, 0x76, 0x31, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, + 0x49, 0x63, 0x65, 0x62, 0x65, 0x72, 0x67, 0x4c, 0x6f, 0x63, 0x61, 0x74, 0x6f, 0x72, 0x52, 0x07, + 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x6f, 0x72, 0x12, 0x41, 0x0a, 0x06, 0x63, 0x6f, 0x6e, 0x66, 0x69, + 0x67, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x29, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x49, 0x63, + 0x65, 0x62, 0x65, 0x72, 0x67, 0x43, 0x61, 0x74, 0x61, 0x6c, 0x6f, 0x67, 0x43, 0x6f, 0x6e, 0x66, + 0x69, 0x67, 0x52, 0x06, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x12, 0x3c, 0x0a, 0x09, 0x74, 0x61, + 0x62, 0x6c, 0x65, 0x5f, 0x64, 0x65, 0x66, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, + 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, + 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x52, 0x08, + 0x74, 0x61, 0x62, 0x6c, 0x65, 0x44, 0x65, 0x66, 0x12, 0x3b, 0x0a, 0x07, 0x63, 0x6f, 0x6c, 0x75, + 0x6d, 0x6e, 0x73, 0x18, 0x04, 0x20, 0x03, 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, 0x43, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x52, 0x07, 0x63, 0x6f, + 0x6c, 0x75, 0x6d, 0x6e, 0x73, 0x12, 0x1b, 0x0a, 0x06, 0x70, 0x72, 0x65, 0x66, 0x69, 0x78, 0x18, + 0x05, 0x20, 0x01, 0x28, 0x09, 0x48, 0x00, 0x52, 0x06, 0x70, 0x72, 0x65, 0x66, 0x69, 0x78, 0x88, + 0x01, 0x01, 0x12, 0x38, 0x0a, 0x16, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x5f, 0x66, 0x69, 0x6c, + 0x65, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x5f, 0x62, 0x79, 0x74, 0x65, 0x73, 0x18, 0x06, 0x20, 0x01, + 0x28, 0x03, 0x48, 0x01, 0x52, 0x13, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x46, 0x69, 0x6c, 0x65, + 0x53, 0x69, 0x7a, 0x65, 0x42, 0x79, 0x74, 0x65, 0x73, 0x88, 0x01, 0x01, 0x12, 0x20, 0x0a, 0x0b, + 0x63, 0x6f, 0x6d, 0x70, 0x72, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x07, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x0b, 0x63, 0x6f, 0x6d, 0x70, 0x72, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x68, + 0x0a, 0x10, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x5f, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, + 0x65, 0x73, 0x18, 0x08, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x3d, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, + 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x45, + 0x78, 0x70, 0x6f, 0x72, 0x74, 0x49, 0x63, 0x65, 0x62, 0x65, 0x72, 0x67, 0x43, 0x6f, 0x6e, 0x66, + 0x69, 0x67, 0x2e, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, + 0x65, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0f, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x50, 0x72, + 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x1a, 0x42, 0x0a, 0x14, 0x54, 0x61, 0x62, 0x6c, + 0x65, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, + 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, + 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x42, 0x09, 0x0a, 0x07, + 0x5f, 0x70, 0x72, 0x65, 0x66, 0x69, 0x78, 0x42, 0x19, 0x0a, 0x17, 0x5f, 0x74, 0x61, 0x72, 0x67, + 0x65, 0x74, 0x5f, 0x66, 0x69, 0x6c, 0x65, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x5f, 0x62, 0x79, 0x74, + 0x65, 0x73, 0x22, 0xa4, 0x02, 0x0a, 0x04, 0x52, 0x65, 0x61, 0x64, 0x12, 0x35, 0x0a, 0x06, 0x64, + 0x65, 0x6d, 0x61, 0x6e, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x72, 0x65, + 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, + 0x31, 0x2e, 0x44, 0x65, 0x6d, 0x61, 0x6e, 0x64, 0x48, 0x00, 0x52, 0x06, 0x64, 0x65, 0x6d, 0x61, + 0x6e, 0x64, 0x12, 0x35, 0x0a, 0x06, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x18, 0x02, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, + 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x4f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x48, + 0x00, 0x52, 0x06, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x12, 0x36, 0x0a, 0x07, 0x77, 0x68, 0x61, + 0x74, 0x5f, 0x69, 0x66, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x72, 0x65, 0x6c, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, + 0x2e, 0x57, 0x68, 0x61, 0x74, 0x49, 0x66, 0x48, 0x00, 0x52, 0x06, 0x77, 0x68, 0x61, 0x74, 0x49, + 0x66, 0x12, 0x32, 0x0a, 0x05, 0x61, 0x62, 0x6f, 0x72, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x1a, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, + 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x41, 0x62, 0x6f, 0x72, 0x74, 0x48, 0x00, 0x52, 0x05, + 0x61, 0x62, 0x6f, 0x72, 0x74, 0x12, 0x35, 0x0a, 0x06, 0x65, 0x78, 0x70, 0x6f, 0x72, 0x74, 0x18, + 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x45, 0x78, 0x70, 0x6f, + 0x72, 0x74, 0x48, 0x00, 0x52, 0x06, 0x65, 0x78, 0x70, 0x6f, 0x72, 0x74, 0x42, 0x0b, 0x0a, 0x09, + 0x72, 0x65, 0x61, 0x64, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x22, 0x4a, 0x0a, 0x06, 0x44, 0x65, 0x6d, + 0x61, 0x6e, 0x64, 0x12, 0x40, 0x0a, 0x0b, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, + 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, + 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x52, + 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x52, 0x0a, 0x72, 0x65, 0x6c, 0x61, 0x74, + 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x22, 0x5e, 0x0a, 0x06, 0x4f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x12, + 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, + 0x61, 0x6d, 0x65, 0x12, 0x40, 0x0a, 0x0b, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, + 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, + 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 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, 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 74665638..bef950aa 100644 --- a/sdks/go/src/parser.go +++ b/sdks/go/src/parser.go @@ -655,152 +655,152 @@ func toPascalCase(s string) string { // --- Helper functions --- func (p *Parser) _extract_value_int32(value *pb.Value, default_ int64) int32 { - var _t2103 interface{} + var _t2106 interface{} if (value != nil && hasProtoField(value, "int32_value")) { return value.GetInt32Value() } - _ = _t2103 + _ = _t2106 return int32(default_) } func (p *Parser) _extract_value_int64(value *pb.Value, default_ int64) int64 { - var _t2104 interface{} + var _t2107 interface{} if (value != nil && hasProtoField(value, "int_value")) { return value.GetIntValue() } - _ = _t2104 + _ = _t2107 return default_ } func (p *Parser) _extract_value_string(value *pb.Value, default_ string) string { - var _t2105 interface{} + var _t2108 interface{} if (value != nil && hasProtoField(value, "string_value")) { return value.GetStringValue() } - _ = _t2105 + _ = _t2108 return default_ } func (p *Parser) _extract_value_boolean(value *pb.Value, default_ bool) bool { - var _t2106 interface{} + var _t2109 interface{} if (value != nil && hasProtoField(value, "boolean_value")) { return value.GetBooleanValue() } - _ = _t2106 + _ = _t2109 return default_ } func (p *Parser) _extract_value_string_list(value *pb.Value, default_ []string) []string { - var _t2107 interface{} + var _t2110 interface{} if (value != nil && hasProtoField(value, "string_value")) { return []string{value.GetStringValue()} } - _ = _t2107 + _ = _t2110 return default_ } func (p *Parser) _try_extract_value_int64(value *pb.Value) *int64 { - var _t2108 interface{} + var _t2111 interface{} if (value != nil && hasProtoField(value, "int_value")) { return ptr(value.GetIntValue()) } - _ = _t2108 + _ = _t2111 return nil } func (p *Parser) _try_extract_value_float64(value *pb.Value) *float64 { - var _t2109 interface{} + var _t2112 interface{} if (value != nil && hasProtoField(value, "float_value")) { return ptr(value.GetFloatValue()) } - _ = _t2109 + _ = _t2112 return nil } func (p *Parser) _try_extract_value_bytes(value *pb.Value) []byte { - var _t2110 interface{} + var _t2113 interface{} if (value != nil && hasProtoField(value, "string_value")) { return []byte(value.GetStringValue()) } - _ = _t2110 + _ = _t2113 return nil } func (p *Parser) _try_extract_value_uint128(value *pb.Value) *pb.UInt128Value { - var _t2111 interface{} + var _t2114 interface{} if (value != nil && hasProtoField(value, "uint128_value")) { return value.GetUint128Value() } - _ = _t2111 + _ = _t2114 return nil } func (p *Parser) construct_csv_config(config_dict [][]interface{}) *pb.CSVConfig { config := dictFromList(config_dict) - _t2112 := p._extract_value_int32(dictGetValue(config, "csv_header_row"), 1) - header_row := _t2112 - _t2113 := p._extract_value_int64(dictGetValue(config, "csv_skip"), 0) - skip := _t2113 - _t2114 := p._extract_value_string(dictGetValue(config, "csv_new_line"), "") - new_line := _t2114 - _t2115 := p._extract_value_string(dictGetValue(config, "csv_delimiter"), ",") - delimiter := _t2115 - _t2116 := p._extract_value_string(dictGetValue(config, "csv_quotechar"), "\"") - quotechar := _t2116 - _t2117 := p._extract_value_string(dictGetValue(config, "csv_escapechar"), "\"") - escapechar := _t2117 - _t2118 := p._extract_value_string(dictGetValue(config, "csv_comment"), "") - comment := _t2118 - _t2119 := p._extract_value_string_list(dictGetValue(config, "csv_missing_strings"), []string{}) - missing_strings := _t2119 - _t2120 := p._extract_value_string(dictGetValue(config, "csv_decimal_separator"), ".") - decimal_separator := _t2120 - _t2121 := p._extract_value_string(dictGetValue(config, "csv_encoding"), "utf-8") - encoding := _t2121 - _t2122 := p._extract_value_string(dictGetValue(config, "csv_compression"), "auto") - compression := _t2122 - _t2123 := p._extract_value_int64(dictGetValue(config, "csv_partition_size_mb"), 0) - partition_size_mb := _t2123 - _t2124 := &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} - return _t2124 + _t2115 := p._extract_value_int32(dictGetValue(config, "csv_header_row"), 1) + header_row := _t2115 + _t2116 := p._extract_value_int64(dictGetValue(config, "csv_skip"), 0) + skip := _t2116 + _t2117 := p._extract_value_string(dictGetValue(config, "csv_new_line"), "") + new_line := _t2117 + _t2118 := p._extract_value_string(dictGetValue(config, "csv_delimiter"), ",") + delimiter := _t2118 + _t2119 := p._extract_value_string(dictGetValue(config, "csv_quotechar"), "\"") + quotechar := _t2119 + _t2120 := p._extract_value_string(dictGetValue(config, "csv_escapechar"), "\"") + escapechar := _t2120 + _t2121 := p._extract_value_string(dictGetValue(config, "csv_comment"), "") + comment := _t2121 + _t2122 := p._extract_value_string_list(dictGetValue(config, "csv_missing_strings"), []string{}) + missing_strings := _t2122 + _t2123 := p._extract_value_string(dictGetValue(config, "csv_decimal_separator"), ".") + decimal_separator := _t2123 + _t2124 := p._extract_value_string(dictGetValue(config, "csv_encoding"), "utf-8") + encoding := _t2124 + _t2125 := p._extract_value_string(dictGetValue(config, "csv_compression"), "auto") + compression := _t2125 + _t2126 := p._extract_value_int64(dictGetValue(config, "csv_partition_size_mb"), 0) + partition_size_mb := _t2126 + _t2127 := &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} + return _t2127 } func (p *Parser) construct_betree_info(key_types []*pb.Type, value_types []*pb.Type, config_dict [][]interface{}) *pb.BeTreeInfo { config := dictFromList(config_dict) - _t2125 := p._try_extract_value_float64(dictGetValue(config, "betree_config_epsilon")) - epsilon := _t2125 - _t2126 := p._try_extract_value_int64(dictGetValue(config, "betree_config_max_pivots")) - max_pivots := _t2126 - _t2127 := p._try_extract_value_int64(dictGetValue(config, "betree_config_max_deltas")) - max_deltas := _t2127 - _t2128 := p._try_extract_value_int64(dictGetValue(config, "betree_config_max_leaf")) - max_leaf := _t2128 - _t2129 := &pb.BeTreeConfig{Epsilon: deref(epsilon, 0.0), MaxPivots: deref(max_pivots, 0), MaxDeltas: deref(max_deltas, 0), MaxLeaf: deref(max_leaf, 0)} - storage_config := _t2129 - _t2130 := p._try_extract_value_uint128(dictGetValue(config, "betree_locator_root_pageid")) - root_pageid := _t2130 - _t2131 := p._try_extract_value_bytes(dictGetValue(config, "betree_locator_inline_data")) - inline_data := _t2131 - _t2132 := p._try_extract_value_int64(dictGetValue(config, "betree_locator_element_count")) - element_count := _t2132 - _t2133 := p._try_extract_value_int64(dictGetValue(config, "betree_locator_tree_height")) - tree_height := _t2133 - _t2134 := &pb.BeTreeLocator{ElementCount: deref(element_count, 0), TreeHeight: deref(tree_height, 0)} + _t2128 := p._try_extract_value_float64(dictGetValue(config, "betree_config_epsilon")) + epsilon := _t2128 + _t2129 := p._try_extract_value_int64(dictGetValue(config, "betree_config_max_pivots")) + max_pivots := _t2129 + _t2130 := p._try_extract_value_int64(dictGetValue(config, "betree_config_max_deltas")) + max_deltas := _t2130 + _t2131 := p._try_extract_value_int64(dictGetValue(config, "betree_config_max_leaf")) + max_leaf := _t2131 + _t2132 := &pb.BeTreeConfig{Epsilon: deref(epsilon, 0.0), MaxPivots: deref(max_pivots, 0), MaxDeltas: deref(max_deltas, 0), MaxLeaf: deref(max_leaf, 0)} + storage_config := _t2132 + _t2133 := p._try_extract_value_uint128(dictGetValue(config, "betree_locator_root_pageid")) + root_pageid := _t2133 + _t2134 := p._try_extract_value_bytes(dictGetValue(config, "betree_locator_inline_data")) + inline_data := _t2134 + _t2135 := p._try_extract_value_int64(dictGetValue(config, "betree_locator_element_count")) + element_count := _t2135 + _t2136 := p._try_extract_value_int64(dictGetValue(config, "betree_locator_tree_height")) + tree_height := _t2136 + _t2137 := &pb.BeTreeLocator{ElementCount: deref(element_count, 0), TreeHeight: deref(tree_height, 0)} if root_pageid != nil { - _t2134.Location = &pb.BeTreeLocator_RootPageid{RootPageid: root_pageid} + _t2137.Location = &pb.BeTreeLocator_RootPageid{RootPageid: root_pageid} } else { - _t2134.Location = &pb.BeTreeLocator_InlineData{InlineData: inline_data} + _t2137.Location = &pb.BeTreeLocator_InlineData{InlineData: inline_data} } - relation_locator := _t2134 - _t2135 := &pb.BeTreeInfo{KeyTypes: key_types, ValueTypes: value_types, StorageConfig: storage_config, RelationLocator: relation_locator} - return _t2135 + relation_locator := _t2137 + _t2138 := &pb.BeTreeInfo{KeyTypes: key_types, ValueTypes: value_types, StorageConfig: storage_config, RelationLocator: relation_locator} + return _t2138 } func (p *Parser) default_configure() *pb.Configure { - _t2136 := &pb.IVMConfig{Level: pb.MaintenanceLevel_MAINTENANCE_LEVEL_OFF} - ivm_config := _t2136 - _t2137 := &pb.Configure{SemanticsVersion: 0, IvmConfig: ivm_config} - return _t2137 + _t2139 := &pb.IVMConfig{Level: pb.MaintenanceLevel_MAINTENANCE_LEVEL_OFF} + ivm_config := _t2139 + _t2140 := &pb.Configure{SemanticsVersion: 0, IvmConfig: ivm_config} + return _t2140 } func (p *Parser) construct_configure(config_dict [][]interface{}) *pb.Configure { @@ -822,4269 +822,4271 @@ func (p *Parser) construct_configure(config_dict [][]interface{}) *pb.Configure } } } - _t2138 := &pb.IVMConfig{Level: maintenance_level} - ivm_config := _t2138 - _t2139 := p._extract_value_int64(dictGetValue(config, "semantics_version"), 0) - semantics_version := _t2139 - _t2140 := &pb.Configure{SemanticsVersion: semantics_version, IvmConfig: ivm_config} - return _t2140 + _t2141 := &pb.IVMConfig{Level: maintenance_level} + ivm_config := _t2141 + _t2142 := p._extract_value_int64(dictGetValue(config, "semantics_version"), 0) + semantics_version := _t2142 + _t2143 := &pb.Configure{SemanticsVersion: semantics_version, IvmConfig: ivm_config} + return _t2143 } func (p *Parser) construct_export_csv_config(path string, columns []*pb.ExportCSVColumn, config_dict [][]interface{}) *pb.ExportCSVConfig { config := dictFromList(config_dict) - _t2141 := p._extract_value_int64(dictGetValue(config, "partition_size"), 0) - partition_size := _t2141 - _t2142 := p._extract_value_string(dictGetValue(config, "compression"), "") - compression := _t2142 - _t2143 := p._extract_value_boolean(dictGetValue(config, "syntax_header_row"), true) - syntax_header_row := _t2143 - _t2144 := p._extract_value_string(dictGetValue(config, "syntax_missing_string"), "") - syntax_missing_string := _t2144 - _t2145 := p._extract_value_string(dictGetValue(config, "syntax_delim"), ",") - syntax_delim := _t2145 - _t2146 := p._extract_value_string(dictGetValue(config, "syntax_quotechar"), "\"") - syntax_quotechar := _t2146 - _t2147 := p._extract_value_string(dictGetValue(config, "syntax_escapechar"), "\\") - syntax_escapechar := _t2147 - _t2148 := &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 _t2148 + _t2144 := p._extract_value_int64(dictGetValue(config, "partition_size"), 0) + partition_size := _t2144 + _t2145 := p._extract_value_string(dictGetValue(config, "compression"), "") + compression := _t2145 + _t2146 := p._extract_value_boolean(dictGetValue(config, "syntax_header_row"), true) + syntax_header_row := _t2146 + _t2147 := p._extract_value_string(dictGetValue(config, "syntax_missing_string"), "") + syntax_missing_string := _t2147 + _t2148 := p._extract_value_string(dictGetValue(config, "syntax_delim"), ",") + syntax_delim := _t2148 + _t2149 := p._extract_value_string(dictGetValue(config, "syntax_quotechar"), "\"") + syntax_quotechar := _t2149 + _t2150 := p._extract_value_string(dictGetValue(config, "syntax_escapechar"), "\\") + syntax_escapechar := _t2150 + _t2151 := &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 _t2151 } func (p *Parser) construct_export_csv_config_with_source(path string, csv_source *pb.ExportCSVSource, csv_config *pb.CSVConfig) *pb.ExportCSVConfig { - _t2149 := &pb.ExportCSVConfig{Path: path, CsvSource: csv_source, CsvConfig: csv_config} - return _t2149 + _t2152 := &pb.ExportCSVConfig{Path: path, CsvSource: csv_source, CsvConfig: csv_config} + return _t2152 } 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) - _t2150 := &pb.IcebergCatalogConfig{CatalogUri: catalog_uri, Scope: ptr(deref(scope_opt, "")), Properties: props, AuthProperties: auth_props} - return _t2150 + _t2153 := &pb.IcebergCatalogConfig{CatalogUri: catalog_uri, Scope: ptr(deref(scope_opt, "")), Properties: props, AuthProperties: auth_props} + return _t2153 } 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 { - _t2151 := &pb.IcebergData{Locator: locator, Config: config, Columns: columns, FromSnapshot: ptr(deref(from_snapshot_opt, "")), ToSnapshot: ptr(deref(to_snapshot_opt, "")), ReturnsDelta: returns_delta} - return _t2151 + _t2154 := &pb.IcebergData{Locator: locator, Config: config, Columns: columns, FromSnapshot: ptr(deref(from_snapshot_opt, "")), ToSnapshot: ptr(deref(to_snapshot_opt, "")), ReturnsDelta: returns_delta} + return _t2154 } func (p *Parser) construct_export_iceberg_config_full(locator *pb.IcebergLocator, config *pb.IcebergCatalogConfig, table_def *pb.RelationId, columns []*pb.ExportColumn, table_property_pairs [][]interface{}, config_dict [][]interface{}) *pb.ExportIcebergConfig { - _t2152 := config_dict + _t2155 := config_dict if config_dict == nil { - _t2152 = [][]interface{}{} - } - cfg := dictFromList(_t2152) - _t2153 := p._extract_value_string(dictGetValue(cfg, "prefix"), "") - prefix := _t2153 - _t2154 := p._extract_value_int64(dictGetValue(cfg, "target_file_size_bytes"), 0) - target_file_size_bytes := _t2154 - _t2155 := p._extract_value_string(dictGetValue(cfg, "compression"), "") - compression := _t2155 + _t2155 = [][]interface{}{} + } + cfg := dictFromList(_t2155) + _t2156 := p._extract_value_string(dictGetValue(cfg, "prefix"), "") + prefix := _t2156 + _t2157 := p._extract_value_int64(dictGetValue(cfg, "target_file_size_bytes"), 0) + target_file_size_bytes := _t2157 + _t2158 := p._extract_value_string(dictGetValue(cfg, "compression"), "") + compression := _t2158 table_props := stringMapFromPairs(table_property_pairs) - _t2156 := &pb.ExportIcebergConfig{Locator: locator, Config: config, TableDef: table_def, Columns: columns, Prefix: ptr(prefix), TargetFileSizeBytes: ptr(target_file_size_bytes), Compression: compression, TableProperties: table_props} - return _t2156 + _t2159 := &pb.ExportIcebergConfig{Locator: locator, Config: config, TableDef: table_def, Columns: columns, Prefix: ptr(prefix), TargetFileSizeBytes: ptr(target_file_size_bytes), Compression: compression, TableProperties: table_props} + return _t2159 } // --- Parse functions --- func (p *Parser) parse_transaction() *pb.Transaction { - span_start677 := int64(p.spanStart()) + span_start678 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("transaction") - var _t1342 *pb.Configure + var _t1344 *pb.Configure if (p.matchLookaheadLiteral("(", 0) && p.matchLookaheadLiteral("configure", 1)) { - _t1343 := p.parse_configure() - _t1342 = _t1343 - } - configure671 := _t1342 - var _t1344 *pb.Sync - if (p.matchLookaheadLiteral("(", 0) && p.matchLookaheadLiteral("sync", 1)) { - _t1345 := p.parse_sync() + _t1345 := p.parse_configure() _t1344 = _t1345 } - sync672 := _t1344 - xs673 := []*pb.Epoch{} - cond674 := p.matchLookaheadLiteral("(", 0) - for cond674 { - _t1346 := p.parse_epoch() - item675 := _t1346 - xs673 = append(xs673, item675) - cond674 = p.matchLookaheadLiteral("(", 0) - } - epochs676 := xs673 + configure672 := _t1344 + var _t1346 *pb.Sync + if (p.matchLookaheadLiteral("(", 0) && p.matchLookaheadLiteral("sync", 1)) { + _t1347 := p.parse_sync() + _t1346 = _t1347 + } + sync673 := _t1346 + xs674 := []*pb.Epoch{} + cond675 := p.matchLookaheadLiteral("(", 0) + for cond675 { + _t1348 := p.parse_epoch() + item676 := _t1348 + xs674 = append(xs674, item676) + cond675 = p.matchLookaheadLiteral("(", 0) + } + epochs677 := xs674 p.consumeLiteral(")") - _t1347 := p.default_configure() - _t1348 := configure671 - if configure671 == nil { - _t1348 = _t1347 + _t1349 := p.default_configure() + _t1350 := configure672 + if configure672 == nil { + _t1350 = _t1349 } - _t1349 := &pb.Transaction{Epochs: epochs676, Configure: _t1348, Sync: sync672} - result678 := _t1349 - p.recordSpan(int(span_start677), "Transaction") - return result678 + _t1351 := &pb.Transaction{Epochs: epochs677, Configure: _t1350, Sync: sync673} + result679 := _t1351 + p.recordSpan(int(span_start678), "Transaction") + return result679 } func (p *Parser) parse_configure() *pb.Configure { - span_start680 := int64(p.spanStart()) + span_start681 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("configure") - _t1350 := p.parse_config_dict() - config_dict679 := _t1350 + _t1352 := p.parse_config_dict() + config_dict680 := _t1352 p.consumeLiteral(")") - _t1351 := p.construct_configure(config_dict679) - result681 := _t1351 - p.recordSpan(int(span_start680), "Configure") - return result681 + _t1353 := p.construct_configure(config_dict680) + result682 := _t1353 + p.recordSpan(int(span_start681), "Configure") + return result682 } func (p *Parser) parse_config_dict() [][]interface{} { p.consumeLiteral("{") - xs682 := [][]interface{}{} - cond683 := p.matchLookaheadLiteral(":", 0) - for cond683 { - _t1352 := p.parse_config_key_value() - item684 := _t1352 - xs682 = append(xs682, item684) - cond683 = p.matchLookaheadLiteral(":", 0) - } - config_key_values685 := xs682 + xs683 := [][]interface{}{} + cond684 := p.matchLookaheadLiteral(":", 0) + for cond684 { + _t1354 := p.parse_config_key_value() + item685 := _t1354 + xs683 = append(xs683, item685) + cond684 = p.matchLookaheadLiteral(":", 0) + } + config_key_values686 := xs683 p.consumeLiteral("}") - return config_key_values685 + return config_key_values686 } func (p *Parser) parse_config_key_value() []interface{} { p.consumeLiteral(":") - symbol686 := p.consumeTerminal("SYMBOL").Value.str - _t1353 := p.parse_raw_value() - raw_value687 := _t1353 - return []interface{}{symbol686, raw_value687} + symbol687 := p.consumeTerminal("SYMBOL").Value.str + _t1355 := p.parse_raw_value() + raw_value688 := _t1355 + return []interface{}{symbol687, raw_value688} } func (p *Parser) parse_raw_value() *pb.Value { - span_start701 := int64(p.spanStart()) - var _t1354 int64 + span_start702 := int64(p.spanStart()) + var _t1356 int64 if p.matchLookaheadLiteral("true", 0) { - _t1354 = 12 + _t1356 = 12 } else { - var _t1355 int64 + var _t1357 int64 if p.matchLookaheadLiteral("missing", 0) { - _t1355 = 11 + _t1357 = 11 } else { - var _t1356 int64 + var _t1358 int64 if p.matchLookaheadLiteral("false", 0) { - _t1356 = 12 + _t1358 = 12 } else { - var _t1357 int64 + var _t1359 int64 if p.matchLookaheadLiteral("(", 0) { - var _t1358 int64 + var _t1360 int64 if p.matchLookaheadLiteral("datetime", 1) { - _t1358 = 1 + _t1360 = 1 } else { - var _t1359 int64 + var _t1361 int64 if p.matchLookaheadLiteral("date", 1) { - _t1359 = 0 + _t1361 = 0 } else { - _t1359 = -1 + _t1361 = -1 } - _t1358 = _t1359 + _t1360 = _t1361 } - _t1357 = _t1358 + _t1359 = _t1360 } else { - var _t1360 int64 + var _t1362 int64 if p.matchLookaheadTerminal("UINT32", 0) { - _t1360 = 7 + _t1362 = 7 } else { - var _t1361 int64 + var _t1363 int64 if p.matchLookaheadTerminal("UINT128", 0) { - _t1361 = 8 + _t1363 = 8 } else { - var _t1362 int64 + var _t1364 int64 if p.matchLookaheadTerminal("STRING", 0) { - _t1362 = 2 + _t1364 = 2 } else { - var _t1363 int64 + var _t1365 int64 if p.matchLookaheadTerminal("INT32", 0) { - _t1363 = 3 + _t1365 = 3 } else { - var _t1364 int64 + var _t1366 int64 if p.matchLookaheadTerminal("INT128", 0) { - _t1364 = 9 + _t1366 = 9 } else { - var _t1365 int64 + var _t1367 int64 if p.matchLookaheadTerminal("INT", 0) { - _t1365 = 4 + _t1367 = 4 } else { - var _t1366 int64 + var _t1368 int64 if p.matchLookaheadTerminal("FLOAT32", 0) { - _t1366 = 5 + _t1368 = 5 } else { - var _t1367 int64 + var _t1369 int64 if p.matchLookaheadTerminal("FLOAT", 0) { - _t1367 = 6 + _t1369 = 6 } else { - var _t1368 int64 + var _t1370 int64 if p.matchLookaheadTerminal("DECIMAL", 0) { - _t1368 = 10 + _t1370 = 10 } else { - _t1368 = -1 + _t1370 = -1 } - _t1367 = _t1368 + _t1369 = _t1370 } - _t1366 = _t1367 + _t1368 = _t1369 } - _t1365 = _t1366 + _t1367 = _t1368 } - _t1364 = _t1365 + _t1366 = _t1367 } - _t1363 = _t1364 + _t1365 = _t1366 } - _t1362 = _t1363 + _t1364 = _t1365 } - _t1361 = _t1362 + _t1363 = _t1364 } - _t1360 = _t1361 + _t1362 = _t1363 } - _t1357 = _t1360 + _t1359 = _t1362 } - _t1356 = _t1357 + _t1358 = _t1359 } - _t1355 = _t1356 + _t1357 = _t1358 } - _t1354 = _t1355 - } - prediction688 := _t1354 - var _t1369 *pb.Value - if prediction688 == 12 { - _t1370 := p.parse_boolean_value() - boolean_value700 := _t1370 - _t1371 := &pb.Value{} - _t1371.Value = &pb.Value_BooleanValue{BooleanValue: boolean_value700} - _t1369 = _t1371 + _t1356 = _t1357 + } + prediction689 := _t1356 + var _t1371 *pb.Value + if prediction689 == 12 { + _t1372 := p.parse_boolean_value() + boolean_value701 := _t1372 + _t1373 := &pb.Value{} + _t1373.Value = &pb.Value_BooleanValue{BooleanValue: boolean_value701} + _t1371 = _t1373 } else { - var _t1372 *pb.Value - if prediction688 == 11 { + var _t1374 *pb.Value + if prediction689 == 11 { p.consumeLiteral("missing") - _t1373 := &pb.MissingValue{} - _t1374 := &pb.Value{} - _t1374.Value = &pb.Value_MissingValue{MissingValue: _t1373} - _t1372 = _t1374 + _t1375 := &pb.MissingValue{} + _t1376 := &pb.Value{} + _t1376.Value = &pb.Value_MissingValue{MissingValue: _t1375} + _t1374 = _t1376 } else { - var _t1375 *pb.Value - if prediction688 == 10 { - decimal699 := p.consumeTerminal("DECIMAL").Value.decimal - _t1376 := &pb.Value{} - _t1376.Value = &pb.Value_DecimalValue{DecimalValue: decimal699} - _t1375 = _t1376 + var _t1377 *pb.Value + if prediction689 == 10 { + decimal700 := p.consumeTerminal("DECIMAL").Value.decimal + _t1378 := &pb.Value{} + _t1378.Value = &pb.Value_DecimalValue{DecimalValue: decimal700} + _t1377 = _t1378 } else { - var _t1377 *pb.Value - if prediction688 == 9 { - int128698 := p.consumeTerminal("INT128").Value.int128 - _t1378 := &pb.Value{} - _t1378.Value = &pb.Value_Int128Value{Int128Value: int128698} - _t1377 = _t1378 + var _t1379 *pb.Value + if prediction689 == 9 { + int128699 := p.consumeTerminal("INT128").Value.int128 + _t1380 := &pb.Value{} + _t1380.Value = &pb.Value_Int128Value{Int128Value: int128699} + _t1379 = _t1380 } else { - var _t1379 *pb.Value - if prediction688 == 8 { - uint128697 := p.consumeTerminal("UINT128").Value.uint128 - _t1380 := &pb.Value{} - _t1380.Value = &pb.Value_Uint128Value{Uint128Value: uint128697} - _t1379 = _t1380 + var _t1381 *pb.Value + if prediction689 == 8 { + uint128698 := p.consumeTerminal("UINT128").Value.uint128 + _t1382 := &pb.Value{} + _t1382.Value = &pb.Value_Uint128Value{Uint128Value: uint128698} + _t1381 = _t1382 } else { - var _t1381 *pb.Value - if prediction688 == 7 { - uint32696 := p.consumeTerminal("UINT32").Value.u32 - _t1382 := &pb.Value{} - _t1382.Value = &pb.Value_Uint32Value{Uint32Value: uint32696} - _t1381 = _t1382 + var _t1383 *pb.Value + if prediction689 == 7 { + uint32697 := p.consumeTerminal("UINT32").Value.u32 + _t1384 := &pb.Value{} + _t1384.Value = &pb.Value_Uint32Value{Uint32Value: uint32697} + _t1383 = _t1384 } else { - var _t1383 *pb.Value - if prediction688 == 6 { - float695 := p.consumeTerminal("FLOAT").Value.f64 - _t1384 := &pb.Value{} - _t1384.Value = &pb.Value_FloatValue{FloatValue: float695} - _t1383 = _t1384 + var _t1385 *pb.Value + if prediction689 == 6 { + float696 := p.consumeTerminal("FLOAT").Value.f64 + _t1386 := &pb.Value{} + _t1386.Value = &pb.Value_FloatValue{FloatValue: float696} + _t1385 = _t1386 } else { - var _t1385 *pb.Value - if prediction688 == 5 { - float32694 := p.consumeTerminal("FLOAT32").Value.f32 - _t1386 := &pb.Value{} - _t1386.Value = &pb.Value_Float32Value{Float32Value: float32694} - _t1385 = _t1386 + var _t1387 *pb.Value + if prediction689 == 5 { + float32695 := p.consumeTerminal("FLOAT32").Value.f32 + _t1388 := &pb.Value{} + _t1388.Value = &pb.Value_Float32Value{Float32Value: float32695} + _t1387 = _t1388 } else { - var _t1387 *pb.Value - if prediction688 == 4 { - int693 := p.consumeTerminal("INT").Value.i64 - _t1388 := &pb.Value{} - _t1388.Value = &pb.Value_IntValue{IntValue: int693} - _t1387 = _t1388 + var _t1389 *pb.Value + if prediction689 == 4 { + int694 := p.consumeTerminal("INT").Value.i64 + _t1390 := &pb.Value{} + _t1390.Value = &pb.Value_IntValue{IntValue: int694} + _t1389 = _t1390 } else { - var _t1389 *pb.Value - if prediction688 == 3 { - int32692 := p.consumeTerminal("INT32").Value.i32 - _t1390 := &pb.Value{} - _t1390.Value = &pb.Value_Int32Value{Int32Value: int32692} - _t1389 = _t1390 + var _t1391 *pb.Value + if prediction689 == 3 { + int32693 := p.consumeTerminal("INT32").Value.i32 + _t1392 := &pb.Value{} + _t1392.Value = &pb.Value_Int32Value{Int32Value: int32693} + _t1391 = _t1392 } else { - var _t1391 *pb.Value - if prediction688 == 2 { - string691 := p.consumeTerminal("STRING").Value.str - _t1392 := &pb.Value{} - _t1392.Value = &pb.Value_StringValue{StringValue: string691} - _t1391 = _t1392 + var _t1393 *pb.Value + if prediction689 == 2 { + string692 := p.consumeTerminal("STRING").Value.str + _t1394 := &pb.Value{} + _t1394.Value = &pb.Value_StringValue{StringValue: string692} + _t1393 = _t1394 } else { - var _t1393 *pb.Value - if prediction688 == 1 { - _t1394 := p.parse_raw_datetime() - raw_datetime690 := _t1394 - _t1395 := &pb.Value{} - _t1395.Value = &pb.Value_DatetimeValue{DatetimeValue: raw_datetime690} - _t1393 = _t1395 + var _t1395 *pb.Value + if prediction689 == 1 { + _t1396 := p.parse_raw_datetime() + raw_datetime691 := _t1396 + _t1397 := &pb.Value{} + _t1397.Value = &pb.Value_DatetimeValue{DatetimeValue: raw_datetime691} + _t1395 = _t1397 } else { - var _t1396 *pb.Value - if prediction688 == 0 { - _t1397 := p.parse_raw_date() - raw_date689 := _t1397 - _t1398 := &pb.Value{} - _t1398.Value = &pb.Value_DateValue{DateValue: raw_date689} - _t1396 = _t1398 + var _t1398 *pb.Value + if prediction689 == 0 { + _t1399 := p.parse_raw_date() + raw_date690 := _t1399 + _t1400 := &pb.Value{} + _t1400.Value = &pb.Value_DateValue{DateValue: raw_date690} + _t1398 = _t1400 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in raw_value", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1393 = _t1396 + _t1395 = _t1398 } - _t1391 = _t1393 + _t1393 = _t1395 } - _t1389 = _t1391 + _t1391 = _t1393 } - _t1387 = _t1389 + _t1389 = _t1391 } - _t1385 = _t1387 + _t1387 = _t1389 } - _t1383 = _t1385 + _t1385 = _t1387 } - _t1381 = _t1383 + _t1383 = _t1385 } - _t1379 = _t1381 + _t1381 = _t1383 } - _t1377 = _t1379 + _t1379 = _t1381 } - _t1375 = _t1377 + _t1377 = _t1379 } - _t1372 = _t1375 + _t1374 = _t1377 } - _t1369 = _t1372 + _t1371 = _t1374 } - result702 := _t1369 - p.recordSpan(int(span_start701), "Value") - return result702 + result703 := _t1371 + p.recordSpan(int(span_start702), "Value") + return result703 } func (p *Parser) parse_raw_date() *pb.DateValue { - span_start706 := int64(p.spanStart()) + span_start707 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("date") - int703 := p.consumeTerminal("INT").Value.i64 - int_3704 := p.consumeTerminal("INT").Value.i64 - int_4705 := p.consumeTerminal("INT").Value.i64 + int704 := p.consumeTerminal("INT").Value.i64 + int_3705 := p.consumeTerminal("INT").Value.i64 + int_4706 := p.consumeTerminal("INT").Value.i64 p.consumeLiteral(")") - _t1399 := &pb.DateValue{Year: int32(int703), Month: int32(int_3704), Day: int32(int_4705)} - result707 := _t1399 - p.recordSpan(int(span_start706), "DateValue") - return result707 + _t1401 := &pb.DateValue{Year: int32(int704), Month: int32(int_3705), Day: int32(int_4706)} + result708 := _t1401 + p.recordSpan(int(span_start707), "DateValue") + return result708 } func (p *Parser) parse_raw_datetime() *pb.DateTimeValue { - span_start715 := int64(p.spanStart()) + span_start716 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("datetime") - int708 := p.consumeTerminal("INT").Value.i64 - int_3709 := p.consumeTerminal("INT").Value.i64 - int_4710 := p.consumeTerminal("INT").Value.i64 - int_5711 := p.consumeTerminal("INT").Value.i64 - int_6712 := p.consumeTerminal("INT").Value.i64 - int_7713 := p.consumeTerminal("INT").Value.i64 - var _t1400 *int64 + int709 := p.consumeTerminal("INT").Value.i64 + int_3710 := p.consumeTerminal("INT").Value.i64 + int_4711 := p.consumeTerminal("INT").Value.i64 + int_5712 := p.consumeTerminal("INT").Value.i64 + int_6713 := p.consumeTerminal("INT").Value.i64 + int_7714 := p.consumeTerminal("INT").Value.i64 + var _t1402 *int64 if p.matchLookaheadTerminal("INT", 0) { - _t1400 = ptr(p.consumeTerminal("INT").Value.i64) + _t1402 = ptr(p.consumeTerminal("INT").Value.i64) } - int_8714 := _t1400 + int_8715 := _t1402 p.consumeLiteral(")") - _t1401 := &pb.DateTimeValue{Year: int32(int708), Month: int32(int_3709), Day: int32(int_4710), Hour: int32(int_5711), Minute: int32(int_6712), Second: int32(int_7713), Microsecond: int32(deref(int_8714, 0))} - result716 := _t1401 - p.recordSpan(int(span_start715), "DateTimeValue") - return result716 + _t1403 := &pb.DateTimeValue{Year: int32(int709), Month: int32(int_3710), Day: int32(int_4711), Hour: int32(int_5712), Minute: int32(int_6713), Second: int32(int_7714), Microsecond: int32(deref(int_8715, 0))} + result717 := _t1403 + p.recordSpan(int(span_start716), "DateTimeValue") + return result717 } func (p *Parser) parse_boolean_value() bool { - var _t1402 int64 + var _t1404 int64 if p.matchLookaheadLiteral("true", 0) { - _t1402 = 0 + _t1404 = 0 } else { - var _t1403 int64 + var _t1405 int64 if p.matchLookaheadLiteral("false", 0) { - _t1403 = 1 + _t1405 = 1 } else { - _t1403 = -1 + _t1405 = -1 } - _t1402 = _t1403 + _t1404 = _t1405 } - prediction717 := _t1402 - var _t1404 bool - if prediction717 == 1 { + prediction718 := _t1404 + var _t1406 bool + if prediction718 == 1 { p.consumeLiteral("false") - _t1404 = false + _t1406 = false } else { - var _t1405 bool - if prediction717 == 0 { + var _t1407 bool + if prediction718 == 0 { p.consumeLiteral("true") - _t1405 = true + _t1407 = true } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in boolean_value", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1404 = _t1405 + _t1406 = _t1407 } - return _t1404 + return _t1406 } func (p *Parser) parse_sync() *pb.Sync { - span_start722 := int64(p.spanStart()) + span_start723 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("sync") - xs718 := []*pb.FragmentId{} - cond719 := p.matchLookaheadLiteral(":", 0) - for cond719 { - _t1406 := p.parse_fragment_id() - item720 := _t1406 - xs718 = append(xs718, item720) - cond719 = p.matchLookaheadLiteral(":", 0) - } - fragment_ids721 := xs718 + xs719 := []*pb.FragmentId{} + cond720 := p.matchLookaheadLiteral(":", 0) + for cond720 { + _t1408 := p.parse_fragment_id() + item721 := _t1408 + xs719 = append(xs719, item721) + cond720 = p.matchLookaheadLiteral(":", 0) + } + fragment_ids722 := xs719 p.consumeLiteral(")") - _t1407 := &pb.Sync{Fragments: fragment_ids721} - result723 := _t1407 - p.recordSpan(int(span_start722), "Sync") - return result723 + _t1409 := &pb.Sync{Fragments: fragment_ids722} + result724 := _t1409 + p.recordSpan(int(span_start723), "Sync") + return result724 } func (p *Parser) parse_fragment_id() *pb.FragmentId { - span_start725 := int64(p.spanStart()) + span_start726 := int64(p.spanStart()) p.consumeLiteral(":") - symbol724 := p.consumeTerminal("SYMBOL").Value.str - result726 := &pb.FragmentId{Id: []byte(symbol724)} - p.recordSpan(int(span_start725), "FragmentId") - return result726 + symbol725 := p.consumeTerminal("SYMBOL").Value.str + result727 := &pb.FragmentId{Id: []byte(symbol725)} + p.recordSpan(int(span_start726), "FragmentId") + return result727 } func (p *Parser) parse_epoch() *pb.Epoch { - span_start729 := int64(p.spanStart()) + span_start730 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("epoch") - var _t1408 []*pb.Write + var _t1410 []*pb.Write if (p.matchLookaheadLiteral("(", 0) && p.matchLookaheadLiteral("writes", 1)) { - _t1409 := p.parse_epoch_writes() - _t1408 = _t1409 + _t1411 := p.parse_epoch_writes() + _t1410 = _t1411 } - epoch_writes727 := _t1408 - var _t1410 []*pb.Read + epoch_writes728 := _t1410 + var _t1412 []*pb.Read if p.matchLookaheadLiteral("(", 0) { - _t1411 := p.parse_epoch_reads() - _t1410 = _t1411 + _t1413 := p.parse_epoch_reads() + _t1412 = _t1413 } - epoch_reads728 := _t1410 + epoch_reads729 := _t1412 p.consumeLiteral(")") - _t1412 := epoch_writes727 - if epoch_writes727 == nil { - _t1412 = []*pb.Write{} + _t1414 := epoch_writes728 + if epoch_writes728 == nil { + _t1414 = []*pb.Write{} } - _t1413 := epoch_reads728 - if epoch_reads728 == nil { - _t1413 = []*pb.Read{} + _t1415 := epoch_reads729 + if epoch_reads729 == nil { + _t1415 = []*pb.Read{} } - _t1414 := &pb.Epoch{Writes: _t1412, Reads: _t1413} - result730 := _t1414 - p.recordSpan(int(span_start729), "Epoch") - return result730 + _t1416 := &pb.Epoch{Writes: _t1414, Reads: _t1415} + result731 := _t1416 + p.recordSpan(int(span_start730), "Epoch") + return result731 } func (p *Parser) parse_epoch_writes() []*pb.Write { p.consumeLiteral("(") p.consumeLiteral("writes") - xs731 := []*pb.Write{} - cond732 := p.matchLookaheadLiteral("(", 0) - for cond732 { - _t1415 := p.parse_write() - item733 := _t1415 - xs731 = append(xs731, item733) - cond732 = p.matchLookaheadLiteral("(", 0) - } - writes734 := xs731 + xs732 := []*pb.Write{} + cond733 := p.matchLookaheadLiteral("(", 0) + for cond733 { + _t1417 := p.parse_write() + item734 := _t1417 + xs732 = append(xs732, item734) + cond733 = p.matchLookaheadLiteral("(", 0) + } + writes735 := xs732 p.consumeLiteral(")") - return writes734 + return writes735 } func (p *Parser) parse_write() *pb.Write { - span_start740 := int64(p.spanStart()) - var _t1416 int64 + span_start741 := int64(p.spanStart()) + var _t1418 int64 if p.matchLookaheadLiteral("(", 0) { - var _t1417 int64 + var _t1419 int64 if p.matchLookaheadLiteral("undefine", 1) { - _t1417 = 1 + _t1419 = 1 } else { - var _t1418 int64 + var _t1420 int64 if p.matchLookaheadLiteral("snapshot", 1) { - _t1418 = 3 + _t1420 = 3 } else { - var _t1419 int64 + var _t1421 int64 if p.matchLookaheadLiteral("define", 1) { - _t1419 = 0 + _t1421 = 0 } else { - var _t1420 int64 + var _t1422 int64 if p.matchLookaheadLiteral("context", 1) { - _t1420 = 2 + _t1422 = 2 } else { - _t1420 = -1 + _t1422 = -1 } - _t1419 = _t1420 + _t1421 = _t1422 } - _t1418 = _t1419 + _t1420 = _t1421 } - _t1417 = _t1418 + _t1419 = _t1420 } - _t1416 = _t1417 + _t1418 = _t1419 } else { - _t1416 = -1 - } - prediction735 := _t1416 - var _t1421 *pb.Write - if prediction735 == 3 { - _t1422 := p.parse_snapshot() - snapshot739 := _t1422 - _t1423 := &pb.Write{} - _t1423.WriteType = &pb.Write_Snapshot{Snapshot: snapshot739} - _t1421 = _t1423 + _t1418 = -1 + } + prediction736 := _t1418 + var _t1423 *pb.Write + if prediction736 == 3 { + _t1424 := p.parse_snapshot() + snapshot740 := _t1424 + _t1425 := &pb.Write{} + _t1425.WriteType = &pb.Write_Snapshot{Snapshot: snapshot740} + _t1423 = _t1425 } else { - var _t1424 *pb.Write - if prediction735 == 2 { - _t1425 := p.parse_context() - context738 := _t1425 - _t1426 := &pb.Write{} - _t1426.WriteType = &pb.Write_Context{Context: context738} - _t1424 = _t1426 + var _t1426 *pb.Write + if prediction736 == 2 { + _t1427 := p.parse_context() + context739 := _t1427 + _t1428 := &pb.Write{} + _t1428.WriteType = &pb.Write_Context{Context: context739} + _t1426 = _t1428 } else { - var _t1427 *pb.Write - if prediction735 == 1 { - _t1428 := p.parse_undefine() - undefine737 := _t1428 - _t1429 := &pb.Write{} - _t1429.WriteType = &pb.Write_Undefine{Undefine: undefine737} - _t1427 = _t1429 + var _t1429 *pb.Write + if prediction736 == 1 { + _t1430 := p.parse_undefine() + undefine738 := _t1430 + _t1431 := &pb.Write{} + _t1431.WriteType = &pb.Write_Undefine{Undefine: undefine738} + _t1429 = _t1431 } else { - var _t1430 *pb.Write - if prediction735 == 0 { - _t1431 := p.parse_define() - define736 := _t1431 - _t1432 := &pb.Write{} - _t1432.WriteType = &pb.Write_Define{Define: define736} - _t1430 = _t1432 + var _t1432 *pb.Write + if prediction736 == 0 { + _t1433 := p.parse_define() + define737 := _t1433 + _t1434 := &pb.Write{} + _t1434.WriteType = &pb.Write_Define{Define: define737} + _t1432 = _t1434 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in write", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1427 = _t1430 + _t1429 = _t1432 } - _t1424 = _t1427 + _t1426 = _t1429 } - _t1421 = _t1424 + _t1423 = _t1426 } - result741 := _t1421 - p.recordSpan(int(span_start740), "Write") - return result741 + result742 := _t1423 + p.recordSpan(int(span_start741), "Write") + return result742 } func (p *Parser) parse_define() *pb.Define { - span_start743 := int64(p.spanStart()) + span_start744 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("define") - _t1433 := p.parse_fragment() - fragment742 := _t1433 + _t1435 := p.parse_fragment() + fragment743 := _t1435 p.consumeLiteral(")") - _t1434 := &pb.Define{Fragment: fragment742} - result744 := _t1434 - p.recordSpan(int(span_start743), "Define") - return result744 + _t1436 := &pb.Define{Fragment: fragment743} + result745 := _t1436 + p.recordSpan(int(span_start744), "Define") + return result745 } func (p *Parser) parse_fragment() *pb.Fragment { - span_start750 := int64(p.spanStart()) + span_start751 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("fragment") - _t1435 := p.parse_new_fragment_id() - new_fragment_id745 := _t1435 - xs746 := []*pb.Declaration{} - cond747 := p.matchLookaheadLiteral("(", 0) - for cond747 { - _t1436 := p.parse_declaration() - item748 := _t1436 - xs746 = append(xs746, item748) - cond747 = p.matchLookaheadLiteral("(", 0) - } - declarations749 := xs746 + _t1437 := p.parse_new_fragment_id() + new_fragment_id746 := _t1437 + xs747 := []*pb.Declaration{} + cond748 := p.matchLookaheadLiteral("(", 0) + for cond748 { + _t1438 := p.parse_declaration() + item749 := _t1438 + xs747 = append(xs747, item749) + cond748 = p.matchLookaheadLiteral("(", 0) + } + declarations750 := xs747 p.consumeLiteral(")") - result751 := p.constructFragment(new_fragment_id745, declarations749) - p.recordSpan(int(span_start750), "Fragment") - return result751 + result752 := p.constructFragment(new_fragment_id746, declarations750) + p.recordSpan(int(span_start751), "Fragment") + return result752 } func (p *Parser) parse_new_fragment_id() *pb.FragmentId { - span_start753 := int64(p.spanStart()) - _t1437 := p.parse_fragment_id() - fragment_id752 := _t1437 - p.startFragment(fragment_id752) - result754 := fragment_id752 - p.recordSpan(int(span_start753), "FragmentId") - return result754 + span_start754 := int64(p.spanStart()) + _t1439 := p.parse_fragment_id() + fragment_id753 := _t1439 + p.startFragment(fragment_id753) + result755 := fragment_id753 + p.recordSpan(int(span_start754), "FragmentId") + return result755 } func (p *Parser) parse_declaration() *pb.Declaration { - span_start760 := int64(p.spanStart()) - var _t1438 int64 + span_start761 := int64(p.spanStart()) + var _t1440 int64 if p.matchLookaheadLiteral("(", 0) { - var _t1439 int64 + var _t1441 int64 if p.matchLookaheadLiteral("iceberg_data", 1) { - _t1439 = 3 + _t1441 = 3 } else { - var _t1440 int64 + var _t1442 int64 if p.matchLookaheadLiteral("functional_dependency", 1) { - _t1440 = 2 + _t1442 = 2 } else { - var _t1441 int64 + var _t1443 int64 if p.matchLookaheadLiteral("edb", 1) { - _t1441 = 3 + _t1443 = 3 } else { - var _t1442 int64 + var _t1444 int64 if p.matchLookaheadLiteral("def", 1) { - _t1442 = 0 + _t1444 = 0 } else { - var _t1443 int64 + var _t1445 int64 if p.matchLookaheadLiteral("csv_data", 1) { - _t1443 = 3 + _t1445 = 3 } else { - var _t1444 int64 + var _t1446 int64 if p.matchLookaheadLiteral("betree_relation", 1) { - _t1444 = 3 + _t1446 = 3 } else { - var _t1445 int64 + var _t1447 int64 if p.matchLookaheadLiteral("algorithm", 1) { - _t1445 = 1 + _t1447 = 1 } else { - _t1445 = -1 + _t1447 = -1 } - _t1444 = _t1445 + _t1446 = _t1447 } - _t1443 = _t1444 + _t1445 = _t1446 } - _t1442 = _t1443 + _t1444 = _t1445 } - _t1441 = _t1442 + _t1443 = _t1444 } - _t1440 = _t1441 + _t1442 = _t1443 } - _t1439 = _t1440 + _t1441 = _t1442 } - _t1438 = _t1439 + _t1440 = _t1441 } else { - _t1438 = -1 - } - prediction755 := _t1438 - var _t1446 *pb.Declaration - if prediction755 == 3 { - _t1447 := p.parse_data() - data759 := _t1447 - _t1448 := &pb.Declaration{} - _t1448.DeclarationType = &pb.Declaration_Data{Data: data759} - _t1446 = _t1448 + _t1440 = -1 + } + prediction756 := _t1440 + var _t1448 *pb.Declaration + if prediction756 == 3 { + _t1449 := p.parse_data() + data760 := _t1449 + _t1450 := &pb.Declaration{} + _t1450.DeclarationType = &pb.Declaration_Data{Data: data760} + _t1448 = _t1450 } else { - var _t1449 *pb.Declaration - if prediction755 == 2 { - _t1450 := p.parse_constraint() - constraint758 := _t1450 - _t1451 := &pb.Declaration{} - _t1451.DeclarationType = &pb.Declaration_Constraint{Constraint: constraint758} - _t1449 = _t1451 + var _t1451 *pb.Declaration + if prediction756 == 2 { + _t1452 := p.parse_constraint() + constraint759 := _t1452 + _t1453 := &pb.Declaration{} + _t1453.DeclarationType = &pb.Declaration_Constraint{Constraint: constraint759} + _t1451 = _t1453 } else { - var _t1452 *pb.Declaration - if prediction755 == 1 { - _t1453 := p.parse_algorithm() - algorithm757 := _t1453 - _t1454 := &pb.Declaration{} - _t1454.DeclarationType = &pb.Declaration_Algorithm{Algorithm: algorithm757} - _t1452 = _t1454 + var _t1454 *pb.Declaration + if prediction756 == 1 { + _t1455 := p.parse_algorithm() + algorithm758 := _t1455 + _t1456 := &pb.Declaration{} + _t1456.DeclarationType = &pb.Declaration_Algorithm{Algorithm: algorithm758} + _t1454 = _t1456 } else { - var _t1455 *pb.Declaration - if prediction755 == 0 { - _t1456 := p.parse_def() - def756 := _t1456 - _t1457 := &pb.Declaration{} - _t1457.DeclarationType = &pb.Declaration_Def{Def: def756} - _t1455 = _t1457 + var _t1457 *pb.Declaration + if prediction756 == 0 { + _t1458 := p.parse_def() + def757 := _t1458 + _t1459 := &pb.Declaration{} + _t1459.DeclarationType = &pb.Declaration_Def{Def: def757} + _t1457 = _t1459 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in declaration", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1452 = _t1455 + _t1454 = _t1457 } - _t1449 = _t1452 + _t1451 = _t1454 } - _t1446 = _t1449 + _t1448 = _t1451 } - result761 := _t1446 - p.recordSpan(int(span_start760), "Declaration") - return result761 + result762 := _t1448 + p.recordSpan(int(span_start761), "Declaration") + return result762 } func (p *Parser) parse_def() *pb.Def { - span_start765 := int64(p.spanStart()) + span_start766 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("def") - _t1458 := p.parse_relation_id() - relation_id762 := _t1458 - _t1459 := p.parse_abstraction() - abstraction763 := _t1459 - var _t1460 []*pb.Attribute + _t1460 := p.parse_relation_id() + relation_id763 := _t1460 + _t1461 := p.parse_abstraction() + abstraction764 := _t1461 + var _t1462 []*pb.Attribute if p.matchLookaheadLiteral("(", 0) { - _t1461 := p.parse_attrs() - _t1460 = _t1461 + _t1463 := p.parse_attrs() + _t1462 = _t1463 } - attrs764 := _t1460 + attrs765 := _t1462 p.consumeLiteral(")") - _t1462 := attrs764 - if attrs764 == nil { - _t1462 = []*pb.Attribute{} + _t1464 := attrs765 + if attrs765 == nil { + _t1464 = []*pb.Attribute{} } - _t1463 := &pb.Def{Name: relation_id762, Body: abstraction763, Attrs: _t1462} - result766 := _t1463 - p.recordSpan(int(span_start765), "Def") - return result766 + _t1465 := &pb.Def{Name: relation_id763, Body: abstraction764, Attrs: _t1464} + result767 := _t1465 + p.recordSpan(int(span_start766), "Def") + return result767 } func (p *Parser) parse_relation_id() *pb.RelationId { - span_start770 := int64(p.spanStart()) - var _t1464 int64 + span_start771 := int64(p.spanStart()) + var _t1466 int64 if p.matchLookaheadLiteral(":", 0) { - _t1464 = 0 + _t1466 = 0 } else { - var _t1465 int64 + var _t1467 int64 if p.matchLookaheadTerminal("UINT128", 0) { - _t1465 = 1 + _t1467 = 1 } else { - _t1465 = -1 + _t1467 = -1 } - _t1464 = _t1465 - } - prediction767 := _t1464 - var _t1466 *pb.RelationId - if prediction767 == 1 { - uint128769 := p.consumeTerminal("UINT128").Value.uint128 - _ = uint128769 - _t1466 = &pb.RelationId{IdLow: uint128769.Low, IdHigh: uint128769.High} + _t1466 = _t1467 + } + prediction768 := _t1466 + var _t1468 *pb.RelationId + if prediction768 == 1 { + uint128770 := p.consumeTerminal("UINT128").Value.uint128 + _ = uint128770 + _t1468 = &pb.RelationId{IdLow: uint128770.Low, IdHigh: uint128770.High} } else { - var _t1467 *pb.RelationId - if prediction767 == 0 { + var _t1469 *pb.RelationId + if prediction768 == 0 { p.consumeLiteral(":") - symbol768 := p.consumeTerminal("SYMBOL").Value.str - _t1467 = p.relationIdFromString(symbol768) + symbol769 := p.consumeTerminal("SYMBOL").Value.str + _t1469 = p.relationIdFromString(symbol769) } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in relation_id", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1466 = _t1467 + _t1468 = _t1469 } - result771 := _t1466 - p.recordSpan(int(span_start770), "RelationId") - return result771 + result772 := _t1468 + p.recordSpan(int(span_start771), "RelationId") + return result772 } func (p *Parser) parse_abstraction() *pb.Abstraction { - span_start774 := int64(p.spanStart()) + span_start775 := int64(p.spanStart()) p.consumeLiteral("(") - _t1468 := p.parse_bindings() - bindings772 := _t1468 - _t1469 := p.parse_formula() - formula773 := _t1469 + _t1470 := p.parse_bindings() + bindings773 := _t1470 + _t1471 := p.parse_formula() + formula774 := _t1471 p.consumeLiteral(")") - _t1470 := &pb.Abstraction{Vars: listConcat(bindings772[0].([]*pb.Binding), bindings772[1].([]*pb.Binding)), Value: formula773} - result775 := _t1470 - p.recordSpan(int(span_start774), "Abstraction") - return result775 + _t1472 := &pb.Abstraction{Vars: listConcat(bindings773[0].([]*pb.Binding), bindings773[1].([]*pb.Binding)), Value: formula774} + result776 := _t1472 + p.recordSpan(int(span_start775), "Abstraction") + return result776 } func (p *Parser) parse_bindings() []interface{} { p.consumeLiteral("[") - xs776 := []*pb.Binding{} - cond777 := p.matchLookaheadTerminal("SYMBOL", 0) - for cond777 { - _t1471 := p.parse_binding() - item778 := _t1471 - xs776 = append(xs776, item778) - cond777 = p.matchLookaheadTerminal("SYMBOL", 0) - } - bindings779 := xs776 - var _t1472 []*pb.Binding + xs777 := []*pb.Binding{} + cond778 := p.matchLookaheadTerminal("SYMBOL", 0) + for cond778 { + _t1473 := p.parse_binding() + item779 := _t1473 + xs777 = append(xs777, item779) + cond778 = p.matchLookaheadTerminal("SYMBOL", 0) + } + bindings780 := xs777 + var _t1474 []*pb.Binding if p.matchLookaheadLiteral("|", 0) { - _t1473 := p.parse_value_bindings() - _t1472 = _t1473 + _t1475 := p.parse_value_bindings() + _t1474 = _t1475 } - value_bindings780 := _t1472 + value_bindings781 := _t1474 p.consumeLiteral("]") - _t1474 := value_bindings780 - if value_bindings780 == nil { - _t1474 = []*pb.Binding{} + _t1476 := value_bindings781 + if value_bindings781 == nil { + _t1476 = []*pb.Binding{} } - return []interface{}{bindings779, _t1474} + return []interface{}{bindings780, _t1476} } func (p *Parser) parse_binding() *pb.Binding { - span_start783 := int64(p.spanStart()) - symbol781 := p.consumeTerminal("SYMBOL").Value.str + span_start784 := int64(p.spanStart()) + symbol782 := p.consumeTerminal("SYMBOL").Value.str p.consumeLiteral("::") - _t1475 := p.parse_type() - type782 := _t1475 - _t1476 := &pb.Var{Name: symbol781} - _t1477 := &pb.Binding{Var: _t1476, Type: type782} - result784 := _t1477 - p.recordSpan(int(span_start783), "Binding") - return result784 + _t1477 := p.parse_type() + type783 := _t1477 + _t1478 := &pb.Var{Name: symbol782} + _t1479 := &pb.Binding{Var: _t1478, Type: type783} + result785 := _t1479 + p.recordSpan(int(span_start784), "Binding") + return result785 } func (p *Parser) parse_type() *pb.Type { - span_start800 := int64(p.spanStart()) - var _t1478 int64 + span_start801 := int64(p.spanStart()) + var _t1480 int64 if p.matchLookaheadLiteral("UNKNOWN", 0) { - _t1478 = 0 + _t1480 = 0 } else { - var _t1479 int64 + var _t1481 int64 if p.matchLookaheadLiteral("UINT32", 0) { - _t1479 = 13 + _t1481 = 13 } else { - var _t1480 int64 + var _t1482 int64 if p.matchLookaheadLiteral("UINT128", 0) { - _t1480 = 4 + _t1482 = 4 } else { - var _t1481 int64 + var _t1483 int64 if p.matchLookaheadLiteral("STRING", 0) { - _t1481 = 1 + _t1483 = 1 } else { - var _t1482 int64 + var _t1484 int64 if p.matchLookaheadLiteral("MISSING", 0) { - _t1482 = 8 + _t1484 = 8 } else { - var _t1483 int64 + var _t1485 int64 if p.matchLookaheadLiteral("INT32", 0) { - _t1483 = 11 + _t1485 = 11 } else { - var _t1484 int64 + var _t1486 int64 if p.matchLookaheadLiteral("INT128", 0) { - _t1484 = 5 + _t1486 = 5 } else { - var _t1485 int64 + var _t1487 int64 if p.matchLookaheadLiteral("INT", 0) { - _t1485 = 2 + _t1487 = 2 } else { - var _t1486 int64 + var _t1488 int64 if p.matchLookaheadLiteral("FLOAT32", 0) { - _t1486 = 12 + _t1488 = 12 } else { - var _t1487 int64 + var _t1489 int64 if p.matchLookaheadLiteral("FLOAT", 0) { - _t1487 = 3 + _t1489 = 3 } else { - var _t1488 int64 + var _t1490 int64 if p.matchLookaheadLiteral("DATETIME", 0) { - _t1488 = 7 + _t1490 = 7 } else { - var _t1489 int64 + var _t1491 int64 if p.matchLookaheadLiteral("DATE", 0) { - _t1489 = 6 + _t1491 = 6 } else { - var _t1490 int64 + var _t1492 int64 if p.matchLookaheadLiteral("BOOLEAN", 0) { - _t1490 = 10 + _t1492 = 10 } else { - var _t1491 int64 + var _t1493 int64 if p.matchLookaheadLiteral("(", 0) { - _t1491 = 9 + _t1493 = 9 } else { - _t1491 = -1 + _t1493 = -1 } - _t1490 = _t1491 + _t1492 = _t1493 } - _t1489 = _t1490 + _t1491 = _t1492 } - _t1488 = _t1489 + _t1490 = _t1491 } - _t1487 = _t1488 + _t1489 = _t1490 } - _t1486 = _t1487 + _t1488 = _t1489 } - _t1485 = _t1486 + _t1487 = _t1488 } - _t1484 = _t1485 + _t1486 = _t1487 } - _t1483 = _t1484 + _t1485 = _t1486 } - _t1482 = _t1483 + _t1484 = _t1485 } - _t1481 = _t1482 + _t1483 = _t1484 } - _t1480 = _t1481 + _t1482 = _t1483 } - _t1479 = _t1480 + _t1481 = _t1482 } - _t1478 = _t1479 - } - prediction785 := _t1478 - var _t1492 *pb.Type - if prediction785 == 13 { - _t1493 := p.parse_uint32_type() - uint32_type799 := _t1493 - _t1494 := &pb.Type{} - _t1494.Type = &pb.Type_Uint32Type{Uint32Type: uint32_type799} - _t1492 = _t1494 + _t1480 = _t1481 + } + prediction786 := _t1480 + var _t1494 *pb.Type + if prediction786 == 13 { + _t1495 := p.parse_uint32_type() + uint32_type800 := _t1495 + _t1496 := &pb.Type{} + _t1496.Type = &pb.Type_Uint32Type{Uint32Type: uint32_type800} + _t1494 = _t1496 } else { - var _t1495 *pb.Type - if prediction785 == 12 { - _t1496 := p.parse_float32_type() - float32_type798 := _t1496 - _t1497 := &pb.Type{} - _t1497.Type = &pb.Type_Float32Type{Float32Type: float32_type798} - _t1495 = _t1497 + var _t1497 *pb.Type + if prediction786 == 12 { + _t1498 := p.parse_float32_type() + float32_type799 := _t1498 + _t1499 := &pb.Type{} + _t1499.Type = &pb.Type_Float32Type{Float32Type: float32_type799} + _t1497 = _t1499 } else { - var _t1498 *pb.Type - if prediction785 == 11 { - _t1499 := p.parse_int32_type() - int32_type797 := _t1499 - _t1500 := &pb.Type{} - _t1500.Type = &pb.Type_Int32Type{Int32Type: int32_type797} - _t1498 = _t1500 + var _t1500 *pb.Type + if prediction786 == 11 { + _t1501 := p.parse_int32_type() + int32_type798 := _t1501 + _t1502 := &pb.Type{} + _t1502.Type = &pb.Type_Int32Type{Int32Type: int32_type798} + _t1500 = _t1502 } else { - var _t1501 *pb.Type - if prediction785 == 10 { - _t1502 := p.parse_boolean_type() - boolean_type796 := _t1502 - _t1503 := &pb.Type{} - _t1503.Type = &pb.Type_BooleanType{BooleanType: boolean_type796} - _t1501 = _t1503 + var _t1503 *pb.Type + if prediction786 == 10 { + _t1504 := p.parse_boolean_type() + boolean_type797 := _t1504 + _t1505 := &pb.Type{} + _t1505.Type = &pb.Type_BooleanType{BooleanType: boolean_type797} + _t1503 = _t1505 } else { - var _t1504 *pb.Type - if prediction785 == 9 { - _t1505 := p.parse_decimal_type() - decimal_type795 := _t1505 - _t1506 := &pb.Type{} - _t1506.Type = &pb.Type_DecimalType{DecimalType: decimal_type795} - _t1504 = _t1506 + var _t1506 *pb.Type + if prediction786 == 9 { + _t1507 := p.parse_decimal_type() + decimal_type796 := _t1507 + _t1508 := &pb.Type{} + _t1508.Type = &pb.Type_DecimalType{DecimalType: decimal_type796} + _t1506 = _t1508 } else { - var _t1507 *pb.Type - if prediction785 == 8 { - _t1508 := p.parse_missing_type() - missing_type794 := _t1508 - _t1509 := &pb.Type{} - _t1509.Type = &pb.Type_MissingType{MissingType: missing_type794} - _t1507 = _t1509 + var _t1509 *pb.Type + if prediction786 == 8 { + _t1510 := p.parse_missing_type() + missing_type795 := _t1510 + _t1511 := &pb.Type{} + _t1511.Type = &pb.Type_MissingType{MissingType: missing_type795} + _t1509 = _t1511 } else { - var _t1510 *pb.Type - if prediction785 == 7 { - _t1511 := p.parse_datetime_type() - datetime_type793 := _t1511 - _t1512 := &pb.Type{} - _t1512.Type = &pb.Type_DatetimeType{DatetimeType: datetime_type793} - _t1510 = _t1512 + var _t1512 *pb.Type + if prediction786 == 7 { + _t1513 := p.parse_datetime_type() + datetime_type794 := _t1513 + _t1514 := &pb.Type{} + _t1514.Type = &pb.Type_DatetimeType{DatetimeType: datetime_type794} + _t1512 = _t1514 } else { - var _t1513 *pb.Type - if prediction785 == 6 { - _t1514 := p.parse_date_type() - date_type792 := _t1514 - _t1515 := &pb.Type{} - _t1515.Type = &pb.Type_DateType{DateType: date_type792} - _t1513 = _t1515 + var _t1515 *pb.Type + if prediction786 == 6 { + _t1516 := p.parse_date_type() + date_type793 := _t1516 + _t1517 := &pb.Type{} + _t1517.Type = &pb.Type_DateType{DateType: date_type793} + _t1515 = _t1517 } else { - var _t1516 *pb.Type - if prediction785 == 5 { - _t1517 := p.parse_int128_type() - int128_type791 := _t1517 - _t1518 := &pb.Type{} - _t1518.Type = &pb.Type_Int128Type{Int128Type: int128_type791} - _t1516 = _t1518 + var _t1518 *pb.Type + if prediction786 == 5 { + _t1519 := p.parse_int128_type() + int128_type792 := _t1519 + _t1520 := &pb.Type{} + _t1520.Type = &pb.Type_Int128Type{Int128Type: int128_type792} + _t1518 = _t1520 } else { - var _t1519 *pb.Type - if prediction785 == 4 { - _t1520 := p.parse_uint128_type() - uint128_type790 := _t1520 - _t1521 := &pb.Type{} - _t1521.Type = &pb.Type_Uint128Type{Uint128Type: uint128_type790} - _t1519 = _t1521 + var _t1521 *pb.Type + if prediction786 == 4 { + _t1522 := p.parse_uint128_type() + uint128_type791 := _t1522 + _t1523 := &pb.Type{} + _t1523.Type = &pb.Type_Uint128Type{Uint128Type: uint128_type791} + _t1521 = _t1523 } else { - var _t1522 *pb.Type - if prediction785 == 3 { - _t1523 := p.parse_float_type() - float_type789 := _t1523 - _t1524 := &pb.Type{} - _t1524.Type = &pb.Type_FloatType{FloatType: float_type789} - _t1522 = _t1524 + var _t1524 *pb.Type + if prediction786 == 3 { + _t1525 := p.parse_float_type() + float_type790 := _t1525 + _t1526 := &pb.Type{} + _t1526.Type = &pb.Type_FloatType{FloatType: float_type790} + _t1524 = _t1526 } else { - var _t1525 *pb.Type - if prediction785 == 2 { - _t1526 := p.parse_int_type() - int_type788 := _t1526 - _t1527 := &pb.Type{} - _t1527.Type = &pb.Type_IntType{IntType: int_type788} - _t1525 = _t1527 + var _t1527 *pb.Type + if prediction786 == 2 { + _t1528 := p.parse_int_type() + int_type789 := _t1528 + _t1529 := &pb.Type{} + _t1529.Type = &pb.Type_IntType{IntType: int_type789} + _t1527 = _t1529 } else { - var _t1528 *pb.Type - if prediction785 == 1 { - _t1529 := p.parse_string_type() - string_type787 := _t1529 - _t1530 := &pb.Type{} - _t1530.Type = &pb.Type_StringType{StringType: string_type787} - _t1528 = _t1530 + var _t1530 *pb.Type + if prediction786 == 1 { + _t1531 := p.parse_string_type() + string_type788 := _t1531 + _t1532 := &pb.Type{} + _t1532.Type = &pb.Type_StringType{StringType: string_type788} + _t1530 = _t1532 } else { - var _t1531 *pb.Type - if prediction785 == 0 { - _t1532 := p.parse_unspecified_type() - unspecified_type786 := _t1532 - _t1533 := &pb.Type{} - _t1533.Type = &pb.Type_UnspecifiedType{UnspecifiedType: unspecified_type786} - _t1531 = _t1533 + var _t1533 *pb.Type + if prediction786 == 0 { + _t1534 := p.parse_unspecified_type() + unspecified_type787 := _t1534 + _t1535 := &pb.Type{} + _t1535.Type = &pb.Type_UnspecifiedType{UnspecifiedType: unspecified_type787} + _t1533 = _t1535 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in type", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1528 = _t1531 + _t1530 = _t1533 } - _t1525 = _t1528 + _t1527 = _t1530 } - _t1522 = _t1525 + _t1524 = _t1527 } - _t1519 = _t1522 + _t1521 = _t1524 } - _t1516 = _t1519 + _t1518 = _t1521 } - _t1513 = _t1516 + _t1515 = _t1518 } - _t1510 = _t1513 + _t1512 = _t1515 } - _t1507 = _t1510 + _t1509 = _t1512 } - _t1504 = _t1507 + _t1506 = _t1509 } - _t1501 = _t1504 + _t1503 = _t1506 } - _t1498 = _t1501 + _t1500 = _t1503 } - _t1495 = _t1498 + _t1497 = _t1500 } - _t1492 = _t1495 + _t1494 = _t1497 } - result801 := _t1492 - p.recordSpan(int(span_start800), "Type") - return result801 + result802 := _t1494 + p.recordSpan(int(span_start801), "Type") + return result802 } func (p *Parser) parse_unspecified_type() *pb.UnspecifiedType { - span_start802 := int64(p.spanStart()) + span_start803 := int64(p.spanStart()) p.consumeLiteral("UNKNOWN") - _t1534 := &pb.UnspecifiedType{} - result803 := _t1534 - p.recordSpan(int(span_start802), "UnspecifiedType") - return result803 + _t1536 := &pb.UnspecifiedType{} + result804 := _t1536 + p.recordSpan(int(span_start803), "UnspecifiedType") + return result804 } func (p *Parser) parse_string_type() *pb.StringType { - span_start804 := int64(p.spanStart()) + span_start805 := int64(p.spanStart()) p.consumeLiteral("STRING") - _t1535 := &pb.StringType{} - result805 := _t1535 - p.recordSpan(int(span_start804), "StringType") - return result805 + _t1537 := &pb.StringType{} + result806 := _t1537 + p.recordSpan(int(span_start805), "StringType") + return result806 } func (p *Parser) parse_int_type() *pb.IntType { - span_start806 := int64(p.spanStart()) + span_start807 := int64(p.spanStart()) p.consumeLiteral("INT") - _t1536 := &pb.IntType{} - result807 := _t1536 - p.recordSpan(int(span_start806), "IntType") - return result807 + _t1538 := &pb.IntType{} + result808 := _t1538 + p.recordSpan(int(span_start807), "IntType") + return result808 } func (p *Parser) parse_float_type() *pb.FloatType { - span_start808 := int64(p.spanStart()) + span_start809 := int64(p.spanStart()) p.consumeLiteral("FLOAT") - _t1537 := &pb.FloatType{} - result809 := _t1537 - p.recordSpan(int(span_start808), "FloatType") - return result809 + _t1539 := &pb.FloatType{} + result810 := _t1539 + p.recordSpan(int(span_start809), "FloatType") + return result810 } func (p *Parser) parse_uint128_type() *pb.UInt128Type { - span_start810 := int64(p.spanStart()) + span_start811 := int64(p.spanStart()) p.consumeLiteral("UINT128") - _t1538 := &pb.UInt128Type{} - result811 := _t1538 - p.recordSpan(int(span_start810), "UInt128Type") - return result811 + _t1540 := &pb.UInt128Type{} + result812 := _t1540 + p.recordSpan(int(span_start811), "UInt128Type") + return result812 } func (p *Parser) parse_int128_type() *pb.Int128Type { - span_start812 := int64(p.spanStart()) + span_start813 := int64(p.spanStart()) p.consumeLiteral("INT128") - _t1539 := &pb.Int128Type{} - result813 := _t1539 - p.recordSpan(int(span_start812), "Int128Type") - return result813 + _t1541 := &pb.Int128Type{} + result814 := _t1541 + p.recordSpan(int(span_start813), "Int128Type") + return result814 } func (p *Parser) parse_date_type() *pb.DateType { - span_start814 := int64(p.spanStart()) + span_start815 := int64(p.spanStart()) p.consumeLiteral("DATE") - _t1540 := &pb.DateType{} - result815 := _t1540 - p.recordSpan(int(span_start814), "DateType") - return result815 + _t1542 := &pb.DateType{} + result816 := _t1542 + p.recordSpan(int(span_start815), "DateType") + return result816 } func (p *Parser) parse_datetime_type() *pb.DateTimeType { - span_start816 := int64(p.spanStart()) + span_start817 := int64(p.spanStart()) p.consumeLiteral("DATETIME") - _t1541 := &pb.DateTimeType{} - result817 := _t1541 - p.recordSpan(int(span_start816), "DateTimeType") - return result817 + _t1543 := &pb.DateTimeType{} + result818 := _t1543 + p.recordSpan(int(span_start817), "DateTimeType") + return result818 } func (p *Parser) parse_missing_type() *pb.MissingType { - span_start818 := int64(p.spanStart()) + span_start819 := int64(p.spanStart()) p.consumeLiteral("MISSING") - _t1542 := &pb.MissingType{} - result819 := _t1542 - p.recordSpan(int(span_start818), "MissingType") - return result819 + _t1544 := &pb.MissingType{} + result820 := _t1544 + p.recordSpan(int(span_start819), "MissingType") + return result820 } func (p *Parser) parse_decimal_type() *pb.DecimalType { - span_start822 := int64(p.spanStart()) + span_start823 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("DECIMAL") - int820 := p.consumeTerminal("INT").Value.i64 - int_3821 := p.consumeTerminal("INT").Value.i64 + int821 := p.consumeTerminal("INT").Value.i64 + int_3822 := p.consumeTerminal("INT").Value.i64 p.consumeLiteral(")") - _t1543 := &pb.DecimalType{Precision: int32(int820), Scale: int32(int_3821)} - result823 := _t1543 - p.recordSpan(int(span_start822), "DecimalType") - return result823 + _t1545 := &pb.DecimalType{Precision: int32(int821), Scale: int32(int_3822)} + result824 := _t1545 + p.recordSpan(int(span_start823), "DecimalType") + return result824 } func (p *Parser) parse_boolean_type() *pb.BooleanType { - span_start824 := int64(p.spanStart()) + span_start825 := int64(p.spanStart()) p.consumeLiteral("BOOLEAN") - _t1544 := &pb.BooleanType{} - result825 := _t1544 - p.recordSpan(int(span_start824), "BooleanType") - return result825 + _t1546 := &pb.BooleanType{} + result826 := _t1546 + p.recordSpan(int(span_start825), "BooleanType") + return result826 } func (p *Parser) parse_int32_type() *pb.Int32Type { - span_start826 := int64(p.spanStart()) + span_start827 := int64(p.spanStart()) p.consumeLiteral("INT32") - _t1545 := &pb.Int32Type{} - result827 := _t1545 - p.recordSpan(int(span_start826), "Int32Type") - return result827 + _t1547 := &pb.Int32Type{} + result828 := _t1547 + p.recordSpan(int(span_start827), "Int32Type") + return result828 } func (p *Parser) parse_float32_type() *pb.Float32Type { - span_start828 := int64(p.spanStart()) + span_start829 := int64(p.spanStart()) p.consumeLiteral("FLOAT32") - _t1546 := &pb.Float32Type{} - result829 := _t1546 - p.recordSpan(int(span_start828), "Float32Type") - return result829 + _t1548 := &pb.Float32Type{} + result830 := _t1548 + p.recordSpan(int(span_start829), "Float32Type") + return result830 } func (p *Parser) parse_uint32_type() *pb.UInt32Type { - span_start830 := int64(p.spanStart()) + span_start831 := int64(p.spanStart()) p.consumeLiteral("UINT32") - _t1547 := &pb.UInt32Type{} - result831 := _t1547 - p.recordSpan(int(span_start830), "UInt32Type") - return result831 + _t1549 := &pb.UInt32Type{} + result832 := _t1549 + p.recordSpan(int(span_start831), "UInt32Type") + return result832 } func (p *Parser) parse_value_bindings() []*pb.Binding { p.consumeLiteral("|") - xs832 := []*pb.Binding{} - cond833 := p.matchLookaheadTerminal("SYMBOL", 0) - for cond833 { - _t1548 := p.parse_binding() - item834 := _t1548 - xs832 = append(xs832, item834) - cond833 = p.matchLookaheadTerminal("SYMBOL", 0) + xs833 := []*pb.Binding{} + cond834 := p.matchLookaheadTerminal("SYMBOL", 0) + for cond834 { + _t1550 := p.parse_binding() + item835 := _t1550 + xs833 = append(xs833, item835) + cond834 = p.matchLookaheadTerminal("SYMBOL", 0) } - bindings835 := xs832 - return bindings835 + bindings836 := xs833 + return bindings836 } func (p *Parser) parse_formula() *pb.Formula { - span_start850 := int64(p.spanStart()) - var _t1549 int64 + span_start851 := int64(p.spanStart()) + var _t1551 int64 if p.matchLookaheadLiteral("(", 0) { - var _t1550 int64 + var _t1552 int64 if p.matchLookaheadLiteral("true", 1) { - _t1550 = 0 + _t1552 = 0 } else { - var _t1551 int64 + var _t1553 int64 if p.matchLookaheadLiteral("relatom", 1) { - _t1551 = 11 + _t1553 = 11 } else { - var _t1552 int64 + var _t1554 int64 if p.matchLookaheadLiteral("reduce", 1) { - _t1552 = 3 + _t1554 = 3 } else { - var _t1553 int64 + var _t1555 int64 if p.matchLookaheadLiteral("primitive", 1) { - _t1553 = 10 + _t1555 = 10 } else { - var _t1554 int64 + var _t1556 int64 if p.matchLookaheadLiteral("pragma", 1) { - _t1554 = 9 + _t1556 = 9 } else { - var _t1555 int64 + var _t1557 int64 if p.matchLookaheadLiteral("or", 1) { - _t1555 = 5 + _t1557 = 5 } else { - var _t1556 int64 + var _t1558 int64 if p.matchLookaheadLiteral("not", 1) { - _t1556 = 6 + _t1558 = 6 } else { - var _t1557 int64 + var _t1559 int64 if p.matchLookaheadLiteral("ffi", 1) { - _t1557 = 7 + _t1559 = 7 } else { - var _t1558 int64 + var _t1560 int64 if p.matchLookaheadLiteral("false", 1) { - _t1558 = 1 + _t1560 = 1 } else { - var _t1559 int64 + var _t1561 int64 if p.matchLookaheadLiteral("exists", 1) { - _t1559 = 2 + _t1561 = 2 } else { - var _t1560 int64 + var _t1562 int64 if p.matchLookaheadLiteral("cast", 1) { - _t1560 = 12 + _t1562 = 12 } else { - var _t1561 int64 + var _t1563 int64 if p.matchLookaheadLiteral("atom", 1) { - _t1561 = 8 + _t1563 = 8 } else { - var _t1562 int64 + var _t1564 int64 if p.matchLookaheadLiteral("and", 1) { - _t1562 = 4 + _t1564 = 4 } else { - var _t1563 int64 + var _t1565 int64 if p.matchLookaheadLiteral(">=", 1) { - _t1563 = 10 + _t1565 = 10 } else { - var _t1564 int64 + var _t1566 int64 if p.matchLookaheadLiteral(">", 1) { - _t1564 = 10 + _t1566 = 10 } else { - var _t1565 int64 + var _t1567 int64 if p.matchLookaheadLiteral("=", 1) { - _t1565 = 10 + _t1567 = 10 } else { - var _t1566 int64 + var _t1568 int64 if p.matchLookaheadLiteral("<=", 1) { - _t1566 = 10 + _t1568 = 10 } else { - var _t1567 int64 + var _t1569 int64 if p.matchLookaheadLiteral("<", 1) { - _t1567 = 10 + _t1569 = 10 } else { - var _t1568 int64 + var _t1570 int64 if p.matchLookaheadLiteral("/", 1) { - _t1568 = 10 + _t1570 = 10 } else { - var _t1569 int64 + var _t1571 int64 if p.matchLookaheadLiteral("-", 1) { - _t1569 = 10 + _t1571 = 10 } else { - var _t1570 int64 + var _t1572 int64 if p.matchLookaheadLiteral("+", 1) { - _t1570 = 10 + _t1572 = 10 } else { - var _t1571 int64 + var _t1573 int64 if p.matchLookaheadLiteral("*", 1) { - _t1571 = 10 + _t1573 = 10 } else { - _t1571 = -1 + _t1573 = -1 } - _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 } - _t1556 = _t1557 + _t1558 = _t1559 } - _t1555 = _t1556 + _t1557 = _t1558 } - _t1554 = _t1555 + _t1556 = _t1557 } - _t1553 = _t1554 + _t1555 = _t1556 } - _t1552 = _t1553 + _t1554 = _t1555 } - _t1551 = _t1552 + _t1553 = _t1554 } - _t1550 = _t1551 + _t1552 = _t1553 } - _t1549 = _t1550 + _t1551 = _t1552 } else { - _t1549 = -1 - } - prediction836 := _t1549 - var _t1572 *pb.Formula - if prediction836 == 12 { - _t1573 := p.parse_cast() - cast849 := _t1573 - _t1574 := &pb.Formula{} - _t1574.FormulaType = &pb.Formula_Cast{Cast: cast849} - _t1572 = _t1574 + _t1551 = -1 + } + prediction837 := _t1551 + var _t1574 *pb.Formula + if prediction837 == 12 { + _t1575 := p.parse_cast() + cast850 := _t1575 + _t1576 := &pb.Formula{} + _t1576.FormulaType = &pb.Formula_Cast{Cast: cast850} + _t1574 = _t1576 } else { - var _t1575 *pb.Formula - if prediction836 == 11 { - _t1576 := p.parse_rel_atom() - rel_atom848 := _t1576 - _t1577 := &pb.Formula{} - _t1577.FormulaType = &pb.Formula_RelAtom{RelAtom: rel_atom848} - _t1575 = _t1577 + var _t1577 *pb.Formula + if prediction837 == 11 { + _t1578 := p.parse_rel_atom() + rel_atom849 := _t1578 + _t1579 := &pb.Formula{} + _t1579.FormulaType = &pb.Formula_RelAtom{RelAtom: rel_atom849} + _t1577 = _t1579 } else { - var _t1578 *pb.Formula - if prediction836 == 10 { - _t1579 := p.parse_primitive() - primitive847 := _t1579 - _t1580 := &pb.Formula{} - _t1580.FormulaType = &pb.Formula_Primitive{Primitive: primitive847} - _t1578 = _t1580 + var _t1580 *pb.Formula + if prediction837 == 10 { + _t1581 := p.parse_primitive() + primitive848 := _t1581 + _t1582 := &pb.Formula{} + _t1582.FormulaType = &pb.Formula_Primitive{Primitive: primitive848} + _t1580 = _t1582 } else { - var _t1581 *pb.Formula - if prediction836 == 9 { - _t1582 := p.parse_pragma() - pragma846 := _t1582 - _t1583 := &pb.Formula{} - _t1583.FormulaType = &pb.Formula_Pragma{Pragma: pragma846} - _t1581 = _t1583 + var _t1583 *pb.Formula + if prediction837 == 9 { + _t1584 := p.parse_pragma() + pragma847 := _t1584 + _t1585 := &pb.Formula{} + _t1585.FormulaType = &pb.Formula_Pragma{Pragma: pragma847} + _t1583 = _t1585 } else { - var _t1584 *pb.Formula - if prediction836 == 8 { - _t1585 := p.parse_atom() - atom845 := _t1585 - _t1586 := &pb.Formula{} - _t1586.FormulaType = &pb.Formula_Atom{Atom: atom845} - _t1584 = _t1586 + var _t1586 *pb.Formula + if prediction837 == 8 { + _t1587 := p.parse_atom() + atom846 := _t1587 + _t1588 := &pb.Formula{} + _t1588.FormulaType = &pb.Formula_Atom{Atom: atom846} + _t1586 = _t1588 } else { - var _t1587 *pb.Formula - if prediction836 == 7 { - _t1588 := p.parse_ffi() - ffi844 := _t1588 - _t1589 := &pb.Formula{} - _t1589.FormulaType = &pb.Formula_Ffi{Ffi: ffi844} - _t1587 = _t1589 + var _t1589 *pb.Formula + if prediction837 == 7 { + _t1590 := p.parse_ffi() + ffi845 := _t1590 + _t1591 := &pb.Formula{} + _t1591.FormulaType = &pb.Formula_Ffi{Ffi: ffi845} + _t1589 = _t1591 } else { - var _t1590 *pb.Formula - if prediction836 == 6 { - _t1591 := p.parse_not() - not843 := _t1591 - _t1592 := &pb.Formula{} - _t1592.FormulaType = &pb.Formula_Not{Not: not843} - _t1590 = _t1592 + var _t1592 *pb.Formula + if prediction837 == 6 { + _t1593 := p.parse_not() + not844 := _t1593 + _t1594 := &pb.Formula{} + _t1594.FormulaType = &pb.Formula_Not{Not: not844} + _t1592 = _t1594 } else { - var _t1593 *pb.Formula - if prediction836 == 5 { - _t1594 := p.parse_disjunction() - disjunction842 := _t1594 - _t1595 := &pb.Formula{} - _t1595.FormulaType = &pb.Formula_Disjunction{Disjunction: disjunction842} - _t1593 = _t1595 + var _t1595 *pb.Formula + if prediction837 == 5 { + _t1596 := p.parse_disjunction() + disjunction843 := _t1596 + _t1597 := &pb.Formula{} + _t1597.FormulaType = &pb.Formula_Disjunction{Disjunction: disjunction843} + _t1595 = _t1597 } else { - var _t1596 *pb.Formula - if prediction836 == 4 { - _t1597 := p.parse_conjunction() - conjunction841 := _t1597 - _t1598 := &pb.Formula{} - _t1598.FormulaType = &pb.Formula_Conjunction{Conjunction: conjunction841} - _t1596 = _t1598 + var _t1598 *pb.Formula + if prediction837 == 4 { + _t1599 := p.parse_conjunction() + conjunction842 := _t1599 + _t1600 := &pb.Formula{} + _t1600.FormulaType = &pb.Formula_Conjunction{Conjunction: conjunction842} + _t1598 = _t1600 } else { - var _t1599 *pb.Formula - if prediction836 == 3 { - _t1600 := p.parse_reduce() - reduce840 := _t1600 - _t1601 := &pb.Formula{} - _t1601.FormulaType = &pb.Formula_Reduce{Reduce: reduce840} - _t1599 = _t1601 + var _t1601 *pb.Formula + if prediction837 == 3 { + _t1602 := p.parse_reduce() + reduce841 := _t1602 + _t1603 := &pb.Formula{} + _t1603.FormulaType = &pb.Formula_Reduce{Reduce: reduce841} + _t1601 = _t1603 } else { - var _t1602 *pb.Formula - if prediction836 == 2 { - _t1603 := p.parse_exists() - exists839 := _t1603 - _t1604 := &pb.Formula{} - _t1604.FormulaType = &pb.Formula_Exists{Exists: exists839} - _t1602 = _t1604 + var _t1604 *pb.Formula + if prediction837 == 2 { + _t1605 := p.parse_exists() + exists840 := _t1605 + _t1606 := &pb.Formula{} + _t1606.FormulaType = &pb.Formula_Exists{Exists: exists840} + _t1604 = _t1606 } else { - var _t1605 *pb.Formula - if prediction836 == 1 { - _t1606 := p.parse_false() - false838 := _t1606 - _t1607 := &pb.Formula{} - _t1607.FormulaType = &pb.Formula_Disjunction{Disjunction: false838} - _t1605 = _t1607 + var _t1607 *pb.Formula + if prediction837 == 1 { + _t1608 := p.parse_false() + false839 := _t1608 + _t1609 := &pb.Formula{} + _t1609.FormulaType = &pb.Formula_Disjunction{Disjunction: false839} + _t1607 = _t1609 } else { - var _t1608 *pb.Formula - if prediction836 == 0 { - _t1609 := p.parse_true() - true837 := _t1609 - _t1610 := &pb.Formula{} - _t1610.FormulaType = &pb.Formula_Conjunction{Conjunction: true837} - _t1608 = _t1610 + var _t1610 *pb.Formula + if prediction837 == 0 { + _t1611 := p.parse_true() + true838 := _t1611 + _t1612 := &pb.Formula{} + _t1612.FormulaType = &pb.Formula_Conjunction{Conjunction: true838} + _t1610 = _t1612 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in formula", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1605 = _t1608 + _t1607 = _t1610 } - _t1602 = _t1605 + _t1604 = _t1607 } - _t1599 = _t1602 + _t1601 = _t1604 } - _t1596 = _t1599 + _t1598 = _t1601 } - _t1593 = _t1596 + _t1595 = _t1598 } - _t1590 = _t1593 + _t1592 = _t1595 } - _t1587 = _t1590 + _t1589 = _t1592 } - _t1584 = _t1587 + _t1586 = _t1589 } - _t1581 = _t1584 + _t1583 = _t1586 } - _t1578 = _t1581 + _t1580 = _t1583 } - _t1575 = _t1578 + _t1577 = _t1580 } - _t1572 = _t1575 + _t1574 = _t1577 } - result851 := _t1572 - p.recordSpan(int(span_start850), "Formula") - return result851 + result852 := _t1574 + p.recordSpan(int(span_start851), "Formula") + return result852 } func (p *Parser) parse_true() *pb.Conjunction { - span_start852 := int64(p.spanStart()) + span_start853 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("true") p.consumeLiteral(")") - _t1611 := &pb.Conjunction{Args: []*pb.Formula{}} - result853 := _t1611 - p.recordSpan(int(span_start852), "Conjunction") - return result853 + _t1613 := &pb.Conjunction{Args: []*pb.Formula{}} + result854 := _t1613 + p.recordSpan(int(span_start853), "Conjunction") + return result854 } func (p *Parser) parse_false() *pb.Disjunction { - span_start854 := int64(p.spanStart()) + span_start855 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("false") p.consumeLiteral(")") - _t1612 := &pb.Disjunction{Args: []*pb.Formula{}} - result855 := _t1612 - p.recordSpan(int(span_start854), "Disjunction") - return result855 + _t1614 := &pb.Disjunction{Args: []*pb.Formula{}} + result856 := _t1614 + p.recordSpan(int(span_start855), "Disjunction") + return result856 } func (p *Parser) parse_exists() *pb.Exists { - span_start858 := int64(p.spanStart()) + span_start859 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("exists") - _t1613 := p.parse_bindings() - bindings856 := _t1613 - _t1614 := p.parse_formula() - formula857 := _t1614 + _t1615 := p.parse_bindings() + bindings857 := _t1615 + _t1616 := p.parse_formula() + formula858 := _t1616 p.consumeLiteral(")") - _t1615 := &pb.Abstraction{Vars: listConcat(bindings856[0].([]*pb.Binding), bindings856[1].([]*pb.Binding)), Value: formula857} - _t1616 := &pb.Exists{Body: _t1615} - result859 := _t1616 - p.recordSpan(int(span_start858), "Exists") - return result859 + _t1617 := &pb.Abstraction{Vars: listConcat(bindings857[0].([]*pb.Binding), bindings857[1].([]*pb.Binding)), Value: formula858} + _t1618 := &pb.Exists{Body: _t1617} + result860 := _t1618 + p.recordSpan(int(span_start859), "Exists") + return result860 } func (p *Parser) parse_reduce() *pb.Reduce { - span_start863 := int64(p.spanStart()) + span_start864 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("reduce") - _t1617 := p.parse_abstraction() - abstraction860 := _t1617 - _t1618 := p.parse_abstraction() - abstraction_3861 := _t1618 - _t1619 := p.parse_terms() - terms862 := _t1619 + _t1619 := p.parse_abstraction() + abstraction861 := _t1619 + _t1620 := p.parse_abstraction() + abstraction_3862 := _t1620 + _t1621 := p.parse_terms() + terms863 := _t1621 p.consumeLiteral(")") - _t1620 := &pb.Reduce{Op: abstraction860, Body: abstraction_3861, Terms: terms862} - result864 := _t1620 - p.recordSpan(int(span_start863), "Reduce") - return result864 + _t1622 := &pb.Reduce{Op: abstraction861, Body: abstraction_3862, Terms: terms863} + result865 := _t1622 + p.recordSpan(int(span_start864), "Reduce") + return result865 } func (p *Parser) parse_terms() []*pb.Term { p.consumeLiteral("(") p.consumeLiteral("terms") - xs865 := []*pb.Term{} - cond866 := (((((((((((((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 cond866 { - _t1621 := p.parse_term() - item867 := _t1621 - xs865 = append(xs865, item867) - cond866 = (((((((((((((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)) - } - terms868 := xs865 + xs866 := []*pb.Term{} + cond867 := (((((((((((((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 cond867 { + _t1623 := p.parse_term() + item868 := _t1623 + xs866 = append(xs866, item868) + cond867 = (((((((((((((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)) + } + terms869 := xs866 p.consumeLiteral(")") - return terms868 + return terms869 } func (p *Parser) parse_term() *pb.Term { - span_start872 := int64(p.spanStart()) - var _t1622 int64 + span_start873 := int64(p.spanStart()) + var _t1624 int64 if p.matchLookaheadLiteral("true", 0) { - _t1622 = 1 + _t1624 = 1 } else { - var _t1623 int64 + var _t1625 int64 if p.matchLookaheadLiteral("missing", 0) { - _t1623 = 1 + _t1625 = 1 } else { - var _t1624 int64 + var _t1626 int64 if p.matchLookaheadLiteral("false", 0) { - _t1624 = 1 + _t1626 = 1 } else { - var _t1625 int64 + var _t1627 int64 if p.matchLookaheadLiteral("(", 0) { - _t1625 = 1 + _t1627 = 1 } else { - var _t1626 int64 + var _t1628 int64 if p.matchLookaheadTerminal("SYMBOL", 0) { - _t1626 = 0 + _t1628 = 0 } else { - var _t1627 int64 + var _t1629 int64 if p.matchLookaheadTerminal("UINT32", 0) { - _t1627 = 1 + _t1629 = 1 } else { - var _t1628 int64 + var _t1630 int64 if p.matchLookaheadTerminal("UINT128", 0) { - _t1628 = 1 + _t1630 = 1 } else { - var _t1629 int64 + var _t1631 int64 if p.matchLookaheadTerminal("STRING", 0) { - _t1629 = 1 + _t1631 = 1 } else { - var _t1630 int64 + var _t1632 int64 if p.matchLookaheadTerminal("INT32", 0) { - _t1630 = 1 + _t1632 = 1 } else { - var _t1631 int64 + var _t1633 int64 if p.matchLookaheadTerminal("INT128", 0) { - _t1631 = 1 + _t1633 = 1 } else { - var _t1632 int64 + var _t1634 int64 if p.matchLookaheadTerminal("INT", 0) { - _t1632 = 1 + _t1634 = 1 } else { - var _t1633 int64 + var _t1635 int64 if p.matchLookaheadTerminal("FLOAT32", 0) { - _t1633 = 1 + _t1635 = 1 } else { - var _t1634 int64 + var _t1636 int64 if p.matchLookaheadTerminal("FLOAT", 0) { - _t1634 = 1 + _t1636 = 1 } else { - var _t1635 int64 + var _t1637 int64 if p.matchLookaheadTerminal("DECIMAL", 0) { - _t1635 = 1 + _t1637 = 1 } else { - _t1635 = -1 + _t1637 = -1 } - _t1634 = _t1635 + _t1636 = _t1637 } - _t1633 = _t1634 + _t1635 = _t1636 } - _t1632 = _t1633 + _t1634 = _t1635 } - _t1631 = _t1632 + _t1633 = _t1634 } - _t1630 = _t1631 + _t1632 = _t1633 } - _t1629 = _t1630 + _t1631 = _t1632 } - _t1628 = _t1629 + _t1630 = _t1631 } - _t1627 = _t1628 + _t1629 = _t1630 } - _t1626 = _t1627 + _t1628 = _t1629 } - _t1625 = _t1626 + _t1627 = _t1628 } - _t1624 = _t1625 + _t1626 = _t1627 } - _t1623 = _t1624 + _t1625 = _t1626 } - _t1622 = _t1623 - } - prediction869 := _t1622 - var _t1636 *pb.Term - if prediction869 == 1 { - _t1637 := p.parse_value() - value871 := _t1637 - _t1638 := &pb.Term{} - _t1638.TermType = &pb.Term_Constant{Constant: value871} - _t1636 = _t1638 + _t1624 = _t1625 + } + prediction870 := _t1624 + var _t1638 *pb.Term + if prediction870 == 1 { + _t1639 := p.parse_value() + value872 := _t1639 + _t1640 := &pb.Term{} + _t1640.TermType = &pb.Term_Constant{Constant: value872} + _t1638 = _t1640 } else { - var _t1639 *pb.Term - if prediction869 == 0 { - _t1640 := p.parse_var() - var870 := _t1640 - _t1641 := &pb.Term{} - _t1641.TermType = &pb.Term_Var{Var: var870} - _t1639 = _t1641 + var _t1641 *pb.Term + if prediction870 == 0 { + _t1642 := p.parse_var() + var871 := _t1642 + _t1643 := &pb.Term{} + _t1643.TermType = &pb.Term_Var{Var: var871} + _t1641 = _t1643 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in term", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1636 = _t1639 + _t1638 = _t1641 } - result873 := _t1636 - p.recordSpan(int(span_start872), "Term") - return result873 + result874 := _t1638 + p.recordSpan(int(span_start873), "Term") + return result874 } func (p *Parser) parse_var() *pb.Var { - span_start875 := int64(p.spanStart()) - symbol874 := p.consumeTerminal("SYMBOL").Value.str - _t1642 := &pb.Var{Name: symbol874} - result876 := _t1642 - p.recordSpan(int(span_start875), "Var") - return result876 + span_start876 := int64(p.spanStart()) + symbol875 := p.consumeTerminal("SYMBOL").Value.str + _t1644 := &pb.Var{Name: symbol875} + result877 := _t1644 + p.recordSpan(int(span_start876), "Var") + return result877 } func (p *Parser) parse_value() *pb.Value { - span_start890 := int64(p.spanStart()) - var _t1643 int64 + span_start891 := int64(p.spanStart()) + var _t1645 int64 if p.matchLookaheadLiteral("true", 0) { - _t1643 = 12 + _t1645 = 12 } else { - var _t1644 int64 + var _t1646 int64 if p.matchLookaheadLiteral("missing", 0) { - _t1644 = 11 + _t1646 = 11 } else { - var _t1645 int64 + var _t1647 int64 if p.matchLookaheadLiteral("false", 0) { - _t1645 = 12 + _t1647 = 12 } else { - var _t1646 int64 + var _t1648 int64 if p.matchLookaheadLiteral("(", 0) { - var _t1647 int64 + var _t1649 int64 if p.matchLookaheadLiteral("datetime", 1) { - _t1647 = 1 + _t1649 = 1 } else { - var _t1648 int64 + var _t1650 int64 if p.matchLookaheadLiteral("date", 1) { - _t1648 = 0 + _t1650 = 0 } else { - _t1648 = -1 + _t1650 = -1 } - _t1647 = _t1648 + _t1649 = _t1650 } - _t1646 = _t1647 + _t1648 = _t1649 } else { - var _t1649 int64 + var _t1651 int64 if p.matchLookaheadTerminal("UINT32", 0) { - _t1649 = 7 + _t1651 = 7 } else { - var _t1650 int64 + var _t1652 int64 if p.matchLookaheadTerminal("UINT128", 0) { - _t1650 = 8 + _t1652 = 8 } else { - var _t1651 int64 + var _t1653 int64 if p.matchLookaheadTerminal("STRING", 0) { - _t1651 = 2 + _t1653 = 2 } else { - var _t1652 int64 + var _t1654 int64 if p.matchLookaheadTerminal("INT32", 0) { - _t1652 = 3 + _t1654 = 3 } else { - var _t1653 int64 + var _t1655 int64 if p.matchLookaheadTerminal("INT128", 0) { - _t1653 = 9 + _t1655 = 9 } else { - var _t1654 int64 + var _t1656 int64 if p.matchLookaheadTerminal("INT", 0) { - _t1654 = 4 + _t1656 = 4 } else { - var _t1655 int64 + var _t1657 int64 if p.matchLookaheadTerminal("FLOAT32", 0) { - _t1655 = 5 + _t1657 = 5 } else { - var _t1656 int64 + var _t1658 int64 if p.matchLookaheadTerminal("FLOAT", 0) { - _t1656 = 6 + _t1658 = 6 } else { - var _t1657 int64 + var _t1659 int64 if p.matchLookaheadTerminal("DECIMAL", 0) { - _t1657 = 10 + _t1659 = 10 } else { - _t1657 = -1 + _t1659 = -1 } - _t1656 = _t1657 + _t1658 = _t1659 } - _t1655 = _t1656 + _t1657 = _t1658 } - _t1654 = _t1655 + _t1656 = _t1657 } - _t1653 = _t1654 + _t1655 = _t1656 } - _t1652 = _t1653 + _t1654 = _t1655 } - _t1651 = _t1652 + _t1653 = _t1654 } - _t1650 = _t1651 + _t1652 = _t1653 } - _t1649 = _t1650 + _t1651 = _t1652 } - _t1646 = _t1649 + _t1648 = _t1651 } - _t1645 = _t1646 + _t1647 = _t1648 } - _t1644 = _t1645 + _t1646 = _t1647 } - _t1643 = _t1644 - } - prediction877 := _t1643 - var _t1658 *pb.Value - if prediction877 == 12 { - _t1659 := p.parse_boolean_value() - boolean_value889 := _t1659 - _t1660 := &pb.Value{} - _t1660.Value = &pb.Value_BooleanValue{BooleanValue: boolean_value889} - _t1658 = _t1660 + _t1645 = _t1646 + } + prediction878 := _t1645 + var _t1660 *pb.Value + if prediction878 == 12 { + _t1661 := p.parse_boolean_value() + boolean_value890 := _t1661 + _t1662 := &pb.Value{} + _t1662.Value = &pb.Value_BooleanValue{BooleanValue: boolean_value890} + _t1660 = _t1662 } else { - var _t1661 *pb.Value - if prediction877 == 11 { + var _t1663 *pb.Value + if prediction878 == 11 { p.consumeLiteral("missing") - _t1662 := &pb.MissingValue{} - _t1663 := &pb.Value{} - _t1663.Value = &pb.Value_MissingValue{MissingValue: _t1662} - _t1661 = _t1663 + _t1664 := &pb.MissingValue{} + _t1665 := &pb.Value{} + _t1665.Value = &pb.Value_MissingValue{MissingValue: _t1664} + _t1663 = _t1665 } else { - var _t1664 *pb.Value - if prediction877 == 10 { - formatted_decimal888 := p.consumeTerminal("DECIMAL").Value.decimal - _t1665 := &pb.Value{} - _t1665.Value = &pb.Value_DecimalValue{DecimalValue: formatted_decimal888} - _t1664 = _t1665 + var _t1666 *pb.Value + if prediction878 == 10 { + formatted_decimal889 := p.consumeTerminal("DECIMAL").Value.decimal + _t1667 := &pb.Value{} + _t1667.Value = &pb.Value_DecimalValue{DecimalValue: formatted_decimal889} + _t1666 = _t1667 } else { - var _t1666 *pb.Value - if prediction877 == 9 { - formatted_int128887 := p.consumeTerminal("INT128").Value.int128 - _t1667 := &pb.Value{} - _t1667.Value = &pb.Value_Int128Value{Int128Value: formatted_int128887} - _t1666 = _t1667 + var _t1668 *pb.Value + if prediction878 == 9 { + formatted_int128888 := p.consumeTerminal("INT128").Value.int128 + _t1669 := &pb.Value{} + _t1669.Value = &pb.Value_Int128Value{Int128Value: formatted_int128888} + _t1668 = _t1669 } else { - var _t1668 *pb.Value - if prediction877 == 8 { - formatted_uint128886 := p.consumeTerminal("UINT128").Value.uint128 - _t1669 := &pb.Value{} - _t1669.Value = &pb.Value_Uint128Value{Uint128Value: formatted_uint128886} - _t1668 = _t1669 + var _t1670 *pb.Value + if prediction878 == 8 { + formatted_uint128887 := p.consumeTerminal("UINT128").Value.uint128 + _t1671 := &pb.Value{} + _t1671.Value = &pb.Value_Uint128Value{Uint128Value: formatted_uint128887} + _t1670 = _t1671 } else { - var _t1670 *pb.Value - if prediction877 == 7 { - formatted_uint32885 := p.consumeTerminal("UINT32").Value.u32 - _t1671 := &pb.Value{} - _t1671.Value = &pb.Value_Uint32Value{Uint32Value: formatted_uint32885} - _t1670 = _t1671 + var _t1672 *pb.Value + if prediction878 == 7 { + formatted_uint32886 := p.consumeTerminal("UINT32").Value.u32 + _t1673 := &pb.Value{} + _t1673.Value = &pb.Value_Uint32Value{Uint32Value: formatted_uint32886} + _t1672 = _t1673 } else { - var _t1672 *pb.Value - if prediction877 == 6 { - formatted_float884 := p.consumeTerminal("FLOAT").Value.f64 - _t1673 := &pb.Value{} - _t1673.Value = &pb.Value_FloatValue{FloatValue: formatted_float884} - _t1672 = _t1673 + var _t1674 *pb.Value + if prediction878 == 6 { + formatted_float885 := p.consumeTerminal("FLOAT").Value.f64 + _t1675 := &pb.Value{} + _t1675.Value = &pb.Value_FloatValue{FloatValue: formatted_float885} + _t1674 = _t1675 } else { - var _t1674 *pb.Value - if prediction877 == 5 { - formatted_float32883 := p.consumeTerminal("FLOAT32").Value.f32 - _t1675 := &pb.Value{} - _t1675.Value = &pb.Value_Float32Value{Float32Value: formatted_float32883} - _t1674 = _t1675 + var _t1676 *pb.Value + if prediction878 == 5 { + formatted_float32884 := p.consumeTerminal("FLOAT32").Value.f32 + _t1677 := &pb.Value{} + _t1677.Value = &pb.Value_Float32Value{Float32Value: formatted_float32884} + _t1676 = _t1677 } else { - var _t1676 *pb.Value - if prediction877 == 4 { - formatted_int882 := p.consumeTerminal("INT").Value.i64 - _t1677 := &pb.Value{} - _t1677.Value = &pb.Value_IntValue{IntValue: formatted_int882} - _t1676 = _t1677 + var _t1678 *pb.Value + if prediction878 == 4 { + formatted_int883 := p.consumeTerminal("INT").Value.i64 + _t1679 := &pb.Value{} + _t1679.Value = &pb.Value_IntValue{IntValue: formatted_int883} + _t1678 = _t1679 } else { - var _t1678 *pb.Value - if prediction877 == 3 { - formatted_int32881 := p.consumeTerminal("INT32").Value.i32 - _t1679 := &pb.Value{} - _t1679.Value = &pb.Value_Int32Value{Int32Value: formatted_int32881} - _t1678 = _t1679 + var _t1680 *pb.Value + if prediction878 == 3 { + formatted_int32882 := p.consumeTerminal("INT32").Value.i32 + _t1681 := &pb.Value{} + _t1681.Value = &pb.Value_Int32Value{Int32Value: formatted_int32882} + _t1680 = _t1681 } else { - var _t1680 *pb.Value - if prediction877 == 2 { - formatted_string880 := p.consumeTerminal("STRING").Value.str - _t1681 := &pb.Value{} - _t1681.Value = &pb.Value_StringValue{StringValue: formatted_string880} - _t1680 = _t1681 + var _t1682 *pb.Value + if prediction878 == 2 { + formatted_string881 := p.consumeTerminal("STRING").Value.str + _t1683 := &pb.Value{} + _t1683.Value = &pb.Value_StringValue{StringValue: formatted_string881} + _t1682 = _t1683 } else { - var _t1682 *pb.Value - if prediction877 == 1 { - _t1683 := p.parse_datetime() - datetime879 := _t1683 - _t1684 := &pb.Value{} - _t1684.Value = &pb.Value_DatetimeValue{DatetimeValue: datetime879} - _t1682 = _t1684 + var _t1684 *pb.Value + if prediction878 == 1 { + _t1685 := p.parse_datetime() + datetime880 := _t1685 + _t1686 := &pb.Value{} + _t1686.Value = &pb.Value_DatetimeValue{DatetimeValue: datetime880} + _t1684 = _t1686 } else { - var _t1685 *pb.Value - if prediction877 == 0 { - _t1686 := p.parse_date() - date878 := _t1686 - _t1687 := &pb.Value{} - _t1687.Value = &pb.Value_DateValue{DateValue: date878} - _t1685 = _t1687 + var _t1687 *pb.Value + if prediction878 == 0 { + _t1688 := p.parse_date() + date879 := _t1688 + _t1689 := &pb.Value{} + _t1689.Value = &pb.Value_DateValue{DateValue: date879} + _t1687 = _t1689 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in value", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1682 = _t1685 + _t1684 = _t1687 } - _t1680 = _t1682 + _t1682 = _t1684 } - _t1678 = _t1680 + _t1680 = _t1682 } - _t1676 = _t1678 + _t1678 = _t1680 } - _t1674 = _t1676 + _t1676 = _t1678 } - _t1672 = _t1674 + _t1674 = _t1676 } - _t1670 = _t1672 + _t1672 = _t1674 } - _t1668 = _t1670 + _t1670 = _t1672 } - _t1666 = _t1668 + _t1668 = _t1670 } - _t1664 = _t1666 + _t1666 = _t1668 } - _t1661 = _t1664 + _t1663 = _t1666 } - _t1658 = _t1661 + _t1660 = _t1663 } - result891 := _t1658 - p.recordSpan(int(span_start890), "Value") - return result891 + result892 := _t1660 + p.recordSpan(int(span_start891), "Value") + return result892 } func (p *Parser) parse_date() *pb.DateValue { - span_start895 := int64(p.spanStart()) + span_start896 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("date") - formatted_int892 := p.consumeTerminal("INT").Value.i64 - formatted_int_3893 := p.consumeTerminal("INT").Value.i64 - formatted_int_4894 := p.consumeTerminal("INT").Value.i64 + formatted_int893 := p.consumeTerminal("INT").Value.i64 + formatted_int_3894 := p.consumeTerminal("INT").Value.i64 + formatted_int_4895 := p.consumeTerminal("INT").Value.i64 p.consumeLiteral(")") - _t1688 := &pb.DateValue{Year: int32(formatted_int892), Month: int32(formatted_int_3893), Day: int32(formatted_int_4894)} - result896 := _t1688 - p.recordSpan(int(span_start895), "DateValue") - return result896 + _t1690 := &pb.DateValue{Year: int32(formatted_int893), Month: int32(formatted_int_3894), Day: int32(formatted_int_4895)} + result897 := _t1690 + p.recordSpan(int(span_start896), "DateValue") + return result897 } func (p *Parser) parse_datetime() *pb.DateTimeValue { - span_start904 := int64(p.spanStart()) + span_start905 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("datetime") - formatted_int897 := p.consumeTerminal("INT").Value.i64 - formatted_int_3898 := p.consumeTerminal("INT").Value.i64 - formatted_int_4899 := p.consumeTerminal("INT").Value.i64 - formatted_int_5900 := p.consumeTerminal("INT").Value.i64 - formatted_int_6901 := p.consumeTerminal("INT").Value.i64 - formatted_int_7902 := p.consumeTerminal("INT").Value.i64 - var _t1689 *int64 + formatted_int898 := p.consumeTerminal("INT").Value.i64 + formatted_int_3899 := p.consumeTerminal("INT").Value.i64 + formatted_int_4900 := p.consumeTerminal("INT").Value.i64 + formatted_int_5901 := p.consumeTerminal("INT").Value.i64 + formatted_int_6902 := p.consumeTerminal("INT").Value.i64 + formatted_int_7903 := p.consumeTerminal("INT").Value.i64 + var _t1691 *int64 if p.matchLookaheadTerminal("INT", 0) { - _t1689 = ptr(p.consumeTerminal("INT").Value.i64) + _t1691 = ptr(p.consumeTerminal("INT").Value.i64) } - formatted_int_8903 := _t1689 + formatted_int_8904 := _t1691 p.consumeLiteral(")") - _t1690 := &pb.DateTimeValue{Year: int32(formatted_int897), Month: int32(formatted_int_3898), Day: int32(formatted_int_4899), Hour: int32(formatted_int_5900), Minute: int32(formatted_int_6901), Second: int32(formatted_int_7902), Microsecond: int32(deref(formatted_int_8903, 0))} - result905 := _t1690 - p.recordSpan(int(span_start904), "DateTimeValue") - return result905 + _t1692 := &pb.DateTimeValue{Year: int32(formatted_int898), Month: int32(formatted_int_3899), Day: int32(formatted_int_4900), Hour: int32(formatted_int_5901), Minute: int32(formatted_int_6902), Second: int32(formatted_int_7903), Microsecond: int32(deref(formatted_int_8904, 0))} + result906 := _t1692 + p.recordSpan(int(span_start905), "DateTimeValue") + return result906 } func (p *Parser) parse_conjunction() *pb.Conjunction { - span_start910 := int64(p.spanStart()) + span_start911 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("and") - xs906 := []*pb.Formula{} - cond907 := p.matchLookaheadLiteral("(", 0) - for cond907 { - _t1691 := p.parse_formula() - item908 := _t1691 - xs906 = append(xs906, item908) - cond907 = p.matchLookaheadLiteral("(", 0) - } - formulas909 := xs906 + xs907 := []*pb.Formula{} + cond908 := p.matchLookaheadLiteral("(", 0) + for cond908 { + _t1693 := p.parse_formula() + item909 := _t1693 + xs907 = append(xs907, item909) + cond908 = p.matchLookaheadLiteral("(", 0) + } + formulas910 := xs907 p.consumeLiteral(")") - _t1692 := &pb.Conjunction{Args: formulas909} - result911 := _t1692 - p.recordSpan(int(span_start910), "Conjunction") - return result911 + _t1694 := &pb.Conjunction{Args: formulas910} + result912 := _t1694 + p.recordSpan(int(span_start911), "Conjunction") + return result912 } func (p *Parser) parse_disjunction() *pb.Disjunction { - span_start916 := int64(p.spanStart()) + span_start917 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("or") - xs912 := []*pb.Formula{} - cond913 := p.matchLookaheadLiteral("(", 0) - for cond913 { - _t1693 := p.parse_formula() - item914 := _t1693 - xs912 = append(xs912, item914) - cond913 = p.matchLookaheadLiteral("(", 0) - } - formulas915 := xs912 + xs913 := []*pb.Formula{} + cond914 := p.matchLookaheadLiteral("(", 0) + for cond914 { + _t1695 := p.parse_formula() + item915 := _t1695 + xs913 = append(xs913, item915) + cond914 = p.matchLookaheadLiteral("(", 0) + } + formulas916 := xs913 p.consumeLiteral(")") - _t1694 := &pb.Disjunction{Args: formulas915} - result917 := _t1694 - p.recordSpan(int(span_start916), "Disjunction") - return result917 + _t1696 := &pb.Disjunction{Args: formulas916} + result918 := _t1696 + p.recordSpan(int(span_start917), "Disjunction") + return result918 } func (p *Parser) parse_not() *pb.Not { - span_start919 := int64(p.spanStart()) + span_start920 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("not") - _t1695 := p.parse_formula() - formula918 := _t1695 + _t1697 := p.parse_formula() + formula919 := _t1697 p.consumeLiteral(")") - _t1696 := &pb.Not{Arg: formula918} - result920 := _t1696 - p.recordSpan(int(span_start919), "Not") - return result920 + _t1698 := &pb.Not{Arg: formula919} + result921 := _t1698 + p.recordSpan(int(span_start920), "Not") + return result921 } func (p *Parser) parse_ffi() *pb.FFI { - span_start924 := int64(p.spanStart()) + span_start925 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("ffi") - _t1697 := p.parse_name() - name921 := _t1697 - _t1698 := p.parse_ffi_args() - ffi_args922 := _t1698 - _t1699 := p.parse_terms() - terms923 := _t1699 + _t1699 := p.parse_name() + name922 := _t1699 + _t1700 := p.parse_ffi_args() + ffi_args923 := _t1700 + _t1701 := p.parse_terms() + terms924 := _t1701 p.consumeLiteral(")") - _t1700 := &pb.FFI{Name: name921, Args: ffi_args922, Terms: terms923} - result925 := _t1700 - p.recordSpan(int(span_start924), "FFI") - return result925 + _t1702 := &pb.FFI{Name: name922, Args: ffi_args923, Terms: terms924} + result926 := _t1702 + p.recordSpan(int(span_start925), "FFI") + return result926 } func (p *Parser) parse_name() string { p.consumeLiteral(":") - symbol926 := p.consumeTerminal("SYMBOL").Value.str - return symbol926 + symbol927 := p.consumeTerminal("SYMBOL").Value.str + return symbol927 } func (p *Parser) parse_ffi_args() []*pb.Abstraction { p.consumeLiteral("(") p.consumeLiteral("args") - xs927 := []*pb.Abstraction{} - cond928 := p.matchLookaheadLiteral("(", 0) - for cond928 { - _t1701 := p.parse_abstraction() - item929 := _t1701 - xs927 = append(xs927, item929) - cond928 = p.matchLookaheadLiteral("(", 0) - } - abstractions930 := xs927 + xs928 := []*pb.Abstraction{} + cond929 := p.matchLookaheadLiteral("(", 0) + for cond929 { + _t1703 := p.parse_abstraction() + item930 := _t1703 + xs928 = append(xs928, item930) + cond929 = p.matchLookaheadLiteral("(", 0) + } + abstractions931 := xs928 p.consumeLiteral(")") - return abstractions930 + return abstractions931 } func (p *Parser) parse_atom() *pb.Atom { - span_start936 := int64(p.spanStart()) + span_start937 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("atom") - _t1702 := p.parse_relation_id() - relation_id931 := _t1702 - xs932 := []*pb.Term{} - cond933 := (((((((((((((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 cond933 { - _t1703 := p.parse_term() - item934 := _t1703 - xs932 = append(xs932, item934) - cond933 = (((((((((((((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)) - } - terms935 := xs932 + _t1704 := p.parse_relation_id() + relation_id932 := _t1704 + xs933 := []*pb.Term{} + cond934 := (((((((((((((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 cond934 { + _t1705 := p.parse_term() + item935 := _t1705 + xs933 = append(xs933, item935) + cond934 = (((((((((((((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)) + } + terms936 := xs933 p.consumeLiteral(")") - _t1704 := &pb.Atom{Name: relation_id931, Terms: terms935} - result937 := _t1704 - p.recordSpan(int(span_start936), "Atom") - return result937 + _t1706 := &pb.Atom{Name: relation_id932, Terms: terms936} + result938 := _t1706 + p.recordSpan(int(span_start937), "Atom") + return result938 } func (p *Parser) parse_pragma() *pb.Pragma { - span_start943 := int64(p.spanStart()) + span_start944 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("pragma") - _t1705 := p.parse_name() - name938 := _t1705 - xs939 := []*pb.Term{} - cond940 := (((((((((((((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 cond940 { - _t1706 := p.parse_term() - item941 := _t1706 - xs939 = append(xs939, item941) - cond940 = (((((((((((((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)) - } - terms942 := xs939 + _t1707 := p.parse_name() + name939 := _t1707 + xs940 := []*pb.Term{} + cond941 := (((((((((((((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 cond941 { + _t1708 := p.parse_term() + item942 := _t1708 + xs940 = append(xs940, item942) + cond941 = (((((((((((((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)) + } + terms943 := xs940 p.consumeLiteral(")") - _t1707 := &pb.Pragma{Name: name938, Terms: terms942} - result944 := _t1707 - p.recordSpan(int(span_start943), "Pragma") - return result944 + _t1709 := &pb.Pragma{Name: name939, Terms: terms943} + result945 := _t1709 + p.recordSpan(int(span_start944), "Pragma") + return result945 } func (p *Parser) parse_primitive() *pb.Primitive { - span_start960 := int64(p.spanStart()) - var _t1708 int64 + span_start961 := int64(p.spanStart()) + var _t1710 int64 if p.matchLookaheadLiteral("(", 0) { - var _t1709 int64 + var _t1711 int64 if p.matchLookaheadLiteral("primitive", 1) { - _t1709 = 9 + _t1711 = 9 } else { - var _t1710 int64 + var _t1712 int64 if p.matchLookaheadLiteral(">=", 1) { - _t1710 = 4 + _t1712 = 4 } else { - var _t1711 int64 + var _t1713 int64 if p.matchLookaheadLiteral(">", 1) { - _t1711 = 3 + _t1713 = 3 } else { - var _t1712 int64 + var _t1714 int64 if p.matchLookaheadLiteral("=", 1) { - _t1712 = 0 + _t1714 = 0 } else { - var _t1713 int64 + var _t1715 int64 if p.matchLookaheadLiteral("<=", 1) { - _t1713 = 2 + _t1715 = 2 } else { - var _t1714 int64 + var _t1716 int64 if p.matchLookaheadLiteral("<", 1) { - _t1714 = 1 + _t1716 = 1 } else { - var _t1715 int64 + var _t1717 int64 if p.matchLookaheadLiteral("/", 1) { - _t1715 = 8 + _t1717 = 8 } else { - var _t1716 int64 + var _t1718 int64 if p.matchLookaheadLiteral("-", 1) { - _t1716 = 6 + _t1718 = 6 } else { - var _t1717 int64 + var _t1719 int64 if p.matchLookaheadLiteral("+", 1) { - _t1717 = 5 + _t1719 = 5 } else { - var _t1718 int64 + var _t1720 int64 if p.matchLookaheadLiteral("*", 1) { - _t1718 = 7 + _t1720 = 7 } else { - _t1718 = -1 + _t1720 = -1 } - _t1717 = _t1718 + _t1719 = _t1720 } - _t1716 = _t1717 + _t1718 = _t1719 } - _t1715 = _t1716 + _t1717 = _t1718 } - _t1714 = _t1715 + _t1716 = _t1717 } - _t1713 = _t1714 + _t1715 = _t1716 } - _t1712 = _t1713 + _t1714 = _t1715 } - _t1711 = _t1712 + _t1713 = _t1714 } - _t1710 = _t1711 + _t1712 = _t1713 } - _t1709 = _t1710 + _t1711 = _t1712 } - _t1708 = _t1709 + _t1710 = _t1711 } else { - _t1708 = -1 + _t1710 = -1 } - prediction945 := _t1708 - var _t1719 *pb.Primitive - if prediction945 == 9 { + prediction946 := _t1710 + var _t1721 *pb.Primitive + if prediction946 == 9 { p.consumeLiteral("(") p.consumeLiteral("primitive") - _t1720 := p.parse_name() - name955 := _t1720 - xs956 := []*pb.RelTerm{} - cond957 := ((((((((((((((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 cond957 { - _t1721 := p.parse_rel_term() - item958 := _t1721 - xs956 = append(xs956, item958) - cond957 = ((((((((((((((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)) + _t1722 := p.parse_name() + name956 := _t1722 + xs957 := []*pb.RelTerm{} + cond958 := ((((((((((((((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 cond958 { + _t1723 := p.parse_rel_term() + item959 := _t1723 + xs957 = append(xs957, item959) + cond958 = ((((((((((((((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_terms959 := xs956 + rel_terms960 := xs957 p.consumeLiteral(")") - _t1722 := &pb.Primitive{Name: name955, Terms: rel_terms959} - _t1719 = _t1722 + _t1724 := &pb.Primitive{Name: name956, Terms: rel_terms960} + _t1721 = _t1724 } else { - var _t1723 *pb.Primitive - if prediction945 == 8 { - _t1724 := p.parse_divide() - divide954 := _t1724 - _t1723 = divide954 + var _t1725 *pb.Primitive + if prediction946 == 8 { + _t1726 := p.parse_divide() + divide955 := _t1726 + _t1725 = divide955 } else { - var _t1725 *pb.Primitive - if prediction945 == 7 { - _t1726 := p.parse_multiply() - multiply953 := _t1726 - _t1725 = multiply953 + var _t1727 *pb.Primitive + if prediction946 == 7 { + _t1728 := p.parse_multiply() + multiply954 := _t1728 + _t1727 = multiply954 } else { - var _t1727 *pb.Primitive - if prediction945 == 6 { - _t1728 := p.parse_minus() - minus952 := _t1728 - _t1727 = minus952 + var _t1729 *pb.Primitive + if prediction946 == 6 { + _t1730 := p.parse_minus() + minus953 := _t1730 + _t1729 = minus953 } else { - var _t1729 *pb.Primitive - if prediction945 == 5 { - _t1730 := p.parse_add() - add951 := _t1730 - _t1729 = add951 + var _t1731 *pb.Primitive + if prediction946 == 5 { + _t1732 := p.parse_add() + add952 := _t1732 + _t1731 = add952 } else { - var _t1731 *pb.Primitive - if prediction945 == 4 { - _t1732 := p.parse_gt_eq() - gt_eq950 := _t1732 - _t1731 = gt_eq950 + var _t1733 *pb.Primitive + if prediction946 == 4 { + _t1734 := p.parse_gt_eq() + gt_eq951 := _t1734 + _t1733 = gt_eq951 } else { - var _t1733 *pb.Primitive - if prediction945 == 3 { - _t1734 := p.parse_gt() - gt949 := _t1734 - _t1733 = gt949 + var _t1735 *pb.Primitive + if prediction946 == 3 { + _t1736 := p.parse_gt() + gt950 := _t1736 + _t1735 = gt950 } else { - var _t1735 *pb.Primitive - if prediction945 == 2 { - _t1736 := p.parse_lt_eq() - lt_eq948 := _t1736 - _t1735 = lt_eq948 + var _t1737 *pb.Primitive + if prediction946 == 2 { + _t1738 := p.parse_lt_eq() + lt_eq949 := _t1738 + _t1737 = lt_eq949 } else { - var _t1737 *pb.Primitive - if prediction945 == 1 { - _t1738 := p.parse_lt() - lt947 := _t1738 - _t1737 = lt947 + var _t1739 *pb.Primitive + if prediction946 == 1 { + _t1740 := p.parse_lt() + lt948 := _t1740 + _t1739 = lt948 } else { - var _t1739 *pb.Primitive - if prediction945 == 0 { - _t1740 := p.parse_eq() - eq946 := _t1740 - _t1739 = eq946 + var _t1741 *pb.Primitive + if prediction946 == 0 { + _t1742 := p.parse_eq() + eq947 := _t1742 + _t1741 = eq947 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in primitive", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1737 = _t1739 + _t1739 = _t1741 } - _t1735 = _t1737 + _t1737 = _t1739 } - _t1733 = _t1735 + _t1735 = _t1737 } - _t1731 = _t1733 + _t1733 = _t1735 } - _t1729 = _t1731 + _t1731 = _t1733 } - _t1727 = _t1729 + _t1729 = _t1731 } - _t1725 = _t1727 + _t1727 = _t1729 } - _t1723 = _t1725 + _t1725 = _t1727 } - _t1719 = _t1723 + _t1721 = _t1725 } - result961 := _t1719 - p.recordSpan(int(span_start960), "Primitive") - return result961 + result962 := _t1721 + p.recordSpan(int(span_start961), "Primitive") + return result962 } func (p *Parser) parse_eq() *pb.Primitive { - span_start964 := int64(p.spanStart()) + span_start965 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("=") - _t1741 := p.parse_term() - term962 := _t1741 - _t1742 := p.parse_term() - term_3963 := _t1742 + _t1743 := p.parse_term() + term963 := _t1743 + _t1744 := p.parse_term() + term_3964 := _t1744 p.consumeLiteral(")") - _t1743 := &pb.RelTerm{} - _t1743.RelTermType = &pb.RelTerm_Term{Term: term962} - _t1744 := &pb.RelTerm{} - _t1744.RelTermType = &pb.RelTerm_Term{Term: term_3963} - _t1745 := &pb.Primitive{Name: "rel_primitive_eq", Terms: []*pb.RelTerm{_t1743, _t1744}} - result965 := _t1745 - p.recordSpan(int(span_start964), "Primitive") - return result965 + _t1745 := &pb.RelTerm{} + _t1745.RelTermType = &pb.RelTerm_Term{Term: term963} + _t1746 := &pb.RelTerm{} + _t1746.RelTermType = &pb.RelTerm_Term{Term: term_3964} + _t1747 := &pb.Primitive{Name: "rel_primitive_eq", Terms: []*pb.RelTerm{_t1745, _t1746}} + result966 := _t1747 + p.recordSpan(int(span_start965), "Primitive") + return result966 } func (p *Parser) parse_lt() *pb.Primitive { - span_start968 := int64(p.spanStart()) + span_start969 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("<") - _t1746 := p.parse_term() - term966 := _t1746 - _t1747 := p.parse_term() - term_3967 := _t1747 + _t1748 := p.parse_term() + term967 := _t1748 + _t1749 := p.parse_term() + term_3968 := _t1749 p.consumeLiteral(")") - _t1748 := &pb.RelTerm{} - _t1748.RelTermType = &pb.RelTerm_Term{Term: term966} - _t1749 := &pb.RelTerm{} - _t1749.RelTermType = &pb.RelTerm_Term{Term: term_3967} - _t1750 := &pb.Primitive{Name: "rel_primitive_lt_monotype", Terms: []*pb.RelTerm{_t1748, _t1749}} - result969 := _t1750 - p.recordSpan(int(span_start968), "Primitive") - return result969 + _t1750 := &pb.RelTerm{} + _t1750.RelTermType = &pb.RelTerm_Term{Term: term967} + _t1751 := &pb.RelTerm{} + _t1751.RelTermType = &pb.RelTerm_Term{Term: term_3968} + _t1752 := &pb.Primitive{Name: "rel_primitive_lt_monotype", Terms: []*pb.RelTerm{_t1750, _t1751}} + result970 := _t1752 + p.recordSpan(int(span_start969), "Primitive") + return result970 } func (p *Parser) parse_lt_eq() *pb.Primitive { - span_start972 := int64(p.spanStart()) + span_start973 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("<=") - _t1751 := p.parse_term() - term970 := _t1751 - _t1752 := p.parse_term() - term_3971 := _t1752 + _t1753 := p.parse_term() + term971 := _t1753 + _t1754 := p.parse_term() + term_3972 := _t1754 p.consumeLiteral(")") - _t1753 := &pb.RelTerm{} - _t1753.RelTermType = &pb.RelTerm_Term{Term: term970} - _t1754 := &pb.RelTerm{} - _t1754.RelTermType = &pb.RelTerm_Term{Term: term_3971} - _t1755 := &pb.Primitive{Name: "rel_primitive_lt_eq_monotype", Terms: []*pb.RelTerm{_t1753, _t1754}} - result973 := _t1755 - p.recordSpan(int(span_start972), "Primitive") - return result973 + _t1755 := &pb.RelTerm{} + _t1755.RelTermType = &pb.RelTerm_Term{Term: term971} + _t1756 := &pb.RelTerm{} + _t1756.RelTermType = &pb.RelTerm_Term{Term: term_3972} + _t1757 := &pb.Primitive{Name: "rel_primitive_lt_eq_monotype", Terms: []*pb.RelTerm{_t1755, _t1756}} + result974 := _t1757 + p.recordSpan(int(span_start973), "Primitive") + return result974 } func (p *Parser) parse_gt() *pb.Primitive { - span_start976 := int64(p.spanStart()) + span_start977 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral(">") - _t1756 := p.parse_term() - term974 := _t1756 - _t1757 := p.parse_term() - term_3975 := _t1757 + _t1758 := p.parse_term() + term975 := _t1758 + _t1759 := p.parse_term() + term_3976 := _t1759 p.consumeLiteral(")") - _t1758 := &pb.RelTerm{} - _t1758.RelTermType = &pb.RelTerm_Term{Term: term974} - _t1759 := &pb.RelTerm{} - _t1759.RelTermType = &pb.RelTerm_Term{Term: term_3975} - _t1760 := &pb.Primitive{Name: "rel_primitive_gt_monotype", Terms: []*pb.RelTerm{_t1758, _t1759}} - result977 := _t1760 - p.recordSpan(int(span_start976), "Primitive") - return result977 + _t1760 := &pb.RelTerm{} + _t1760.RelTermType = &pb.RelTerm_Term{Term: term975} + _t1761 := &pb.RelTerm{} + _t1761.RelTermType = &pb.RelTerm_Term{Term: term_3976} + _t1762 := &pb.Primitive{Name: "rel_primitive_gt_monotype", Terms: []*pb.RelTerm{_t1760, _t1761}} + result978 := _t1762 + p.recordSpan(int(span_start977), "Primitive") + return result978 } func (p *Parser) parse_gt_eq() *pb.Primitive { - span_start980 := int64(p.spanStart()) + span_start981 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral(">=") - _t1761 := p.parse_term() - term978 := _t1761 - _t1762 := p.parse_term() - term_3979 := _t1762 + _t1763 := p.parse_term() + term979 := _t1763 + _t1764 := p.parse_term() + term_3980 := _t1764 p.consumeLiteral(")") - _t1763 := &pb.RelTerm{} - _t1763.RelTermType = &pb.RelTerm_Term{Term: term978} - _t1764 := &pb.RelTerm{} - _t1764.RelTermType = &pb.RelTerm_Term{Term: term_3979} - _t1765 := &pb.Primitive{Name: "rel_primitive_gt_eq_monotype", Terms: []*pb.RelTerm{_t1763, _t1764}} - result981 := _t1765 - p.recordSpan(int(span_start980), "Primitive") - return result981 + _t1765 := &pb.RelTerm{} + _t1765.RelTermType = &pb.RelTerm_Term{Term: term979} + _t1766 := &pb.RelTerm{} + _t1766.RelTermType = &pb.RelTerm_Term{Term: term_3980} + _t1767 := &pb.Primitive{Name: "rel_primitive_gt_eq_monotype", Terms: []*pb.RelTerm{_t1765, _t1766}} + result982 := _t1767 + p.recordSpan(int(span_start981), "Primitive") + return result982 } func (p *Parser) parse_add() *pb.Primitive { - span_start985 := int64(p.spanStart()) + span_start986 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("+") - _t1766 := p.parse_term() - term982 := _t1766 - _t1767 := p.parse_term() - term_3983 := _t1767 _t1768 := p.parse_term() - term_4984 := _t1768 + term983 := _t1768 + _t1769 := p.parse_term() + term_3984 := _t1769 + _t1770 := p.parse_term() + term_4985 := _t1770 p.consumeLiteral(")") - _t1769 := &pb.RelTerm{} - _t1769.RelTermType = &pb.RelTerm_Term{Term: term982} - _t1770 := &pb.RelTerm{} - _t1770.RelTermType = &pb.RelTerm_Term{Term: term_3983} _t1771 := &pb.RelTerm{} - _t1771.RelTermType = &pb.RelTerm_Term{Term: term_4984} - _t1772 := &pb.Primitive{Name: "rel_primitive_add_monotype", Terms: []*pb.RelTerm{_t1769, _t1770, _t1771}} - result986 := _t1772 - p.recordSpan(int(span_start985), "Primitive") - return result986 + _t1771.RelTermType = &pb.RelTerm_Term{Term: term983} + _t1772 := &pb.RelTerm{} + _t1772.RelTermType = &pb.RelTerm_Term{Term: term_3984} + _t1773 := &pb.RelTerm{} + _t1773.RelTermType = &pb.RelTerm_Term{Term: term_4985} + _t1774 := &pb.Primitive{Name: "rel_primitive_add_monotype", Terms: []*pb.RelTerm{_t1771, _t1772, _t1773}} + result987 := _t1774 + p.recordSpan(int(span_start986), "Primitive") + return result987 } func (p *Parser) parse_minus() *pb.Primitive { - span_start990 := int64(p.spanStart()) + span_start991 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("-") - _t1773 := p.parse_term() - term987 := _t1773 - _t1774 := p.parse_term() - term_3988 := _t1774 _t1775 := p.parse_term() - term_4989 := _t1775 + term988 := _t1775 + _t1776 := p.parse_term() + term_3989 := _t1776 + _t1777 := p.parse_term() + term_4990 := _t1777 p.consumeLiteral(")") - _t1776 := &pb.RelTerm{} - _t1776.RelTermType = &pb.RelTerm_Term{Term: term987} - _t1777 := &pb.RelTerm{} - _t1777.RelTermType = &pb.RelTerm_Term{Term: term_3988} _t1778 := &pb.RelTerm{} - _t1778.RelTermType = &pb.RelTerm_Term{Term: term_4989} - _t1779 := &pb.Primitive{Name: "rel_primitive_subtract_monotype", Terms: []*pb.RelTerm{_t1776, _t1777, _t1778}} - result991 := _t1779 - p.recordSpan(int(span_start990), "Primitive") - return result991 + _t1778.RelTermType = &pb.RelTerm_Term{Term: term988} + _t1779 := &pb.RelTerm{} + _t1779.RelTermType = &pb.RelTerm_Term{Term: term_3989} + _t1780 := &pb.RelTerm{} + _t1780.RelTermType = &pb.RelTerm_Term{Term: term_4990} + _t1781 := &pb.Primitive{Name: "rel_primitive_subtract_monotype", Terms: []*pb.RelTerm{_t1778, _t1779, _t1780}} + result992 := _t1781 + p.recordSpan(int(span_start991), "Primitive") + return result992 } func (p *Parser) parse_multiply() *pb.Primitive { - span_start995 := int64(p.spanStart()) + span_start996 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("*") - _t1780 := p.parse_term() - term992 := _t1780 - _t1781 := p.parse_term() - term_3993 := _t1781 _t1782 := p.parse_term() - term_4994 := _t1782 + term993 := _t1782 + _t1783 := p.parse_term() + term_3994 := _t1783 + _t1784 := p.parse_term() + term_4995 := _t1784 p.consumeLiteral(")") - _t1783 := &pb.RelTerm{} - _t1783.RelTermType = &pb.RelTerm_Term{Term: term992} - _t1784 := &pb.RelTerm{} - _t1784.RelTermType = &pb.RelTerm_Term{Term: term_3993} _t1785 := &pb.RelTerm{} - _t1785.RelTermType = &pb.RelTerm_Term{Term: term_4994} - _t1786 := &pb.Primitive{Name: "rel_primitive_multiply_monotype", Terms: []*pb.RelTerm{_t1783, _t1784, _t1785}} - result996 := _t1786 - p.recordSpan(int(span_start995), "Primitive") - return result996 + _t1785.RelTermType = &pb.RelTerm_Term{Term: term993} + _t1786 := &pb.RelTerm{} + _t1786.RelTermType = &pb.RelTerm_Term{Term: term_3994} + _t1787 := &pb.RelTerm{} + _t1787.RelTermType = &pb.RelTerm_Term{Term: term_4995} + _t1788 := &pb.Primitive{Name: "rel_primitive_multiply_monotype", Terms: []*pb.RelTerm{_t1785, _t1786, _t1787}} + result997 := _t1788 + p.recordSpan(int(span_start996), "Primitive") + return result997 } func (p *Parser) parse_divide() *pb.Primitive { - span_start1000 := int64(p.spanStart()) + span_start1001 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("/") - _t1787 := p.parse_term() - term997 := _t1787 - _t1788 := p.parse_term() - term_3998 := _t1788 _t1789 := p.parse_term() - term_4999 := _t1789 + term998 := _t1789 + _t1790 := p.parse_term() + term_3999 := _t1790 + _t1791 := p.parse_term() + term_41000 := _t1791 p.consumeLiteral(")") - _t1790 := &pb.RelTerm{} - _t1790.RelTermType = &pb.RelTerm_Term{Term: term997} - _t1791 := &pb.RelTerm{} - _t1791.RelTermType = &pb.RelTerm_Term{Term: term_3998} _t1792 := &pb.RelTerm{} - _t1792.RelTermType = &pb.RelTerm_Term{Term: term_4999} - _t1793 := &pb.Primitive{Name: "rel_primitive_divide_monotype", Terms: []*pb.RelTerm{_t1790, _t1791, _t1792}} - result1001 := _t1793 - p.recordSpan(int(span_start1000), "Primitive") - return result1001 + _t1792.RelTermType = &pb.RelTerm_Term{Term: term998} + _t1793 := &pb.RelTerm{} + _t1793.RelTermType = &pb.RelTerm_Term{Term: term_3999} + _t1794 := &pb.RelTerm{} + _t1794.RelTermType = &pb.RelTerm_Term{Term: term_41000} + _t1795 := &pb.Primitive{Name: "rel_primitive_divide_monotype", Terms: []*pb.RelTerm{_t1792, _t1793, _t1794}} + result1002 := _t1795 + p.recordSpan(int(span_start1001), "Primitive") + return result1002 } func (p *Parser) parse_rel_term() *pb.RelTerm { - span_start1005 := int64(p.spanStart()) - var _t1794 int64 + span_start1006 := int64(p.spanStart()) + var _t1796 int64 if p.matchLookaheadLiteral("true", 0) { - _t1794 = 1 + _t1796 = 1 } else { - var _t1795 int64 + var _t1797 int64 if p.matchLookaheadLiteral("missing", 0) { - _t1795 = 1 + _t1797 = 1 } else { - var _t1796 int64 + var _t1798 int64 if p.matchLookaheadLiteral("false", 0) { - _t1796 = 1 + _t1798 = 1 } else { - var _t1797 int64 + var _t1799 int64 if p.matchLookaheadLiteral("(", 0) { - _t1797 = 1 + _t1799 = 1 } else { - var _t1798 int64 + var _t1800 int64 if p.matchLookaheadLiteral("#", 0) { - _t1798 = 0 + _t1800 = 0 } else { - var _t1799 int64 + var _t1801 int64 if p.matchLookaheadTerminal("SYMBOL", 0) { - _t1799 = 1 + _t1801 = 1 } else { - var _t1800 int64 + var _t1802 int64 if p.matchLookaheadTerminal("UINT32", 0) { - _t1800 = 1 + _t1802 = 1 } else { - var _t1801 int64 + var _t1803 int64 if p.matchLookaheadTerminal("UINT128", 0) { - _t1801 = 1 + _t1803 = 1 } else { - var _t1802 int64 + var _t1804 int64 if p.matchLookaheadTerminal("STRING", 0) { - _t1802 = 1 + _t1804 = 1 } else { - var _t1803 int64 + var _t1805 int64 if p.matchLookaheadTerminal("INT32", 0) { - _t1803 = 1 + _t1805 = 1 } else { - var _t1804 int64 + var _t1806 int64 if p.matchLookaheadTerminal("INT128", 0) { - _t1804 = 1 + _t1806 = 1 } else { - var _t1805 int64 + var _t1807 int64 if p.matchLookaheadTerminal("INT", 0) { - _t1805 = 1 + _t1807 = 1 } else { - var _t1806 int64 + var _t1808 int64 if p.matchLookaheadTerminal("FLOAT32", 0) { - _t1806 = 1 + _t1808 = 1 } else { - var _t1807 int64 + var _t1809 int64 if p.matchLookaheadTerminal("FLOAT", 0) { - _t1807 = 1 + _t1809 = 1 } else { - var _t1808 int64 + var _t1810 int64 if p.matchLookaheadTerminal("DECIMAL", 0) { - _t1808 = 1 + _t1810 = 1 } else { - _t1808 = -1 + _t1810 = -1 } - _t1807 = _t1808 + _t1809 = _t1810 } - _t1806 = _t1807 + _t1808 = _t1809 } - _t1805 = _t1806 + _t1807 = _t1808 } - _t1804 = _t1805 + _t1806 = _t1807 } - _t1803 = _t1804 + _t1805 = _t1806 } - _t1802 = _t1803 + _t1804 = _t1805 } - _t1801 = _t1802 + _t1803 = _t1804 } - _t1800 = _t1801 + _t1802 = _t1803 } - _t1799 = _t1800 + _t1801 = _t1802 } - _t1798 = _t1799 + _t1800 = _t1801 } - _t1797 = _t1798 + _t1799 = _t1800 } - _t1796 = _t1797 + _t1798 = _t1799 } - _t1795 = _t1796 + _t1797 = _t1798 } - _t1794 = _t1795 - } - prediction1002 := _t1794 - var _t1809 *pb.RelTerm - if prediction1002 == 1 { - _t1810 := p.parse_term() - term1004 := _t1810 - _t1811 := &pb.RelTerm{} - _t1811.RelTermType = &pb.RelTerm_Term{Term: term1004} - _t1809 = _t1811 + _t1796 = _t1797 + } + prediction1003 := _t1796 + var _t1811 *pb.RelTerm + if prediction1003 == 1 { + _t1812 := p.parse_term() + term1005 := _t1812 + _t1813 := &pb.RelTerm{} + _t1813.RelTermType = &pb.RelTerm_Term{Term: term1005} + _t1811 = _t1813 } else { - var _t1812 *pb.RelTerm - if prediction1002 == 0 { - _t1813 := p.parse_specialized_value() - specialized_value1003 := _t1813 - _t1814 := &pb.RelTerm{} - _t1814.RelTermType = &pb.RelTerm_SpecializedValue{SpecializedValue: specialized_value1003} - _t1812 = _t1814 + var _t1814 *pb.RelTerm + if prediction1003 == 0 { + _t1815 := p.parse_specialized_value() + specialized_value1004 := _t1815 + _t1816 := &pb.RelTerm{} + _t1816.RelTermType = &pb.RelTerm_SpecializedValue{SpecializedValue: specialized_value1004} + _t1814 = _t1816 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in rel_term", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1809 = _t1812 + _t1811 = _t1814 } - result1006 := _t1809 - p.recordSpan(int(span_start1005), "RelTerm") - return result1006 + result1007 := _t1811 + p.recordSpan(int(span_start1006), "RelTerm") + return result1007 } func (p *Parser) parse_specialized_value() *pb.Value { - span_start1008 := int64(p.spanStart()) + span_start1009 := int64(p.spanStart()) p.consumeLiteral("#") - _t1815 := p.parse_raw_value() - raw_value1007 := _t1815 - result1009 := raw_value1007 - p.recordSpan(int(span_start1008), "Value") - return result1009 + _t1817 := p.parse_raw_value() + raw_value1008 := _t1817 + result1010 := raw_value1008 + p.recordSpan(int(span_start1009), "Value") + return result1010 } func (p *Parser) parse_rel_atom() *pb.RelAtom { - span_start1015 := int64(p.spanStart()) + span_start1016 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("relatom") - _t1816 := p.parse_name() - name1010 := _t1816 - xs1011 := []*pb.RelTerm{} - cond1012 := ((((((((((((((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 cond1012 { - _t1817 := p.parse_rel_term() - item1013 := _t1817 - xs1011 = append(xs1011, item1013) - cond1012 = ((((((((((((((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_terms1014 := xs1011 + _t1818 := p.parse_name() + name1011 := _t1818 + xs1012 := []*pb.RelTerm{} + cond1013 := ((((((((((((((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 cond1013 { + _t1819 := p.parse_rel_term() + item1014 := _t1819 + xs1012 = append(xs1012, item1014) + cond1013 = ((((((((((((((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_terms1015 := xs1012 p.consumeLiteral(")") - _t1818 := &pb.RelAtom{Name: name1010, Terms: rel_terms1014} - result1016 := _t1818 - p.recordSpan(int(span_start1015), "RelAtom") - return result1016 + _t1820 := &pb.RelAtom{Name: name1011, Terms: rel_terms1015} + result1017 := _t1820 + p.recordSpan(int(span_start1016), "RelAtom") + return result1017 } func (p *Parser) parse_cast() *pb.Cast { - span_start1019 := int64(p.spanStart()) + span_start1020 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("cast") - _t1819 := p.parse_term() - term1017 := _t1819 - _t1820 := p.parse_term() - term_31018 := _t1820 + _t1821 := p.parse_term() + term1018 := _t1821 + _t1822 := p.parse_term() + term_31019 := _t1822 p.consumeLiteral(")") - _t1821 := &pb.Cast{Input: term1017, Result: term_31018} - result1020 := _t1821 - p.recordSpan(int(span_start1019), "Cast") - return result1020 + _t1823 := &pb.Cast{Input: term1018, Result: term_31019} + result1021 := _t1823 + p.recordSpan(int(span_start1020), "Cast") + return result1021 } func (p *Parser) parse_attrs() []*pb.Attribute { p.consumeLiteral("(") p.consumeLiteral("attrs") - xs1021 := []*pb.Attribute{} - cond1022 := p.matchLookaheadLiteral("(", 0) - for cond1022 { - _t1822 := p.parse_attribute() - item1023 := _t1822 - xs1021 = append(xs1021, item1023) - cond1022 = p.matchLookaheadLiteral("(", 0) - } - attributes1024 := xs1021 + xs1022 := []*pb.Attribute{} + cond1023 := p.matchLookaheadLiteral("(", 0) + for cond1023 { + _t1824 := p.parse_attribute() + item1024 := _t1824 + xs1022 = append(xs1022, item1024) + cond1023 = p.matchLookaheadLiteral("(", 0) + } + attributes1025 := xs1022 p.consumeLiteral(")") - return attributes1024 + return attributes1025 } func (p *Parser) parse_attribute() *pb.Attribute { - span_start1030 := int64(p.spanStart()) + span_start1031 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("attribute") - _t1823 := p.parse_name() - name1025 := _t1823 - xs1026 := []*pb.Value{} - cond1027 := ((((((((((((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 cond1027 { - _t1824 := p.parse_raw_value() - item1028 := _t1824 - xs1026 = append(xs1026, item1028) - cond1027 = ((((((((((((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_values1029 := xs1026 + _t1825 := p.parse_name() + name1026 := _t1825 + xs1027 := []*pb.Value{} + cond1028 := ((((((((((((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 cond1028 { + _t1826 := p.parse_raw_value() + item1029 := _t1826 + xs1027 = append(xs1027, item1029) + cond1028 = ((((((((((((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_values1030 := xs1027 p.consumeLiteral(")") - _t1825 := &pb.Attribute{Name: name1025, Args: raw_values1029} - result1031 := _t1825 - p.recordSpan(int(span_start1030), "Attribute") - return result1031 + _t1827 := &pb.Attribute{Name: name1026, Args: raw_values1030} + result1032 := _t1827 + p.recordSpan(int(span_start1031), "Attribute") + return result1032 } func (p *Parser) parse_algorithm() *pb.Algorithm { - span_start1037 := int64(p.spanStart()) + span_start1038 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("algorithm") - xs1032 := []*pb.RelationId{} - cond1033 := (p.matchLookaheadLiteral(":", 0) || p.matchLookaheadTerminal("UINT128", 0)) - for cond1033 { - _t1826 := p.parse_relation_id() - item1034 := _t1826 - xs1032 = append(xs1032, item1034) - cond1033 = (p.matchLookaheadLiteral(":", 0) || p.matchLookaheadTerminal("UINT128", 0)) - } - relation_ids1035 := xs1032 - _t1827 := p.parse_script() - script1036 := _t1827 + xs1033 := []*pb.RelationId{} + cond1034 := (p.matchLookaheadLiteral(":", 0) || p.matchLookaheadTerminal("UINT128", 0)) + for cond1034 { + _t1828 := p.parse_relation_id() + item1035 := _t1828 + xs1033 = append(xs1033, item1035) + cond1034 = (p.matchLookaheadLiteral(":", 0) || p.matchLookaheadTerminal("UINT128", 0)) + } + relation_ids1036 := xs1033 + _t1829 := p.parse_script() + script1037 := _t1829 p.consumeLiteral(")") - _t1828 := &pb.Algorithm{Global: relation_ids1035, Body: script1036} - result1038 := _t1828 - p.recordSpan(int(span_start1037), "Algorithm") - return result1038 + _t1830 := &pb.Algorithm{Global: relation_ids1036, Body: script1037} + result1039 := _t1830 + p.recordSpan(int(span_start1038), "Algorithm") + return result1039 } func (p *Parser) parse_script() *pb.Script { - span_start1043 := int64(p.spanStart()) + span_start1044 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("script") - xs1039 := []*pb.Construct{} - cond1040 := p.matchLookaheadLiteral("(", 0) - for cond1040 { - _t1829 := p.parse_construct() - item1041 := _t1829 - xs1039 = append(xs1039, item1041) - cond1040 = p.matchLookaheadLiteral("(", 0) - } - constructs1042 := xs1039 + xs1040 := []*pb.Construct{} + cond1041 := p.matchLookaheadLiteral("(", 0) + for cond1041 { + _t1831 := p.parse_construct() + item1042 := _t1831 + xs1040 = append(xs1040, item1042) + cond1041 = p.matchLookaheadLiteral("(", 0) + } + constructs1043 := xs1040 p.consumeLiteral(")") - _t1830 := &pb.Script{Constructs: constructs1042} - result1044 := _t1830 - p.recordSpan(int(span_start1043), "Script") - return result1044 + _t1832 := &pb.Script{Constructs: constructs1043} + result1045 := _t1832 + p.recordSpan(int(span_start1044), "Script") + return result1045 } func (p *Parser) parse_construct() *pb.Construct { - span_start1048 := int64(p.spanStart()) - var _t1831 int64 + span_start1049 := int64(p.spanStart()) + var _t1833 int64 if p.matchLookaheadLiteral("(", 0) { - var _t1832 int64 + var _t1834 int64 if p.matchLookaheadLiteral("upsert", 1) { - _t1832 = 1 + _t1834 = 1 } else { - var _t1833 int64 + var _t1835 int64 if p.matchLookaheadLiteral("monus", 1) { - _t1833 = 1 + _t1835 = 1 } else { - var _t1834 int64 + var _t1836 int64 if p.matchLookaheadLiteral("monoid", 1) { - _t1834 = 1 + _t1836 = 1 } else { - var _t1835 int64 + var _t1837 int64 if p.matchLookaheadLiteral("loop", 1) { - _t1835 = 0 + _t1837 = 0 } else { - var _t1836 int64 + var _t1838 int64 if p.matchLookaheadLiteral("break", 1) { - _t1836 = 1 + _t1838 = 1 } else { - var _t1837 int64 + var _t1839 int64 if p.matchLookaheadLiteral("assign", 1) { - _t1837 = 1 + _t1839 = 1 } else { - _t1837 = -1 + _t1839 = -1 } - _t1836 = _t1837 + _t1838 = _t1839 } - _t1835 = _t1836 + _t1837 = _t1838 } - _t1834 = _t1835 + _t1836 = _t1837 } - _t1833 = _t1834 + _t1835 = _t1836 } - _t1832 = _t1833 + _t1834 = _t1835 } - _t1831 = _t1832 + _t1833 = _t1834 } else { - _t1831 = -1 - } - prediction1045 := _t1831 - var _t1838 *pb.Construct - if prediction1045 == 1 { - _t1839 := p.parse_instruction() - instruction1047 := _t1839 - _t1840 := &pb.Construct{} - _t1840.ConstructType = &pb.Construct_Instruction{Instruction: instruction1047} - _t1838 = _t1840 + _t1833 = -1 + } + prediction1046 := _t1833 + var _t1840 *pb.Construct + if prediction1046 == 1 { + _t1841 := p.parse_instruction() + instruction1048 := _t1841 + _t1842 := &pb.Construct{} + _t1842.ConstructType = &pb.Construct_Instruction{Instruction: instruction1048} + _t1840 = _t1842 } else { - var _t1841 *pb.Construct - if prediction1045 == 0 { - _t1842 := p.parse_loop() - loop1046 := _t1842 - _t1843 := &pb.Construct{} - _t1843.ConstructType = &pb.Construct_Loop{Loop: loop1046} - _t1841 = _t1843 + var _t1843 *pb.Construct + if prediction1046 == 0 { + _t1844 := p.parse_loop() + loop1047 := _t1844 + _t1845 := &pb.Construct{} + _t1845.ConstructType = &pb.Construct_Loop{Loop: loop1047} + _t1843 = _t1845 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in construct", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1838 = _t1841 + _t1840 = _t1843 } - result1049 := _t1838 - p.recordSpan(int(span_start1048), "Construct") - return result1049 + result1050 := _t1840 + p.recordSpan(int(span_start1049), "Construct") + return result1050 } func (p *Parser) parse_loop() *pb.Loop { - span_start1052 := int64(p.spanStart()) + span_start1053 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("loop") - _t1844 := p.parse_init() - init1050 := _t1844 - _t1845 := p.parse_script() - script1051 := _t1845 + _t1846 := p.parse_init() + init1051 := _t1846 + _t1847 := p.parse_script() + script1052 := _t1847 p.consumeLiteral(")") - _t1846 := &pb.Loop{Init: init1050, Body: script1051} - result1053 := _t1846 - p.recordSpan(int(span_start1052), "Loop") - return result1053 + _t1848 := &pb.Loop{Init: init1051, Body: script1052} + result1054 := _t1848 + p.recordSpan(int(span_start1053), "Loop") + return result1054 } func (p *Parser) parse_init() []*pb.Instruction { p.consumeLiteral("(") p.consumeLiteral("init") - xs1054 := []*pb.Instruction{} - cond1055 := p.matchLookaheadLiteral("(", 0) - for cond1055 { - _t1847 := p.parse_instruction() - item1056 := _t1847 - xs1054 = append(xs1054, item1056) - cond1055 = p.matchLookaheadLiteral("(", 0) - } - instructions1057 := xs1054 + xs1055 := []*pb.Instruction{} + cond1056 := p.matchLookaheadLiteral("(", 0) + for cond1056 { + _t1849 := p.parse_instruction() + item1057 := _t1849 + xs1055 = append(xs1055, item1057) + cond1056 = p.matchLookaheadLiteral("(", 0) + } + instructions1058 := xs1055 p.consumeLiteral(")") - return instructions1057 + return instructions1058 } func (p *Parser) parse_instruction() *pb.Instruction { - span_start1064 := int64(p.spanStart()) - var _t1848 int64 + span_start1065 := int64(p.spanStart()) + var _t1850 int64 if p.matchLookaheadLiteral("(", 0) { - var _t1849 int64 + var _t1851 int64 if p.matchLookaheadLiteral("upsert", 1) { - _t1849 = 1 + _t1851 = 1 } else { - var _t1850 int64 + var _t1852 int64 if p.matchLookaheadLiteral("monus", 1) { - _t1850 = 4 + _t1852 = 4 } else { - var _t1851 int64 + var _t1853 int64 if p.matchLookaheadLiteral("monoid", 1) { - _t1851 = 3 + _t1853 = 3 } else { - var _t1852 int64 + var _t1854 int64 if p.matchLookaheadLiteral("break", 1) { - _t1852 = 2 + _t1854 = 2 } else { - var _t1853 int64 + var _t1855 int64 if p.matchLookaheadLiteral("assign", 1) { - _t1853 = 0 + _t1855 = 0 } else { - _t1853 = -1 + _t1855 = -1 } - _t1852 = _t1853 + _t1854 = _t1855 } - _t1851 = _t1852 + _t1853 = _t1854 } - _t1850 = _t1851 + _t1852 = _t1853 } - _t1849 = _t1850 + _t1851 = _t1852 } - _t1848 = _t1849 + _t1850 = _t1851 } else { - _t1848 = -1 - } - prediction1058 := _t1848 - var _t1854 *pb.Instruction - if prediction1058 == 4 { - _t1855 := p.parse_monus_def() - monus_def1063 := _t1855 - _t1856 := &pb.Instruction{} - _t1856.InstrType = &pb.Instruction_MonusDef{MonusDef: monus_def1063} - _t1854 = _t1856 + _t1850 = -1 + } + prediction1059 := _t1850 + var _t1856 *pb.Instruction + if prediction1059 == 4 { + _t1857 := p.parse_monus_def() + monus_def1064 := _t1857 + _t1858 := &pb.Instruction{} + _t1858.InstrType = &pb.Instruction_MonusDef{MonusDef: monus_def1064} + _t1856 = _t1858 } else { - var _t1857 *pb.Instruction - if prediction1058 == 3 { - _t1858 := p.parse_monoid_def() - monoid_def1062 := _t1858 - _t1859 := &pb.Instruction{} - _t1859.InstrType = &pb.Instruction_MonoidDef{MonoidDef: monoid_def1062} - _t1857 = _t1859 + var _t1859 *pb.Instruction + if prediction1059 == 3 { + _t1860 := p.parse_monoid_def() + monoid_def1063 := _t1860 + _t1861 := &pb.Instruction{} + _t1861.InstrType = &pb.Instruction_MonoidDef{MonoidDef: monoid_def1063} + _t1859 = _t1861 } else { - var _t1860 *pb.Instruction - if prediction1058 == 2 { - _t1861 := p.parse_break() - break1061 := _t1861 - _t1862 := &pb.Instruction{} - _t1862.InstrType = &pb.Instruction_Break{Break: break1061} - _t1860 = _t1862 + var _t1862 *pb.Instruction + if prediction1059 == 2 { + _t1863 := p.parse_break() + break1062 := _t1863 + _t1864 := &pb.Instruction{} + _t1864.InstrType = &pb.Instruction_Break{Break: break1062} + _t1862 = _t1864 } else { - var _t1863 *pb.Instruction - if prediction1058 == 1 { - _t1864 := p.parse_upsert() - upsert1060 := _t1864 - _t1865 := &pb.Instruction{} - _t1865.InstrType = &pb.Instruction_Upsert{Upsert: upsert1060} - _t1863 = _t1865 + var _t1865 *pb.Instruction + if prediction1059 == 1 { + _t1866 := p.parse_upsert() + upsert1061 := _t1866 + _t1867 := &pb.Instruction{} + _t1867.InstrType = &pb.Instruction_Upsert{Upsert: upsert1061} + _t1865 = _t1867 } else { - var _t1866 *pb.Instruction - if prediction1058 == 0 { - _t1867 := p.parse_assign() - assign1059 := _t1867 - _t1868 := &pb.Instruction{} - _t1868.InstrType = &pb.Instruction_Assign{Assign: assign1059} - _t1866 = _t1868 + var _t1868 *pb.Instruction + if prediction1059 == 0 { + _t1869 := p.parse_assign() + assign1060 := _t1869 + _t1870 := &pb.Instruction{} + _t1870.InstrType = &pb.Instruction_Assign{Assign: assign1060} + _t1868 = _t1870 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in instruction", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1863 = _t1866 + _t1865 = _t1868 } - _t1860 = _t1863 + _t1862 = _t1865 } - _t1857 = _t1860 + _t1859 = _t1862 } - _t1854 = _t1857 + _t1856 = _t1859 } - result1065 := _t1854 - p.recordSpan(int(span_start1064), "Instruction") - return result1065 + result1066 := _t1856 + p.recordSpan(int(span_start1065), "Instruction") + return result1066 } func (p *Parser) parse_assign() *pb.Assign { - span_start1069 := int64(p.spanStart()) + span_start1070 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("assign") - _t1869 := p.parse_relation_id() - relation_id1066 := _t1869 - _t1870 := p.parse_abstraction() - abstraction1067 := _t1870 - var _t1871 []*pb.Attribute + _t1871 := p.parse_relation_id() + relation_id1067 := _t1871 + _t1872 := p.parse_abstraction() + abstraction1068 := _t1872 + var _t1873 []*pb.Attribute if p.matchLookaheadLiteral("(", 0) { - _t1872 := p.parse_attrs() - _t1871 = _t1872 + _t1874 := p.parse_attrs() + _t1873 = _t1874 } - attrs1068 := _t1871 + attrs1069 := _t1873 p.consumeLiteral(")") - _t1873 := attrs1068 - if attrs1068 == nil { - _t1873 = []*pb.Attribute{} + _t1875 := attrs1069 + if attrs1069 == nil { + _t1875 = []*pb.Attribute{} } - _t1874 := &pb.Assign{Name: relation_id1066, Body: abstraction1067, Attrs: _t1873} - result1070 := _t1874 - p.recordSpan(int(span_start1069), "Assign") - return result1070 + _t1876 := &pb.Assign{Name: relation_id1067, Body: abstraction1068, Attrs: _t1875} + result1071 := _t1876 + p.recordSpan(int(span_start1070), "Assign") + return result1071 } func (p *Parser) parse_upsert() *pb.Upsert { - span_start1074 := int64(p.spanStart()) + span_start1075 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("upsert") - _t1875 := p.parse_relation_id() - relation_id1071 := _t1875 - _t1876 := p.parse_abstraction_with_arity() - abstraction_with_arity1072 := _t1876 - var _t1877 []*pb.Attribute + _t1877 := p.parse_relation_id() + relation_id1072 := _t1877 + _t1878 := p.parse_abstraction_with_arity() + abstraction_with_arity1073 := _t1878 + var _t1879 []*pb.Attribute if p.matchLookaheadLiteral("(", 0) { - _t1878 := p.parse_attrs() - _t1877 = _t1878 + _t1880 := p.parse_attrs() + _t1879 = _t1880 } - attrs1073 := _t1877 + attrs1074 := _t1879 p.consumeLiteral(")") - _t1879 := attrs1073 - if attrs1073 == nil { - _t1879 = []*pb.Attribute{} + _t1881 := attrs1074 + if attrs1074 == nil { + _t1881 = []*pb.Attribute{} } - _t1880 := &pb.Upsert{Name: relation_id1071, Body: abstraction_with_arity1072[0].(*pb.Abstraction), Attrs: _t1879, ValueArity: abstraction_with_arity1072[1].(int64)} - result1075 := _t1880 - p.recordSpan(int(span_start1074), "Upsert") - return result1075 + _t1882 := &pb.Upsert{Name: relation_id1072, Body: abstraction_with_arity1073[0].(*pb.Abstraction), Attrs: _t1881, ValueArity: abstraction_with_arity1073[1].(int64)} + result1076 := _t1882 + p.recordSpan(int(span_start1075), "Upsert") + return result1076 } func (p *Parser) parse_abstraction_with_arity() []interface{} { p.consumeLiteral("(") - _t1881 := p.parse_bindings() - bindings1076 := _t1881 - _t1882 := p.parse_formula() - formula1077 := _t1882 + _t1883 := p.parse_bindings() + bindings1077 := _t1883 + _t1884 := p.parse_formula() + formula1078 := _t1884 p.consumeLiteral(")") - _t1883 := &pb.Abstraction{Vars: listConcat(bindings1076[0].([]*pb.Binding), bindings1076[1].([]*pb.Binding)), Value: formula1077} - return []interface{}{_t1883, int64(len(bindings1076[1].([]*pb.Binding)))} + _t1885 := &pb.Abstraction{Vars: listConcat(bindings1077[0].([]*pb.Binding), bindings1077[1].([]*pb.Binding)), Value: formula1078} + return []interface{}{_t1885, int64(len(bindings1077[1].([]*pb.Binding)))} } func (p *Parser) parse_break() *pb.Break { - span_start1081 := int64(p.spanStart()) + span_start1082 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("break") - _t1884 := p.parse_relation_id() - relation_id1078 := _t1884 - _t1885 := p.parse_abstraction() - abstraction1079 := _t1885 - var _t1886 []*pb.Attribute + _t1886 := p.parse_relation_id() + relation_id1079 := _t1886 + _t1887 := p.parse_abstraction() + abstraction1080 := _t1887 + var _t1888 []*pb.Attribute if p.matchLookaheadLiteral("(", 0) { - _t1887 := p.parse_attrs() - _t1886 = _t1887 + _t1889 := p.parse_attrs() + _t1888 = _t1889 } - attrs1080 := _t1886 + attrs1081 := _t1888 p.consumeLiteral(")") - _t1888 := attrs1080 - if attrs1080 == nil { - _t1888 = []*pb.Attribute{} + _t1890 := attrs1081 + if attrs1081 == nil { + _t1890 = []*pb.Attribute{} } - _t1889 := &pb.Break{Name: relation_id1078, Body: abstraction1079, Attrs: _t1888} - result1082 := _t1889 - p.recordSpan(int(span_start1081), "Break") - return result1082 + _t1891 := &pb.Break{Name: relation_id1079, Body: abstraction1080, Attrs: _t1890} + result1083 := _t1891 + p.recordSpan(int(span_start1082), "Break") + return result1083 } func (p *Parser) parse_monoid_def() *pb.MonoidDef { - span_start1087 := int64(p.spanStart()) + span_start1088 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("monoid") - _t1890 := p.parse_monoid() - monoid1083 := _t1890 - _t1891 := p.parse_relation_id() - relation_id1084 := _t1891 - _t1892 := p.parse_abstraction_with_arity() - abstraction_with_arity1085 := _t1892 - var _t1893 []*pb.Attribute + _t1892 := p.parse_monoid() + monoid1084 := _t1892 + _t1893 := p.parse_relation_id() + relation_id1085 := _t1893 + _t1894 := p.parse_abstraction_with_arity() + abstraction_with_arity1086 := _t1894 + var _t1895 []*pb.Attribute if p.matchLookaheadLiteral("(", 0) { - _t1894 := p.parse_attrs() - _t1893 = _t1894 + _t1896 := p.parse_attrs() + _t1895 = _t1896 } - attrs1086 := _t1893 + attrs1087 := _t1895 p.consumeLiteral(")") - _t1895 := attrs1086 - if attrs1086 == nil { - _t1895 = []*pb.Attribute{} + _t1897 := attrs1087 + if attrs1087 == nil { + _t1897 = []*pb.Attribute{} } - _t1896 := &pb.MonoidDef{Monoid: monoid1083, Name: relation_id1084, Body: abstraction_with_arity1085[0].(*pb.Abstraction), Attrs: _t1895, ValueArity: abstraction_with_arity1085[1].(int64)} - result1088 := _t1896 - p.recordSpan(int(span_start1087), "MonoidDef") - return result1088 + _t1898 := &pb.MonoidDef{Monoid: monoid1084, Name: relation_id1085, Body: abstraction_with_arity1086[0].(*pb.Abstraction), Attrs: _t1897, ValueArity: abstraction_with_arity1086[1].(int64)} + result1089 := _t1898 + p.recordSpan(int(span_start1088), "MonoidDef") + return result1089 } func (p *Parser) parse_monoid() *pb.Monoid { - span_start1094 := int64(p.spanStart()) - var _t1897 int64 + span_start1095 := int64(p.spanStart()) + var _t1899 int64 if p.matchLookaheadLiteral("(", 0) { - var _t1898 int64 + var _t1900 int64 if p.matchLookaheadLiteral("sum", 1) { - _t1898 = 3 + _t1900 = 3 } else { - var _t1899 int64 + var _t1901 int64 if p.matchLookaheadLiteral("or", 1) { - _t1899 = 0 + _t1901 = 0 } else { - var _t1900 int64 + var _t1902 int64 if p.matchLookaheadLiteral("min", 1) { - _t1900 = 1 + _t1902 = 1 } else { - var _t1901 int64 + var _t1903 int64 if p.matchLookaheadLiteral("max", 1) { - _t1901 = 2 + _t1903 = 2 } else { - _t1901 = -1 + _t1903 = -1 } - _t1900 = _t1901 + _t1902 = _t1903 } - _t1899 = _t1900 + _t1901 = _t1902 } - _t1898 = _t1899 + _t1900 = _t1901 } - _t1897 = _t1898 + _t1899 = _t1900 } else { - _t1897 = -1 - } - prediction1089 := _t1897 - var _t1902 *pb.Monoid - if prediction1089 == 3 { - _t1903 := p.parse_sum_monoid() - sum_monoid1093 := _t1903 - _t1904 := &pb.Monoid{} - _t1904.Value = &pb.Monoid_SumMonoid{SumMonoid: sum_monoid1093} - _t1902 = _t1904 + _t1899 = -1 + } + prediction1090 := _t1899 + var _t1904 *pb.Monoid + if prediction1090 == 3 { + _t1905 := p.parse_sum_monoid() + sum_monoid1094 := _t1905 + _t1906 := &pb.Monoid{} + _t1906.Value = &pb.Monoid_SumMonoid{SumMonoid: sum_monoid1094} + _t1904 = _t1906 } else { - var _t1905 *pb.Monoid - if prediction1089 == 2 { - _t1906 := p.parse_max_monoid() - max_monoid1092 := _t1906 - _t1907 := &pb.Monoid{} - _t1907.Value = &pb.Monoid_MaxMonoid{MaxMonoid: max_monoid1092} - _t1905 = _t1907 + var _t1907 *pb.Monoid + if prediction1090 == 2 { + _t1908 := p.parse_max_monoid() + max_monoid1093 := _t1908 + _t1909 := &pb.Monoid{} + _t1909.Value = &pb.Monoid_MaxMonoid{MaxMonoid: max_monoid1093} + _t1907 = _t1909 } else { - var _t1908 *pb.Monoid - if prediction1089 == 1 { - _t1909 := p.parse_min_monoid() - min_monoid1091 := _t1909 - _t1910 := &pb.Monoid{} - _t1910.Value = &pb.Monoid_MinMonoid{MinMonoid: min_monoid1091} - _t1908 = _t1910 + var _t1910 *pb.Monoid + if prediction1090 == 1 { + _t1911 := p.parse_min_monoid() + min_monoid1092 := _t1911 + _t1912 := &pb.Monoid{} + _t1912.Value = &pb.Monoid_MinMonoid{MinMonoid: min_monoid1092} + _t1910 = _t1912 } else { - var _t1911 *pb.Monoid - if prediction1089 == 0 { - _t1912 := p.parse_or_monoid() - or_monoid1090 := _t1912 - _t1913 := &pb.Monoid{} - _t1913.Value = &pb.Monoid_OrMonoid{OrMonoid: or_monoid1090} - _t1911 = _t1913 + var _t1913 *pb.Monoid + if prediction1090 == 0 { + _t1914 := p.parse_or_monoid() + or_monoid1091 := _t1914 + _t1915 := &pb.Monoid{} + _t1915.Value = &pb.Monoid_OrMonoid{OrMonoid: or_monoid1091} + _t1913 = _t1915 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in monoid", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1908 = _t1911 + _t1910 = _t1913 } - _t1905 = _t1908 + _t1907 = _t1910 } - _t1902 = _t1905 + _t1904 = _t1907 } - result1095 := _t1902 - p.recordSpan(int(span_start1094), "Monoid") - return result1095 + result1096 := _t1904 + p.recordSpan(int(span_start1095), "Monoid") + return result1096 } func (p *Parser) parse_or_monoid() *pb.OrMonoid { - span_start1096 := int64(p.spanStart()) + span_start1097 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("or") p.consumeLiteral(")") - _t1914 := &pb.OrMonoid{} - result1097 := _t1914 - p.recordSpan(int(span_start1096), "OrMonoid") - return result1097 + _t1916 := &pb.OrMonoid{} + result1098 := _t1916 + p.recordSpan(int(span_start1097), "OrMonoid") + return result1098 } func (p *Parser) parse_min_monoid() *pb.MinMonoid { - span_start1099 := int64(p.spanStart()) + span_start1100 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("min") - _t1915 := p.parse_type() - type1098 := _t1915 + _t1917 := p.parse_type() + type1099 := _t1917 p.consumeLiteral(")") - _t1916 := &pb.MinMonoid{Type: type1098} - result1100 := _t1916 - p.recordSpan(int(span_start1099), "MinMonoid") - return result1100 + _t1918 := &pb.MinMonoid{Type: type1099} + result1101 := _t1918 + p.recordSpan(int(span_start1100), "MinMonoid") + return result1101 } func (p *Parser) parse_max_monoid() *pb.MaxMonoid { - span_start1102 := int64(p.spanStart()) + span_start1103 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("max") - _t1917 := p.parse_type() - type1101 := _t1917 + _t1919 := p.parse_type() + type1102 := _t1919 p.consumeLiteral(")") - _t1918 := &pb.MaxMonoid{Type: type1101} - result1103 := _t1918 - p.recordSpan(int(span_start1102), "MaxMonoid") - return result1103 + _t1920 := &pb.MaxMonoid{Type: type1102} + result1104 := _t1920 + p.recordSpan(int(span_start1103), "MaxMonoid") + return result1104 } func (p *Parser) parse_sum_monoid() *pb.SumMonoid { - span_start1105 := int64(p.spanStart()) + span_start1106 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("sum") - _t1919 := p.parse_type() - type1104 := _t1919 + _t1921 := p.parse_type() + type1105 := _t1921 p.consumeLiteral(")") - _t1920 := &pb.SumMonoid{Type: type1104} - result1106 := _t1920 - p.recordSpan(int(span_start1105), "SumMonoid") - return result1106 + _t1922 := &pb.SumMonoid{Type: type1105} + result1107 := _t1922 + p.recordSpan(int(span_start1106), "SumMonoid") + return result1107 } func (p *Parser) parse_monus_def() *pb.MonusDef { - span_start1111 := int64(p.spanStart()) + span_start1112 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("monus") - _t1921 := p.parse_monoid() - monoid1107 := _t1921 - _t1922 := p.parse_relation_id() - relation_id1108 := _t1922 - _t1923 := p.parse_abstraction_with_arity() - abstraction_with_arity1109 := _t1923 - var _t1924 []*pb.Attribute + _t1923 := p.parse_monoid() + monoid1108 := _t1923 + _t1924 := p.parse_relation_id() + relation_id1109 := _t1924 + _t1925 := p.parse_abstraction_with_arity() + abstraction_with_arity1110 := _t1925 + var _t1926 []*pb.Attribute if p.matchLookaheadLiteral("(", 0) { - _t1925 := p.parse_attrs() - _t1924 = _t1925 + _t1927 := p.parse_attrs() + _t1926 = _t1927 } - attrs1110 := _t1924 + attrs1111 := _t1926 p.consumeLiteral(")") - _t1926 := attrs1110 - if attrs1110 == nil { - _t1926 = []*pb.Attribute{} + _t1928 := attrs1111 + if attrs1111 == nil { + _t1928 = []*pb.Attribute{} } - _t1927 := &pb.MonusDef{Monoid: monoid1107, Name: relation_id1108, Body: abstraction_with_arity1109[0].(*pb.Abstraction), Attrs: _t1926, ValueArity: abstraction_with_arity1109[1].(int64)} - result1112 := _t1927 - p.recordSpan(int(span_start1111), "MonusDef") - return result1112 + _t1929 := &pb.MonusDef{Monoid: monoid1108, Name: relation_id1109, Body: abstraction_with_arity1110[0].(*pb.Abstraction), Attrs: _t1928, ValueArity: abstraction_with_arity1110[1].(int64)} + result1113 := _t1929 + p.recordSpan(int(span_start1112), "MonusDef") + return result1113 } func (p *Parser) parse_constraint() *pb.Constraint { - span_start1117 := int64(p.spanStart()) + span_start1118 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("functional_dependency") - _t1928 := p.parse_relation_id() - relation_id1113 := _t1928 - _t1929 := p.parse_abstraction() - abstraction1114 := _t1929 - _t1930 := p.parse_functional_dependency_keys() - functional_dependency_keys1115 := _t1930 - _t1931 := p.parse_functional_dependency_values() - functional_dependency_values1116 := _t1931 + _t1930 := p.parse_relation_id() + relation_id1114 := _t1930 + _t1931 := p.parse_abstraction() + abstraction1115 := _t1931 + _t1932 := p.parse_functional_dependency_keys() + functional_dependency_keys1116 := _t1932 + _t1933 := p.parse_functional_dependency_values() + functional_dependency_values1117 := _t1933 p.consumeLiteral(")") - _t1932 := &pb.FunctionalDependency{Guard: abstraction1114, Keys: functional_dependency_keys1115, Values: functional_dependency_values1116} - _t1933 := &pb.Constraint{Name: relation_id1113} - _t1933.ConstraintType = &pb.Constraint_FunctionalDependency{FunctionalDependency: _t1932} - result1118 := _t1933 - p.recordSpan(int(span_start1117), "Constraint") - return result1118 + _t1934 := &pb.FunctionalDependency{Guard: abstraction1115, Keys: functional_dependency_keys1116, Values: functional_dependency_values1117} + _t1935 := &pb.Constraint{Name: relation_id1114} + _t1935.ConstraintType = &pb.Constraint_FunctionalDependency{FunctionalDependency: _t1934} + result1119 := _t1935 + p.recordSpan(int(span_start1118), "Constraint") + return result1119 } func (p *Parser) parse_functional_dependency_keys() []*pb.Var { p.consumeLiteral("(") p.consumeLiteral("keys") - xs1119 := []*pb.Var{} - cond1120 := p.matchLookaheadTerminal("SYMBOL", 0) - for cond1120 { - _t1934 := p.parse_var() - item1121 := _t1934 - xs1119 = append(xs1119, item1121) - cond1120 = p.matchLookaheadTerminal("SYMBOL", 0) - } - vars1122 := xs1119 + xs1120 := []*pb.Var{} + cond1121 := p.matchLookaheadTerminal("SYMBOL", 0) + for cond1121 { + _t1936 := p.parse_var() + item1122 := _t1936 + xs1120 = append(xs1120, item1122) + cond1121 = p.matchLookaheadTerminal("SYMBOL", 0) + } + vars1123 := xs1120 p.consumeLiteral(")") - return vars1122 + return vars1123 } func (p *Parser) parse_functional_dependency_values() []*pb.Var { p.consumeLiteral("(") p.consumeLiteral("values") - xs1123 := []*pb.Var{} - cond1124 := p.matchLookaheadTerminal("SYMBOL", 0) - for cond1124 { - _t1935 := p.parse_var() - item1125 := _t1935 - xs1123 = append(xs1123, item1125) - cond1124 = p.matchLookaheadTerminal("SYMBOL", 0) - } - vars1126 := xs1123 + xs1124 := []*pb.Var{} + cond1125 := p.matchLookaheadTerminal("SYMBOL", 0) + for cond1125 { + _t1937 := p.parse_var() + item1126 := _t1937 + xs1124 = append(xs1124, item1126) + cond1125 = p.matchLookaheadTerminal("SYMBOL", 0) + } + vars1127 := xs1124 p.consumeLiteral(")") - return vars1126 + return vars1127 } func (p *Parser) parse_data() *pb.Data { - span_start1132 := int64(p.spanStart()) - var _t1936 int64 + span_start1133 := int64(p.spanStart()) + var _t1938 int64 if p.matchLookaheadLiteral("(", 0) { - var _t1937 int64 + var _t1939 int64 if p.matchLookaheadLiteral("iceberg_data", 1) { - _t1937 = 3 + _t1939 = 3 } else { - var _t1938 int64 + var _t1940 int64 if p.matchLookaheadLiteral("edb", 1) { - _t1938 = 0 + _t1940 = 0 } else { - var _t1939 int64 + var _t1941 int64 if p.matchLookaheadLiteral("csv_data", 1) { - _t1939 = 2 + _t1941 = 2 } else { - var _t1940 int64 + var _t1942 int64 if p.matchLookaheadLiteral("betree_relation", 1) { - _t1940 = 1 + _t1942 = 1 } else { - _t1940 = -1 + _t1942 = -1 } - _t1939 = _t1940 + _t1941 = _t1942 } - _t1938 = _t1939 + _t1940 = _t1941 } - _t1937 = _t1938 + _t1939 = _t1940 } - _t1936 = _t1937 + _t1938 = _t1939 } else { - _t1936 = -1 - } - prediction1127 := _t1936 - var _t1941 *pb.Data - if prediction1127 == 3 { - _t1942 := p.parse_iceberg_data() - iceberg_data1131 := _t1942 - _t1943 := &pb.Data{} - _t1943.DataType = &pb.Data_IcebergData{IcebergData: iceberg_data1131} - _t1941 = _t1943 + _t1938 = -1 + } + prediction1128 := _t1938 + var _t1943 *pb.Data + if prediction1128 == 3 { + _t1944 := p.parse_iceberg_data() + iceberg_data1132 := _t1944 + _t1945 := &pb.Data{} + _t1945.DataType = &pb.Data_IcebergData{IcebergData: iceberg_data1132} + _t1943 = _t1945 } else { - var _t1944 *pb.Data - if prediction1127 == 2 { - _t1945 := p.parse_csv_data() - csv_data1130 := _t1945 - _t1946 := &pb.Data{} - _t1946.DataType = &pb.Data_CsvData{CsvData: csv_data1130} - _t1944 = _t1946 + var _t1946 *pb.Data + if prediction1128 == 2 { + _t1947 := p.parse_csv_data() + csv_data1131 := _t1947 + _t1948 := &pb.Data{} + _t1948.DataType = &pb.Data_CsvData{CsvData: csv_data1131} + _t1946 = _t1948 } else { - var _t1947 *pb.Data - if prediction1127 == 1 { - _t1948 := p.parse_betree_relation() - betree_relation1129 := _t1948 - _t1949 := &pb.Data{} - _t1949.DataType = &pb.Data_BetreeRelation{BetreeRelation: betree_relation1129} - _t1947 = _t1949 + var _t1949 *pb.Data + if prediction1128 == 1 { + _t1950 := p.parse_betree_relation() + betree_relation1130 := _t1950 + _t1951 := &pb.Data{} + _t1951.DataType = &pb.Data_BetreeRelation{BetreeRelation: betree_relation1130} + _t1949 = _t1951 } else { - var _t1950 *pb.Data - if prediction1127 == 0 { - _t1951 := p.parse_edb() - edb1128 := _t1951 - _t1952 := &pb.Data{} - _t1952.DataType = &pb.Data_Edb{Edb: edb1128} - _t1950 = _t1952 + var _t1952 *pb.Data + if prediction1128 == 0 { + _t1953 := p.parse_edb() + edb1129 := _t1953 + _t1954 := &pb.Data{} + _t1954.DataType = &pb.Data_Edb{Edb: edb1129} + _t1952 = _t1954 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in data", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1947 = _t1950 + _t1949 = _t1952 } - _t1944 = _t1947 + _t1946 = _t1949 } - _t1941 = _t1944 + _t1943 = _t1946 } - result1133 := _t1941 - p.recordSpan(int(span_start1132), "Data") - return result1133 + result1134 := _t1943 + p.recordSpan(int(span_start1133), "Data") + return result1134 } func (p *Parser) parse_edb() *pb.EDB { - span_start1137 := int64(p.spanStart()) + span_start1138 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("edb") - _t1953 := p.parse_relation_id() - relation_id1134 := _t1953 - _t1954 := p.parse_edb_path() - edb_path1135 := _t1954 - _t1955 := p.parse_edb_types() - edb_types1136 := _t1955 + _t1955 := p.parse_relation_id() + relation_id1135 := _t1955 + _t1956 := p.parse_edb_path() + edb_path1136 := _t1956 + _t1957 := p.parse_edb_types() + edb_types1137 := _t1957 p.consumeLiteral(")") - _t1956 := &pb.EDB{TargetId: relation_id1134, Path: edb_path1135, Types: edb_types1136} - result1138 := _t1956 - p.recordSpan(int(span_start1137), "EDB") - return result1138 + _t1958 := &pb.EDB{TargetId: relation_id1135, Path: edb_path1136, Types: edb_types1137} + result1139 := _t1958 + p.recordSpan(int(span_start1138), "EDB") + return result1139 } func (p *Parser) parse_edb_path() []string { p.consumeLiteral("[") - xs1139 := []string{} - cond1140 := p.matchLookaheadTerminal("STRING", 0) - for cond1140 { - item1141 := p.consumeTerminal("STRING").Value.str - xs1139 = append(xs1139, item1141) - cond1140 = p.matchLookaheadTerminal("STRING", 0) - } - strings1142 := xs1139 + xs1140 := []string{} + cond1141 := p.matchLookaheadTerminal("STRING", 0) + for cond1141 { + item1142 := p.consumeTerminal("STRING").Value.str + xs1140 = append(xs1140, item1142) + cond1141 = p.matchLookaheadTerminal("STRING", 0) + } + strings1143 := xs1140 p.consumeLiteral("]") - return strings1142 + return strings1143 } func (p *Parser) parse_edb_types() []*pb.Type { p.consumeLiteral("[") - xs1143 := []*pb.Type{} - cond1144 := (((((((((((((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 cond1144 { - _t1957 := p.parse_type() - item1145 := _t1957 - xs1143 = append(xs1143, item1145) - cond1144 = (((((((((((((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)) - } - types1146 := xs1143 + xs1144 := []*pb.Type{} + cond1145 := (((((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("BOOLEAN", 0)) || p.matchLookaheadLiteral("DATE", 0)) || p.matchLookaheadLiteral("DATETIME", 0)) || p.matchLookaheadLiteral("FLOAT", 0)) || p.matchLookaheadLiteral("FLOAT32", 0)) || p.matchLookaheadLiteral("INT", 0)) || p.matchLookaheadLiteral("INT128", 0)) || p.matchLookaheadLiteral("INT32", 0)) || p.matchLookaheadLiteral("MISSING", 0)) || p.matchLookaheadLiteral("STRING", 0)) || p.matchLookaheadLiteral("UINT128", 0)) || p.matchLookaheadLiteral("UINT32", 0)) || p.matchLookaheadLiteral("UNKNOWN", 0)) + for cond1145 { + _t1959 := p.parse_type() + item1146 := _t1959 + xs1144 = append(xs1144, item1146) + cond1145 = (((((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("BOOLEAN", 0)) || p.matchLookaheadLiteral("DATE", 0)) || p.matchLookaheadLiteral("DATETIME", 0)) || p.matchLookaheadLiteral("FLOAT", 0)) || p.matchLookaheadLiteral("FLOAT32", 0)) || p.matchLookaheadLiteral("INT", 0)) || p.matchLookaheadLiteral("INT128", 0)) || p.matchLookaheadLiteral("INT32", 0)) || p.matchLookaheadLiteral("MISSING", 0)) || p.matchLookaheadLiteral("STRING", 0)) || p.matchLookaheadLiteral("UINT128", 0)) || p.matchLookaheadLiteral("UINT32", 0)) || p.matchLookaheadLiteral("UNKNOWN", 0)) + } + types1147 := xs1144 p.consumeLiteral("]") - return types1146 + return types1147 } func (p *Parser) parse_betree_relation() *pb.BeTreeRelation { - span_start1149 := int64(p.spanStart()) + span_start1150 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("betree_relation") - _t1958 := p.parse_relation_id() - relation_id1147 := _t1958 - _t1959 := p.parse_betree_info() - betree_info1148 := _t1959 + _t1960 := p.parse_relation_id() + relation_id1148 := _t1960 + _t1961 := p.parse_betree_info() + betree_info1149 := _t1961 p.consumeLiteral(")") - _t1960 := &pb.BeTreeRelation{Name: relation_id1147, RelationInfo: betree_info1148} - result1150 := _t1960 - p.recordSpan(int(span_start1149), "BeTreeRelation") - return result1150 + _t1962 := &pb.BeTreeRelation{Name: relation_id1148, RelationInfo: betree_info1149} + result1151 := _t1962 + p.recordSpan(int(span_start1150), "BeTreeRelation") + return result1151 } func (p *Parser) parse_betree_info() *pb.BeTreeInfo { - span_start1154 := int64(p.spanStart()) + span_start1155 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("betree_info") - _t1961 := p.parse_betree_info_key_types() - betree_info_key_types1151 := _t1961 - _t1962 := p.parse_betree_info_value_types() - betree_info_value_types1152 := _t1962 - _t1963 := p.parse_config_dict() - config_dict1153 := _t1963 + _t1963 := p.parse_betree_info_key_types() + betree_info_key_types1152 := _t1963 + _t1964 := p.parse_betree_info_value_types() + betree_info_value_types1153 := _t1964 + _t1965 := p.parse_config_dict() + config_dict1154 := _t1965 p.consumeLiteral(")") - _t1964 := p.construct_betree_info(betree_info_key_types1151, betree_info_value_types1152, config_dict1153) - result1155 := _t1964 - p.recordSpan(int(span_start1154), "BeTreeInfo") - return result1155 + _t1966 := p.construct_betree_info(betree_info_key_types1152, betree_info_value_types1153, config_dict1154) + result1156 := _t1966 + p.recordSpan(int(span_start1155), "BeTreeInfo") + return result1156 } func (p *Parser) parse_betree_info_key_types() []*pb.Type { p.consumeLiteral("(") p.consumeLiteral("key_types") - xs1156 := []*pb.Type{} - cond1157 := (((((((((((((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 cond1157 { - _t1965 := p.parse_type() - item1158 := _t1965 - xs1156 = append(xs1156, item1158) - cond1157 = (((((((((((((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)) - } - types1159 := xs1156 + xs1157 := []*pb.Type{} + cond1158 := (((((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("BOOLEAN", 0)) || p.matchLookaheadLiteral("DATE", 0)) || p.matchLookaheadLiteral("DATETIME", 0)) || p.matchLookaheadLiteral("FLOAT", 0)) || p.matchLookaheadLiteral("FLOAT32", 0)) || p.matchLookaheadLiteral("INT", 0)) || p.matchLookaheadLiteral("INT128", 0)) || p.matchLookaheadLiteral("INT32", 0)) || p.matchLookaheadLiteral("MISSING", 0)) || p.matchLookaheadLiteral("STRING", 0)) || p.matchLookaheadLiteral("UINT128", 0)) || p.matchLookaheadLiteral("UINT32", 0)) || p.matchLookaheadLiteral("UNKNOWN", 0)) + for cond1158 { + _t1967 := p.parse_type() + item1159 := _t1967 + xs1157 = append(xs1157, item1159) + cond1158 = (((((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("BOOLEAN", 0)) || p.matchLookaheadLiteral("DATE", 0)) || p.matchLookaheadLiteral("DATETIME", 0)) || p.matchLookaheadLiteral("FLOAT", 0)) || p.matchLookaheadLiteral("FLOAT32", 0)) || p.matchLookaheadLiteral("INT", 0)) || p.matchLookaheadLiteral("INT128", 0)) || p.matchLookaheadLiteral("INT32", 0)) || p.matchLookaheadLiteral("MISSING", 0)) || p.matchLookaheadLiteral("STRING", 0)) || p.matchLookaheadLiteral("UINT128", 0)) || p.matchLookaheadLiteral("UINT32", 0)) || p.matchLookaheadLiteral("UNKNOWN", 0)) + } + types1160 := xs1157 p.consumeLiteral(")") - return types1159 + return types1160 } func (p *Parser) parse_betree_info_value_types() []*pb.Type { p.consumeLiteral("(") p.consumeLiteral("value_types") - xs1160 := []*pb.Type{} - cond1161 := (((((((((((((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 cond1161 { - _t1966 := p.parse_type() - item1162 := _t1966 - xs1160 = append(xs1160, item1162) - cond1161 = (((((((((((((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)) - } - types1163 := xs1160 + xs1161 := []*pb.Type{} + cond1162 := (((((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("BOOLEAN", 0)) || p.matchLookaheadLiteral("DATE", 0)) || p.matchLookaheadLiteral("DATETIME", 0)) || p.matchLookaheadLiteral("FLOAT", 0)) || p.matchLookaheadLiteral("FLOAT32", 0)) || p.matchLookaheadLiteral("INT", 0)) || p.matchLookaheadLiteral("INT128", 0)) || p.matchLookaheadLiteral("INT32", 0)) || p.matchLookaheadLiteral("MISSING", 0)) || p.matchLookaheadLiteral("STRING", 0)) || p.matchLookaheadLiteral("UINT128", 0)) || p.matchLookaheadLiteral("UINT32", 0)) || p.matchLookaheadLiteral("UNKNOWN", 0)) + for cond1162 { + _t1968 := p.parse_type() + item1163 := _t1968 + xs1161 = append(xs1161, item1163) + cond1162 = (((((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("BOOLEAN", 0)) || p.matchLookaheadLiteral("DATE", 0)) || p.matchLookaheadLiteral("DATETIME", 0)) || p.matchLookaheadLiteral("FLOAT", 0)) || p.matchLookaheadLiteral("FLOAT32", 0)) || p.matchLookaheadLiteral("INT", 0)) || p.matchLookaheadLiteral("INT128", 0)) || p.matchLookaheadLiteral("INT32", 0)) || p.matchLookaheadLiteral("MISSING", 0)) || p.matchLookaheadLiteral("STRING", 0)) || p.matchLookaheadLiteral("UINT128", 0)) || p.matchLookaheadLiteral("UINT32", 0)) || p.matchLookaheadLiteral("UNKNOWN", 0)) + } + types1164 := xs1161 p.consumeLiteral(")") - return types1163 + return types1164 } func (p *Parser) parse_csv_data() *pb.CSVData { - span_start1168 := int64(p.spanStart()) + span_start1169 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("csv_data") - _t1967 := p.parse_csvlocator() - csvlocator1164 := _t1967 - _t1968 := p.parse_csv_config() - csv_config1165 := _t1968 - _t1969 := p.parse_gnf_columns() - gnf_columns1166 := _t1969 - _t1970 := p.parse_csv_asof() - csv_asof1167 := _t1970 + _t1969 := p.parse_csvlocator() + csvlocator1165 := _t1969 + _t1970 := p.parse_csv_config() + csv_config1166 := _t1970 + _t1971 := p.parse_gnf_columns() + gnf_columns1167 := _t1971 + _t1972 := p.parse_csv_asof() + csv_asof1168 := _t1972 p.consumeLiteral(")") - _t1971 := &pb.CSVData{Locator: csvlocator1164, Config: csv_config1165, Columns: gnf_columns1166, Asof: csv_asof1167} - result1169 := _t1971 - p.recordSpan(int(span_start1168), "CSVData") - return result1169 + _t1973 := &pb.CSVData{Locator: csvlocator1165, Config: csv_config1166, Columns: gnf_columns1167, Asof: csv_asof1168} + result1170 := _t1973 + p.recordSpan(int(span_start1169), "CSVData") + return result1170 } func (p *Parser) parse_csvlocator() *pb.CSVLocator { - span_start1172 := int64(p.spanStart()) + span_start1173 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("csv_locator") - var _t1972 []string + var _t1974 []string if (p.matchLookaheadLiteral("(", 0) && p.matchLookaheadLiteral("paths", 1)) { - _t1973 := p.parse_csv_locator_paths() - _t1972 = _t1973 + _t1975 := p.parse_csv_locator_paths() + _t1974 = _t1975 } - csv_locator_paths1170 := _t1972 - var _t1974 *string + csv_locator_paths1171 := _t1974 + var _t1976 *string if p.matchLookaheadLiteral("(", 0) { - _t1975 := p.parse_csv_locator_inline_data() - _t1974 = ptr(_t1975) + _t1977 := p.parse_csv_locator_inline_data() + _t1976 = ptr(_t1977) } - csv_locator_inline_data1171 := _t1974 + csv_locator_inline_data1172 := _t1976 p.consumeLiteral(")") - _t1976 := csv_locator_paths1170 - if csv_locator_paths1170 == nil { - _t1976 = []string{} + _t1978 := csv_locator_paths1171 + if csv_locator_paths1171 == nil { + _t1978 = []string{} } - _t1977 := &pb.CSVLocator{Paths: _t1976, InlineData: []byte(deref(csv_locator_inline_data1171, ""))} - result1173 := _t1977 - p.recordSpan(int(span_start1172), "CSVLocator") - return result1173 + _t1979 := &pb.CSVLocator{Paths: _t1978, InlineData: []byte(deref(csv_locator_inline_data1172, ""))} + result1174 := _t1979 + p.recordSpan(int(span_start1173), "CSVLocator") + return result1174 } func (p *Parser) parse_csv_locator_paths() []string { p.consumeLiteral("(") p.consumeLiteral("paths") - xs1174 := []string{} - cond1175 := p.matchLookaheadTerminal("STRING", 0) - for cond1175 { - item1176 := p.consumeTerminal("STRING").Value.str - xs1174 = append(xs1174, item1176) - cond1175 = p.matchLookaheadTerminal("STRING", 0) - } - strings1177 := xs1174 + xs1175 := []string{} + cond1176 := p.matchLookaheadTerminal("STRING", 0) + for cond1176 { + item1177 := p.consumeTerminal("STRING").Value.str + xs1175 = append(xs1175, item1177) + cond1176 = p.matchLookaheadTerminal("STRING", 0) + } + strings1178 := xs1175 p.consumeLiteral(")") - return strings1177 + return strings1178 } func (p *Parser) parse_csv_locator_inline_data() string { p.consumeLiteral("(") p.consumeLiteral("inline_data") - string1178 := p.consumeTerminal("STRING").Value.str + string1179 := p.consumeTerminal("STRING").Value.str p.consumeLiteral(")") - return string1178 + return string1179 } func (p *Parser) parse_csv_config() *pb.CSVConfig { - span_start1180 := int64(p.spanStart()) + span_start1181 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("csv_config") - _t1978 := p.parse_config_dict() - config_dict1179 := _t1978 + _t1980 := p.parse_config_dict() + config_dict1180 := _t1980 p.consumeLiteral(")") - _t1979 := p.construct_csv_config(config_dict1179) - result1181 := _t1979 - p.recordSpan(int(span_start1180), "CSVConfig") - return result1181 + _t1981 := p.construct_csv_config(config_dict1180) + result1182 := _t1981 + p.recordSpan(int(span_start1181), "CSVConfig") + return result1182 } func (p *Parser) parse_gnf_columns() []*pb.GNFColumn { p.consumeLiteral("(") p.consumeLiteral("columns") - xs1182 := []*pb.GNFColumn{} - cond1183 := p.matchLookaheadLiteral("(", 0) - for cond1183 { - _t1980 := p.parse_gnf_column() - item1184 := _t1980 - xs1182 = append(xs1182, item1184) - cond1183 = p.matchLookaheadLiteral("(", 0) - } - gnf_columns1185 := xs1182 + xs1183 := []*pb.GNFColumn{} + cond1184 := p.matchLookaheadLiteral("(", 0) + for cond1184 { + _t1982 := p.parse_gnf_column() + item1185 := _t1982 + xs1183 = append(xs1183, item1185) + cond1184 = p.matchLookaheadLiteral("(", 0) + } + gnf_columns1186 := xs1183 p.consumeLiteral(")") - return gnf_columns1185 + return gnf_columns1186 } func (p *Parser) parse_gnf_column() *pb.GNFColumn { - span_start1192 := int64(p.spanStart()) + span_start1193 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("column") - _t1981 := p.parse_gnf_column_path() - gnf_column_path1186 := _t1981 - var _t1982 *pb.RelationId + _t1983 := p.parse_gnf_column_path() + gnf_column_path1187 := _t1983 + var _t1984 *pb.RelationId if (p.matchLookaheadLiteral(":", 0) || p.matchLookaheadTerminal("UINT128", 0)) { - _t1983 := p.parse_relation_id() - _t1982 = _t1983 + _t1985 := p.parse_relation_id() + _t1984 = _t1985 } - relation_id1187 := _t1982 + relation_id1188 := _t1984 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 { - _t1984 := p.parse_type() - item1190 := _t1984 - 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 + xs1189 := []*pb.Type{} + cond1190 := (((((((((((((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 cond1190 { + _t1986 := p.parse_type() + item1191 := _t1986 + xs1189 = append(xs1189, item1191) + cond1190 = (((((((((((((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)) + } + types1192 := xs1189 p.consumeLiteral("]") p.consumeLiteral(")") - _t1985 := &pb.GNFColumn{ColumnPath: gnf_column_path1186, TargetId: relation_id1187, Types: types1191} - result1193 := _t1985 - p.recordSpan(int(span_start1192), "GNFColumn") - return result1193 + _t1987 := &pb.GNFColumn{ColumnPath: gnf_column_path1187, TargetId: relation_id1188, Types: types1192} + result1194 := _t1987 + p.recordSpan(int(span_start1193), "GNFColumn") + return result1194 } func (p *Parser) parse_gnf_column_path() []string { - var _t1986 int64 + var _t1988 int64 if p.matchLookaheadLiteral("[", 0) { - _t1986 = 1 + _t1988 = 1 } else { - var _t1987 int64 + var _t1989 int64 if p.matchLookaheadTerminal("STRING", 0) { - _t1987 = 0 + _t1989 = 0 } else { - _t1987 = -1 + _t1989 = -1 } - _t1986 = _t1987 + _t1988 = _t1989 } - prediction1194 := _t1986 - var _t1988 []string - if prediction1194 == 1 { + prediction1195 := _t1988 + var _t1990 []string + if prediction1195 == 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) + xs1197 := []string{} + cond1198 := p.matchLookaheadTerminal("STRING", 0) + for cond1198 { + item1199 := p.consumeTerminal("STRING").Value.str + xs1197 = append(xs1197, item1199) + cond1198 = p.matchLookaheadTerminal("STRING", 0) } - strings1199 := xs1196 + strings1200 := xs1197 p.consumeLiteral("]") - _t1988 = strings1199 + _t1990 = strings1200 } else { - var _t1989 []string - if prediction1194 == 0 { - string1195 := p.consumeTerminal("STRING").Value.str - _ = string1195 - _t1989 = []string{string1195} + var _t1991 []string + if prediction1195 == 0 { + string1196 := p.consumeTerminal("STRING").Value.str + _ = string1196 + _t1991 = []string{string1196} } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in gnf_column_path", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1988 = _t1989 + _t1990 = _t1991 } - return _t1988 + return _t1990 } func (p *Parser) parse_csv_asof() string { p.consumeLiteral("(") p.consumeLiteral("asof") - string1200 := p.consumeTerminal("STRING").Value.str + string1201 := p.consumeTerminal("STRING").Value.str p.consumeLiteral(")") - return string1200 + return string1201 } func (p *Parser) parse_iceberg_data() *pb.IcebergData { - span_start1207 := int64(p.spanStart()) + span_start1208 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("iceberg_data") - _t1990 := p.parse_iceberg_locator() - iceberg_locator1201 := _t1990 - _t1991 := p.parse_iceberg_catalog_config() - iceberg_catalog_config1202 := _t1991 - _t1992 := p.parse_gnf_columns() - gnf_columns1203 := _t1992 - var _t1993 *string + _t1992 := p.parse_iceberg_locator() + iceberg_locator1202 := _t1992 + _t1993 := p.parse_iceberg_catalog_config() + iceberg_catalog_config1203 := _t1993 + _t1994 := p.parse_gnf_columns() + gnf_columns1204 := _t1994 + var _t1995 *string if (p.matchLookaheadLiteral("(", 0) && p.matchLookaheadLiteral("from_snapshot", 1)) { - _t1994 := p.parse_iceberg_from_snapshot() - _t1993 = ptr(_t1994) + _t1996 := p.parse_iceberg_from_snapshot() + _t1995 = ptr(_t1996) } - iceberg_from_snapshot1204 := _t1993 - var _t1995 *string + iceberg_from_snapshot1205 := _t1995 + var _t1997 *string if p.matchLookaheadLiteral("(", 0) { - _t1996 := p.parse_iceberg_to_snapshot() - _t1995 = ptr(_t1996) + _t1998 := p.parse_iceberg_to_snapshot() + _t1997 = ptr(_t1998) } - iceberg_to_snapshot1205 := _t1995 - _t1997 := p.parse_boolean_value() - boolean_value1206 := _t1997 + iceberg_to_snapshot1206 := _t1997 + _t1999 := p.parse_boolean_value() + boolean_value1207 := _t1999 p.consumeLiteral(")") - _t1998 := p.construct_iceberg_data(iceberg_locator1201, iceberg_catalog_config1202, gnf_columns1203, iceberg_from_snapshot1204, iceberg_to_snapshot1205, boolean_value1206) - result1208 := _t1998 - p.recordSpan(int(span_start1207), "IcebergData") - return result1208 + _t2000 := p.construct_iceberg_data(iceberg_locator1202, iceberg_catalog_config1203, gnf_columns1204, iceberg_from_snapshot1205, iceberg_to_snapshot1206, boolean_value1207) + result1209 := _t2000 + p.recordSpan(int(span_start1208), "IcebergData") + return result1209 } func (p *Parser) parse_iceberg_locator() *pb.IcebergLocator { - span_start1212 := int64(p.spanStart()) + span_start1213 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("iceberg_locator") - _t1999 := p.parse_iceberg_locator_table_name() - iceberg_locator_table_name1209 := _t1999 - _t2000 := p.parse_iceberg_locator_namespace() - iceberg_locator_namespace1210 := _t2000 - _t2001 := p.parse_iceberg_locator_warehouse() - iceberg_locator_warehouse1211 := _t2001 + _t2001 := p.parse_iceberg_locator_table_name() + iceberg_locator_table_name1210 := _t2001 + _t2002 := p.parse_iceberg_locator_namespace() + iceberg_locator_namespace1211 := _t2002 + _t2003 := p.parse_iceberg_locator_warehouse() + iceberg_locator_warehouse1212 := _t2003 p.consumeLiteral(")") - _t2002 := &pb.IcebergLocator{TableName: iceberg_locator_table_name1209, Namespace: iceberg_locator_namespace1210, Warehouse: iceberg_locator_warehouse1211} - result1213 := _t2002 - p.recordSpan(int(span_start1212), "IcebergLocator") - return result1213 + _t2004 := &pb.IcebergLocator{TableName: iceberg_locator_table_name1210, Namespace: iceberg_locator_namespace1211, Warehouse: iceberg_locator_warehouse1212} + result1214 := _t2004 + p.recordSpan(int(span_start1213), "IcebergLocator") + return result1214 } func (p *Parser) parse_iceberg_locator_table_name() string { p.consumeLiteral("(") p.consumeLiteral("table_name") - string1214 := p.consumeTerminal("STRING").Value.str + string1215 := p.consumeTerminal("STRING").Value.str p.consumeLiteral(")") - return string1214 + return string1215 } 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 + xs1216 := []string{} + cond1217 := p.matchLookaheadTerminal("STRING", 0) + for cond1217 { + item1218 := p.consumeTerminal("STRING").Value.str + xs1216 = append(xs1216, item1218) + cond1217 = p.matchLookaheadTerminal("STRING", 0) + } + strings1219 := xs1216 p.consumeLiteral(")") - return strings1218 + return strings1219 } func (p *Parser) parse_iceberg_locator_warehouse() string { p.consumeLiteral("(") p.consumeLiteral("warehouse") - string1219 := p.consumeTerminal("STRING").Value.str + string1220 := p.consumeTerminal("STRING").Value.str p.consumeLiteral(")") - return string1219 + return string1220 } func (p *Parser) parse_iceberg_catalog_config() *pb.IcebergCatalogConfig { - span_start1224 := int64(p.spanStart()) + span_start1225 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("iceberg_catalog_config") - _t2003 := p.parse_iceberg_catalog_uri() - iceberg_catalog_uri1220 := _t2003 - var _t2004 *string + _t2005 := p.parse_iceberg_catalog_uri() + iceberg_catalog_uri1221 := _t2005 + var _t2006 *string if (p.matchLookaheadLiteral("(", 0) && p.matchLookaheadLiteral("scope", 1)) { - _t2005 := p.parse_iceberg_catalog_config_scope() - _t2004 = ptr(_t2005) - } - iceberg_catalog_config_scope1221 := _t2004 - _t2006 := p.parse_iceberg_properties() - iceberg_properties1222 := _t2006 - _t2007 := p.parse_iceberg_auth_properties() - iceberg_auth_properties1223 := _t2007 + _t2007 := p.parse_iceberg_catalog_config_scope() + _t2006 = ptr(_t2007) + } + iceberg_catalog_config_scope1222 := _t2006 + _t2008 := p.parse_iceberg_properties() + iceberg_properties1223 := _t2008 + _t2009 := p.parse_iceberg_auth_properties() + iceberg_auth_properties1224 := _t2009 p.consumeLiteral(")") - _t2008 := p.construct_iceberg_catalog_config(iceberg_catalog_uri1220, iceberg_catalog_config_scope1221, iceberg_properties1222, iceberg_auth_properties1223) - result1225 := _t2008 - p.recordSpan(int(span_start1224), "IcebergCatalogConfig") - return result1225 + _t2010 := p.construct_iceberg_catalog_config(iceberg_catalog_uri1221, iceberg_catalog_config_scope1222, iceberg_properties1223, iceberg_auth_properties1224) + result1226 := _t2010 + p.recordSpan(int(span_start1225), "IcebergCatalogConfig") + return result1226 } func (p *Parser) parse_iceberg_catalog_uri() string { p.consumeLiteral("(") p.consumeLiteral("catalog_uri") - string1226 := p.consumeTerminal("STRING").Value.str + string1227 := p.consumeTerminal("STRING").Value.str p.consumeLiteral(")") - return string1226 + return string1227 } func (p *Parser) parse_iceberg_catalog_config_scope() string { p.consumeLiteral("(") p.consumeLiteral("scope") - string1227 := p.consumeTerminal("STRING").Value.str + string1228 := p.consumeTerminal("STRING").Value.str p.consumeLiteral(")") - return string1227 + return string1228 } func (p *Parser) parse_iceberg_properties() [][]interface{} { p.consumeLiteral("(") p.consumeLiteral("properties") - xs1228 := [][]interface{}{} - cond1229 := p.matchLookaheadLiteral("(", 0) - for cond1229 { - _t2009 := p.parse_iceberg_property_entry() - item1230 := _t2009 - xs1228 = append(xs1228, item1230) - cond1229 = p.matchLookaheadLiteral("(", 0) - } - iceberg_property_entrys1231 := xs1228 + xs1229 := [][]interface{}{} + cond1230 := p.matchLookaheadLiteral("(", 0) + for cond1230 { + _t2011 := p.parse_iceberg_property_entry() + item1231 := _t2011 + xs1229 = append(xs1229, item1231) + cond1230 = p.matchLookaheadLiteral("(", 0) + } + iceberg_property_entrys1232 := xs1229 p.consumeLiteral(")") - return iceberg_property_entrys1231 + return iceberg_property_entrys1232 } 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 + string1233 := p.consumeTerminal("STRING").Value.str + string_31234 := p.consumeTerminal("STRING").Value.str p.consumeLiteral(")") - return []interface{}{string1232, string_31233} + return []interface{}{string1233, string_31234} } func (p *Parser) parse_iceberg_auth_properties() [][]interface{} { p.consumeLiteral("(") p.consumeLiteral("auth_properties") - xs1234 := [][]interface{}{} - cond1235 := p.matchLookaheadLiteral("(", 0) - for cond1235 { - _t2010 := p.parse_iceberg_masked_property_entry() - item1236 := _t2010 - xs1234 = append(xs1234, item1236) - cond1235 = p.matchLookaheadLiteral("(", 0) - } - iceberg_masked_property_entrys1237 := xs1234 + xs1235 := [][]interface{}{} + cond1236 := p.matchLookaheadLiteral("(", 0) + for cond1236 { + _t2012 := p.parse_iceberg_masked_property_entry() + item1237 := _t2012 + xs1235 = append(xs1235, item1237) + cond1236 = p.matchLookaheadLiteral("(", 0) + } + iceberg_masked_property_entrys1238 := xs1235 p.consumeLiteral(")") - return iceberg_masked_property_entrys1237 + return iceberg_masked_property_entrys1238 } 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 + string1239 := p.consumeTerminal("STRING").Value.str + string_31240 := p.consumeTerminal("STRING").Value.str p.consumeLiteral(")") - return []interface{}{string1238, string_31239} + return []interface{}{string1239, string_31240} } func (p *Parser) parse_iceberg_from_snapshot() string { p.consumeLiteral("(") p.consumeLiteral("from_snapshot") - string1240 := p.consumeTerminal("STRING").Value.str + string1241 := p.consumeTerminal("STRING").Value.str p.consumeLiteral(")") - return string1240 + return string1241 } func (p *Parser) parse_iceberg_to_snapshot() string { p.consumeLiteral("(") p.consumeLiteral("to_snapshot") - string1241 := p.consumeTerminal("STRING").Value.str + string1242 := p.consumeTerminal("STRING").Value.str p.consumeLiteral(")") - return string1241 + return string1242 } func (p *Parser) parse_undefine() *pb.Undefine { - span_start1243 := int64(p.spanStart()) + span_start1244 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("undefine") - _t2011 := p.parse_fragment_id() - fragment_id1242 := _t2011 + _t2013 := p.parse_fragment_id() + fragment_id1243 := _t2013 p.consumeLiteral(")") - _t2012 := &pb.Undefine{FragmentId: fragment_id1242} - result1244 := _t2012 - p.recordSpan(int(span_start1243), "Undefine") - return result1244 + _t2014 := &pb.Undefine{FragmentId: fragment_id1243} + result1245 := _t2014 + p.recordSpan(int(span_start1244), "Undefine") + return result1245 } func (p *Parser) parse_context() *pb.Context { - span_start1249 := int64(p.spanStart()) + span_start1250 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("context") - xs1245 := []*pb.RelationId{} - cond1246 := (p.matchLookaheadLiteral(":", 0) || p.matchLookaheadTerminal("UINT128", 0)) - for cond1246 { - _t2013 := p.parse_relation_id() - item1247 := _t2013 - xs1245 = append(xs1245, item1247) - cond1246 = (p.matchLookaheadLiteral(":", 0) || p.matchLookaheadTerminal("UINT128", 0)) - } - relation_ids1248 := xs1245 + xs1246 := []*pb.RelationId{} + cond1247 := (p.matchLookaheadLiteral(":", 0) || p.matchLookaheadTerminal("UINT128", 0)) + for cond1247 { + _t2015 := p.parse_relation_id() + item1248 := _t2015 + xs1246 = append(xs1246, item1248) + cond1247 = (p.matchLookaheadLiteral(":", 0) || p.matchLookaheadTerminal("UINT128", 0)) + } + relation_ids1249 := xs1246 p.consumeLiteral(")") - _t2014 := &pb.Context{Relations: relation_ids1248} - result1250 := _t2014 - p.recordSpan(int(span_start1249), "Context") - return result1250 + _t2016 := &pb.Context{Relations: relation_ids1249} + result1251 := _t2016 + p.recordSpan(int(span_start1250), "Context") + return result1251 } func (p *Parser) parse_snapshot() *pb.Snapshot { - span_start1255 := int64(p.spanStart()) + span_start1257 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("snapshot") - xs1251 := []*pb.SnapshotMapping{} - cond1252 := p.matchLookaheadLiteral("[", 0) - for cond1252 { - _t2015 := p.parse_snapshot_mapping() - item1253 := _t2015 - xs1251 = append(xs1251, item1253) - cond1252 = p.matchLookaheadLiteral("[", 0) - } - snapshot_mappings1254 := xs1251 + _t2017 := p.parse_edb_path() + edb_path1252 := _t2017 + xs1253 := []*pb.SnapshotMapping{} + cond1254 := p.matchLookaheadLiteral("[", 0) + for cond1254 { + _t2018 := p.parse_snapshot_mapping() + item1255 := _t2018 + xs1253 = append(xs1253, item1255) + cond1254 = p.matchLookaheadLiteral("[", 0) + } + snapshot_mappings1256 := xs1253 p.consumeLiteral(")") - _t2016 := &pb.Snapshot{Mappings: snapshot_mappings1254} - result1256 := _t2016 - p.recordSpan(int(span_start1255), "Snapshot") - return result1256 + _t2019 := &pb.Snapshot{Prefix: edb_path1252, Mappings: snapshot_mappings1256} + result1258 := _t2019 + p.recordSpan(int(span_start1257), "Snapshot") + return result1258 } func (p *Parser) parse_snapshot_mapping() *pb.SnapshotMapping { - span_start1259 := int64(p.spanStart()) - _t2017 := p.parse_edb_path() - edb_path1257 := _t2017 - _t2018 := p.parse_relation_id() - relation_id1258 := _t2018 - _t2019 := &pb.SnapshotMapping{DestinationPath: edb_path1257, SourceRelation: relation_id1258} - result1260 := _t2019 - p.recordSpan(int(span_start1259), "SnapshotMapping") - return result1260 + span_start1261 := int64(p.spanStart()) + _t2020 := p.parse_edb_path() + edb_path1259 := _t2020 + _t2021 := p.parse_relation_id() + relation_id1260 := _t2021 + _t2022 := &pb.SnapshotMapping{DestinationPath: edb_path1259, SourceRelation: relation_id1260} + result1262 := _t2022 + p.recordSpan(int(span_start1261), "SnapshotMapping") + return result1262 } func (p *Parser) parse_epoch_reads() []*pb.Read { p.consumeLiteral("(") p.consumeLiteral("reads") - xs1261 := []*pb.Read{} - cond1262 := p.matchLookaheadLiteral("(", 0) - for cond1262 { - _t2020 := p.parse_read() - item1263 := _t2020 - xs1261 = append(xs1261, item1263) - cond1262 = p.matchLookaheadLiteral("(", 0) - } - reads1264 := xs1261 + xs1263 := []*pb.Read{} + cond1264 := p.matchLookaheadLiteral("(", 0) + for cond1264 { + _t2023 := p.parse_read() + item1265 := _t2023 + xs1263 = append(xs1263, item1265) + cond1264 = p.matchLookaheadLiteral("(", 0) + } + reads1266 := xs1263 p.consumeLiteral(")") - return reads1264 + return reads1266 } func (p *Parser) parse_read() *pb.Read { - span_start1271 := int64(p.spanStart()) - var _t2021 int64 + span_start1273 := int64(p.spanStart()) + var _t2024 int64 if p.matchLookaheadLiteral("(", 0) { - var _t2022 int64 + var _t2025 int64 if p.matchLookaheadLiteral("what_if", 1) { - _t2022 = 2 + _t2025 = 2 } else { - var _t2023 int64 + var _t2026 int64 if p.matchLookaheadLiteral("output", 1) { - _t2023 = 1 + _t2026 = 1 } else { - var _t2024 int64 + var _t2027 int64 if p.matchLookaheadLiteral("export_iceberg", 1) { - _t2024 = 4 + _t2027 = 4 } else { - var _t2025 int64 + var _t2028 int64 if p.matchLookaheadLiteral("export", 1) { - _t2025 = 4 + _t2028 = 4 } else { - var _t2026 int64 + var _t2029 int64 if p.matchLookaheadLiteral("demand", 1) { - _t2026 = 0 + _t2029 = 0 } else { - var _t2027 int64 + var _t2030 int64 if p.matchLookaheadLiteral("abort", 1) { - _t2027 = 3 + _t2030 = 3 } else { - _t2027 = -1 + _t2030 = -1 } - _t2026 = _t2027 + _t2029 = _t2030 } - _t2025 = _t2026 + _t2028 = _t2029 } - _t2024 = _t2025 + _t2027 = _t2028 } - _t2023 = _t2024 + _t2026 = _t2027 } - _t2022 = _t2023 + _t2025 = _t2026 } - _t2021 = _t2022 + _t2024 = _t2025 } else { - _t2021 = -1 - } - prediction1265 := _t2021 - var _t2028 *pb.Read - if prediction1265 == 4 { - _t2029 := p.parse_export() - export1270 := _t2029 - _t2030 := &pb.Read{} - _t2030.ReadType = &pb.Read_Export{Export: export1270} - _t2028 = _t2030 + _t2024 = -1 + } + prediction1267 := _t2024 + var _t2031 *pb.Read + if prediction1267 == 4 { + _t2032 := p.parse_export() + export1272 := _t2032 + _t2033 := &pb.Read{} + _t2033.ReadType = &pb.Read_Export{Export: export1272} + _t2031 = _t2033 } else { - var _t2031 *pb.Read - if prediction1265 == 3 { - _t2032 := p.parse_abort() - abort1269 := _t2032 - _t2033 := &pb.Read{} - _t2033.ReadType = &pb.Read_Abort{Abort: abort1269} - _t2031 = _t2033 + var _t2034 *pb.Read + if prediction1267 == 3 { + _t2035 := p.parse_abort() + abort1271 := _t2035 + _t2036 := &pb.Read{} + _t2036.ReadType = &pb.Read_Abort{Abort: abort1271} + _t2034 = _t2036 } else { - var _t2034 *pb.Read - if prediction1265 == 2 { - _t2035 := p.parse_what_if() - what_if1268 := _t2035 - _t2036 := &pb.Read{} - _t2036.ReadType = &pb.Read_WhatIf{WhatIf: what_if1268} - _t2034 = _t2036 + var _t2037 *pb.Read + if prediction1267 == 2 { + _t2038 := p.parse_what_if() + what_if1270 := _t2038 + _t2039 := &pb.Read{} + _t2039.ReadType = &pb.Read_WhatIf{WhatIf: what_if1270} + _t2037 = _t2039 } else { - var _t2037 *pb.Read - if prediction1265 == 1 { - _t2038 := p.parse_output() - output1267 := _t2038 - _t2039 := &pb.Read{} - _t2039.ReadType = &pb.Read_Output{Output: output1267} - _t2037 = _t2039 + var _t2040 *pb.Read + if prediction1267 == 1 { + _t2041 := p.parse_output() + output1269 := _t2041 + _t2042 := &pb.Read{} + _t2042.ReadType = &pb.Read_Output{Output: output1269} + _t2040 = _t2042 } else { - var _t2040 *pb.Read - if prediction1265 == 0 { - _t2041 := p.parse_demand() - demand1266 := _t2041 - _t2042 := &pb.Read{} - _t2042.ReadType = &pb.Read_Demand{Demand: demand1266} - _t2040 = _t2042 + var _t2043 *pb.Read + if prediction1267 == 0 { + _t2044 := p.parse_demand() + demand1268 := _t2044 + _t2045 := &pb.Read{} + _t2045.ReadType = &pb.Read_Demand{Demand: demand1268} + _t2043 = _t2045 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in read", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t2037 = _t2040 + _t2040 = _t2043 } - _t2034 = _t2037 + _t2037 = _t2040 } - _t2031 = _t2034 + _t2034 = _t2037 } - _t2028 = _t2031 + _t2031 = _t2034 } - result1272 := _t2028 - p.recordSpan(int(span_start1271), "Read") - return result1272 + result1274 := _t2031 + p.recordSpan(int(span_start1273), "Read") + return result1274 } func (p *Parser) parse_demand() *pb.Demand { - span_start1274 := int64(p.spanStart()) + span_start1276 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("demand") - _t2043 := p.parse_relation_id() - relation_id1273 := _t2043 + _t2046 := p.parse_relation_id() + relation_id1275 := _t2046 p.consumeLiteral(")") - _t2044 := &pb.Demand{RelationId: relation_id1273} - result1275 := _t2044 - p.recordSpan(int(span_start1274), "Demand") - return result1275 + _t2047 := &pb.Demand{RelationId: relation_id1275} + result1277 := _t2047 + p.recordSpan(int(span_start1276), "Demand") + return result1277 } func (p *Parser) parse_output() *pb.Output { - span_start1278 := int64(p.spanStart()) + span_start1280 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("output") - _t2045 := p.parse_name() - name1276 := _t2045 - _t2046 := p.parse_relation_id() - relation_id1277 := _t2046 + _t2048 := p.parse_name() + name1278 := _t2048 + _t2049 := p.parse_relation_id() + relation_id1279 := _t2049 p.consumeLiteral(")") - _t2047 := &pb.Output{Name: name1276, RelationId: relation_id1277} - result1279 := _t2047 - p.recordSpan(int(span_start1278), "Output") - return result1279 + _t2050 := &pb.Output{Name: name1278, RelationId: relation_id1279} + result1281 := _t2050 + p.recordSpan(int(span_start1280), "Output") + return result1281 } func (p *Parser) parse_what_if() *pb.WhatIf { - span_start1282 := int64(p.spanStart()) + span_start1284 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("what_if") - _t2048 := p.parse_name() - name1280 := _t2048 - _t2049 := p.parse_epoch() - epoch1281 := _t2049 + _t2051 := p.parse_name() + name1282 := _t2051 + _t2052 := p.parse_epoch() + epoch1283 := _t2052 p.consumeLiteral(")") - _t2050 := &pb.WhatIf{Branch: name1280, Epoch: epoch1281} - result1283 := _t2050 - p.recordSpan(int(span_start1282), "WhatIf") - return result1283 + _t2053 := &pb.WhatIf{Branch: name1282, Epoch: epoch1283} + result1285 := _t2053 + p.recordSpan(int(span_start1284), "WhatIf") + return result1285 } func (p *Parser) parse_abort() *pb.Abort { - span_start1286 := int64(p.spanStart()) + span_start1288 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("abort") - var _t2051 *string + var _t2054 *string if (p.matchLookaheadLiteral(":", 0) && p.matchLookaheadTerminal("SYMBOL", 1)) { - _t2052 := p.parse_name() - _t2051 = ptr(_t2052) + _t2055 := p.parse_name() + _t2054 = ptr(_t2055) } - name1284 := _t2051 - _t2053 := p.parse_relation_id() - relation_id1285 := _t2053 + name1286 := _t2054 + _t2056 := p.parse_relation_id() + relation_id1287 := _t2056 p.consumeLiteral(")") - _t2054 := &pb.Abort{Name: deref(name1284, "abort"), RelationId: relation_id1285} - result1287 := _t2054 - p.recordSpan(int(span_start1286), "Abort") - return result1287 + _t2057 := &pb.Abort{Name: deref(name1286, "abort"), RelationId: relation_id1287} + result1289 := _t2057 + p.recordSpan(int(span_start1288), "Abort") + return result1289 } func (p *Parser) parse_export() *pb.Export { - span_start1291 := int64(p.spanStart()) - var _t2055 int64 + span_start1293 := int64(p.spanStart()) + var _t2058 int64 if p.matchLookaheadLiteral("(", 0) { - var _t2056 int64 + var _t2059 int64 if p.matchLookaheadLiteral("export_iceberg", 1) { - _t2056 = 1 + _t2059 = 1 } else { - var _t2057 int64 + var _t2060 int64 if p.matchLookaheadLiteral("export", 1) { - _t2057 = 0 + _t2060 = 0 } else { - _t2057 = -1 + _t2060 = -1 } - _t2056 = _t2057 + _t2059 = _t2060 } - _t2055 = _t2056 + _t2058 = _t2059 } else { - _t2055 = -1 + _t2058 = -1 } - prediction1288 := _t2055 - var _t2058 *pb.Export - if prediction1288 == 1 { + prediction1290 := _t2058 + var _t2061 *pb.Export + if prediction1290 == 1 { p.consumeLiteral("(") p.consumeLiteral("export_iceberg") - _t2059 := p.parse_export_iceberg_config() - export_iceberg_config1290 := _t2059 + _t2062 := p.parse_export_iceberg_config() + export_iceberg_config1292 := _t2062 p.consumeLiteral(")") - _t2060 := &pb.Export{} - _t2060.ExportConfig = &pb.Export_IcebergConfig{IcebergConfig: export_iceberg_config1290} - _t2058 = _t2060 + _t2063 := &pb.Export{} + _t2063.ExportConfig = &pb.Export_IcebergConfig{IcebergConfig: export_iceberg_config1292} + _t2061 = _t2063 } else { - var _t2061 *pb.Export - if prediction1288 == 0 { + var _t2064 *pb.Export + if prediction1290 == 0 { p.consumeLiteral("(") p.consumeLiteral("export") - _t2062 := p.parse_export_csv_config() - export_csv_config1289 := _t2062 + _t2065 := p.parse_export_csv_config() + export_csv_config1291 := _t2065 p.consumeLiteral(")") - _t2063 := &pb.Export{} - _t2063.ExportConfig = &pb.Export_CsvConfig{CsvConfig: export_csv_config1289} - _t2061 = _t2063 + _t2066 := &pb.Export{} + _t2066.ExportConfig = &pb.Export_CsvConfig{CsvConfig: export_csv_config1291} + _t2064 = _t2066 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in export", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t2058 = _t2061 + _t2061 = _t2064 } - result1292 := _t2058 - p.recordSpan(int(span_start1291), "Export") - return result1292 + result1294 := _t2061 + p.recordSpan(int(span_start1293), "Export") + return result1294 } func (p *Parser) parse_export_csv_config() *pb.ExportCSVConfig { - span_start1300 := int64(p.spanStart()) - var _t2064 int64 + span_start1302 := int64(p.spanStart()) + var _t2067 int64 if p.matchLookaheadLiteral("(", 0) { - var _t2065 int64 + var _t2068 int64 if p.matchLookaheadLiteral("export_csv_config_v2", 1) { - _t2065 = 0 + _t2068 = 0 } else { - var _t2066 int64 + var _t2069 int64 if p.matchLookaheadLiteral("export_csv_config", 1) { - _t2066 = 1 + _t2069 = 1 } else { - _t2066 = -1 + _t2069 = -1 } - _t2065 = _t2066 + _t2068 = _t2069 } - _t2064 = _t2065 + _t2067 = _t2068 } else { - _t2064 = -1 + _t2067 = -1 } - prediction1293 := _t2064 - var _t2067 *pb.ExportCSVConfig - if prediction1293 == 1 { + prediction1295 := _t2067 + var _t2070 *pb.ExportCSVConfig + if prediction1295 == 1 { p.consumeLiteral("(") p.consumeLiteral("export_csv_config") - _t2068 := p.parse_export_csv_path() - export_csv_path1297 := _t2068 - _t2069 := p.parse_export_csv_columns_list() - export_csv_columns_list1298 := _t2069 - _t2070 := p.parse_config_dict() - config_dict1299 := _t2070 + _t2071 := p.parse_export_csv_path() + export_csv_path1299 := _t2071 + _t2072 := p.parse_export_csv_columns_list() + export_csv_columns_list1300 := _t2072 + _t2073 := p.parse_config_dict() + config_dict1301 := _t2073 p.consumeLiteral(")") - _t2071 := p.construct_export_csv_config(export_csv_path1297, export_csv_columns_list1298, config_dict1299) - _t2067 = _t2071 + _t2074 := p.construct_export_csv_config(export_csv_path1299, export_csv_columns_list1300, config_dict1301) + _t2070 = _t2074 } else { - var _t2072 *pb.ExportCSVConfig - if prediction1293 == 0 { + var _t2075 *pb.ExportCSVConfig + if prediction1295 == 0 { p.consumeLiteral("(") p.consumeLiteral("export_csv_config_v2") - _t2073 := p.parse_export_csv_path() - export_csv_path1294 := _t2073 - _t2074 := p.parse_export_csv_source() - export_csv_source1295 := _t2074 - _t2075 := p.parse_csv_config() - csv_config1296 := _t2075 + _t2076 := p.parse_export_csv_path() + export_csv_path1296 := _t2076 + _t2077 := p.parse_export_csv_source() + export_csv_source1297 := _t2077 + _t2078 := p.parse_csv_config() + csv_config1298 := _t2078 p.consumeLiteral(")") - _t2076 := p.construct_export_csv_config_with_source(export_csv_path1294, export_csv_source1295, csv_config1296) - _t2072 = _t2076 + _t2079 := p.construct_export_csv_config_with_source(export_csv_path1296, export_csv_source1297, csv_config1298) + _t2075 = _t2079 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in export_csv_config", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t2067 = _t2072 + _t2070 = _t2075 } - result1301 := _t2067 - p.recordSpan(int(span_start1300), "ExportCSVConfig") - return result1301 + result1303 := _t2070 + p.recordSpan(int(span_start1302), "ExportCSVConfig") + return result1303 } func (p *Parser) parse_export_csv_path() string { p.consumeLiteral("(") p.consumeLiteral("path") - string1302 := p.consumeTerminal("STRING").Value.str + string1304 := p.consumeTerminal("STRING").Value.str p.consumeLiteral(")") - return string1302 + return string1304 } func (p *Parser) parse_export_csv_source() *pb.ExportCSVSource { - span_start1309 := int64(p.spanStart()) - var _t2077 int64 + span_start1311 := int64(p.spanStart()) + var _t2080 int64 if p.matchLookaheadLiteral("(", 0) { - var _t2078 int64 + var _t2081 int64 if p.matchLookaheadLiteral("table_def", 1) { - _t2078 = 1 + _t2081 = 1 } else { - var _t2079 int64 + var _t2082 int64 if p.matchLookaheadLiteral("gnf_columns", 1) { - _t2079 = 0 + _t2082 = 0 } else { - _t2079 = -1 + _t2082 = -1 } - _t2078 = _t2079 + _t2081 = _t2082 } - _t2077 = _t2078 + _t2080 = _t2081 } else { - _t2077 = -1 + _t2080 = -1 } - prediction1303 := _t2077 - var _t2080 *pb.ExportCSVSource - if prediction1303 == 1 { + prediction1305 := _t2080 + var _t2083 *pb.ExportCSVSource + if prediction1305 == 1 { p.consumeLiteral("(") p.consumeLiteral("table_def") - _t2081 := p.parse_relation_id() - relation_id1308 := _t2081 + _t2084 := p.parse_relation_id() + relation_id1310 := _t2084 p.consumeLiteral(")") - _t2082 := &pb.ExportCSVSource{} - _t2082.CsvSource = &pb.ExportCSVSource_TableDef{TableDef: relation_id1308} - _t2080 = _t2082 + _t2085 := &pb.ExportCSVSource{} + _t2085.CsvSource = &pb.ExportCSVSource_TableDef{TableDef: relation_id1310} + _t2083 = _t2085 } else { - var _t2083 *pb.ExportCSVSource - if prediction1303 == 0 { + var _t2086 *pb.ExportCSVSource + if prediction1305 == 0 { p.consumeLiteral("(") p.consumeLiteral("gnf_columns") - xs1304 := []*pb.ExportCSVColumn{} - cond1305 := p.matchLookaheadLiteral("(", 0) - for cond1305 { - _t2084 := p.parse_export_csv_column() - item1306 := _t2084 - xs1304 = append(xs1304, item1306) - cond1305 = p.matchLookaheadLiteral("(", 0) + xs1306 := []*pb.ExportCSVColumn{} + cond1307 := p.matchLookaheadLiteral("(", 0) + for cond1307 { + _t2087 := p.parse_export_csv_column() + item1308 := _t2087 + xs1306 = append(xs1306, item1308) + cond1307 = p.matchLookaheadLiteral("(", 0) } - export_csv_columns1307 := xs1304 + export_csv_columns1309 := xs1306 p.consumeLiteral(")") - _t2085 := &pb.ExportCSVColumns{Columns: export_csv_columns1307} - _t2086 := &pb.ExportCSVSource{} - _t2086.CsvSource = &pb.ExportCSVSource_GnfColumns{GnfColumns: _t2085} - _t2083 = _t2086 + _t2088 := &pb.ExportCSVColumns{Columns: export_csv_columns1309} + _t2089 := &pb.ExportCSVSource{} + _t2089.CsvSource = &pb.ExportCSVSource_GnfColumns{GnfColumns: _t2088} + _t2086 = _t2089 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in export_csv_source", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t2080 = _t2083 + _t2083 = _t2086 } - result1310 := _t2080 - p.recordSpan(int(span_start1309), "ExportCSVSource") - return result1310 + result1312 := _t2083 + p.recordSpan(int(span_start1311), "ExportCSVSource") + return result1312 } func (p *Parser) parse_export_csv_column() *pb.ExportCSVColumn { - span_start1313 := int64(p.spanStart()) + span_start1315 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("column") - string1311 := p.consumeTerminal("STRING").Value.str - _t2087 := p.parse_relation_id() - relation_id1312 := _t2087 + string1313 := p.consumeTerminal("STRING").Value.str + _t2090 := p.parse_relation_id() + relation_id1314 := _t2090 p.consumeLiteral(")") - _t2088 := &pb.ExportCSVColumn{ColumnName: string1311, ColumnData: relation_id1312} - result1314 := _t2088 - p.recordSpan(int(span_start1313), "ExportCSVColumn") - return result1314 + _t2091 := &pb.ExportCSVColumn{ColumnName: string1313, ColumnData: relation_id1314} + result1316 := _t2091 + p.recordSpan(int(span_start1315), "ExportCSVColumn") + return result1316 } func (p *Parser) parse_export_csv_columns_list() []*pb.ExportCSVColumn { p.consumeLiteral("(") p.consumeLiteral("columns") - xs1315 := []*pb.ExportCSVColumn{} - cond1316 := p.matchLookaheadLiteral("(", 0) - for cond1316 { - _t2089 := p.parse_export_csv_column() - item1317 := _t2089 - xs1315 = append(xs1315, item1317) - cond1316 = p.matchLookaheadLiteral("(", 0) - } - export_csv_columns1318 := xs1315 + xs1317 := []*pb.ExportCSVColumn{} + cond1318 := p.matchLookaheadLiteral("(", 0) + for cond1318 { + _t2092 := p.parse_export_csv_column() + item1319 := _t2092 + xs1317 = append(xs1317, item1319) + cond1318 = p.matchLookaheadLiteral("(", 0) + } + export_csv_columns1320 := xs1317 p.consumeLiteral(")") - return export_csv_columns1318 + return export_csv_columns1320 } func (p *Parser) parse_export_iceberg_config() *pb.ExportIcebergConfig { - span_start1325 := int64(p.spanStart()) + span_start1327 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("export_iceberg_config") - _t2090 := p.parse_iceberg_locator() - iceberg_locator1319 := _t2090 - _t2091 := p.parse_iceberg_catalog_config() - iceberg_catalog_config1320 := _t2091 - _t2092 := p.parse_export_iceberg_table_def() - export_iceberg_table_def1321 := _t2092 - _t2093 := p.parse_export_iceberg_columns() - export_iceberg_columns1322 := _t2093 - _t2094 := p.parse_iceberg_table_properties() - iceberg_table_properties1323 := _t2094 - var _t2095 [][]interface{} + _t2093 := p.parse_iceberg_locator() + iceberg_locator1321 := _t2093 + _t2094 := p.parse_iceberg_catalog_config() + iceberg_catalog_config1322 := _t2094 + _t2095 := p.parse_export_iceberg_table_def() + export_iceberg_table_def1323 := _t2095 + _t2096 := p.parse_export_iceberg_columns() + export_iceberg_columns1324 := _t2096 + _t2097 := p.parse_iceberg_table_properties() + iceberg_table_properties1325 := _t2097 + var _t2098 [][]interface{} if p.matchLookaheadLiteral("{", 0) { - _t2096 := p.parse_config_dict() - _t2095 = _t2096 + _t2099 := p.parse_config_dict() + _t2098 = _t2099 } - config_dict1324 := _t2095 + config_dict1326 := _t2098 p.consumeLiteral(")") - _t2097 := p.construct_export_iceberg_config_full(iceberg_locator1319, iceberg_catalog_config1320, export_iceberg_table_def1321, export_iceberg_columns1322, iceberg_table_properties1323, config_dict1324) - result1326 := _t2097 - p.recordSpan(int(span_start1325), "ExportIcebergConfig") - return result1326 + _t2100 := p.construct_export_iceberg_config_full(iceberg_locator1321, iceberg_catalog_config1322, export_iceberg_table_def1323, export_iceberg_columns1324, iceberg_table_properties1325, config_dict1326) + result1328 := _t2100 + p.recordSpan(int(span_start1327), "ExportIcebergConfig") + return result1328 } func (p *Parser) parse_export_iceberg_table_def() *pb.RelationId { - span_start1328 := int64(p.spanStart()) + span_start1330 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("table_def") - _t2098 := p.parse_relation_id() - relation_id1327 := _t2098 + _t2101 := p.parse_relation_id() + relation_id1329 := _t2101 p.consumeLiteral(")") - result1329 := relation_id1327 - p.recordSpan(int(span_start1328), "RelationId") - return result1329 + result1331 := relation_id1329 + p.recordSpan(int(span_start1330), "RelationId") + return result1331 } func (p *Parser) parse_export_iceberg_columns() []*pb.ExportColumn { p.consumeLiteral("(") p.consumeLiteral("columns") - xs1330 := []*pb.ExportColumn{} - cond1331 := p.matchLookaheadLiteral("(", 0) - for cond1331 { - _t2099 := p.parse_export_iceberg_column() - item1332 := _t2099 - xs1330 = append(xs1330, item1332) - cond1331 = p.matchLookaheadLiteral("(", 0) - } - export_iceberg_columns1333 := xs1330 + xs1332 := []*pb.ExportColumn{} + cond1333 := p.matchLookaheadLiteral("(", 0) + for cond1333 { + _t2102 := p.parse_export_iceberg_column() + item1334 := _t2102 + xs1332 = append(xs1332, item1334) + cond1333 = p.matchLookaheadLiteral("(", 0) + } + export_iceberg_columns1335 := xs1332 p.consumeLiteral(")") - return export_iceberg_columns1333 + return export_iceberg_columns1335 } func (p *Parser) parse_export_iceberg_column() *pb.ExportColumn { - span_start1336 := int64(p.spanStart()) + span_start1338 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("column") - string1334 := p.consumeTerminal("STRING").Value.str - _t2100 := p.parse_boolean_value() - boolean_value1335 := _t2100 + string1336 := p.consumeTerminal("STRING").Value.str + _t2103 := p.parse_boolean_value() + boolean_value1337 := _t2103 p.consumeLiteral(")") - _t2101 := &pb.ExportColumn{Name: string1334, Nullable: boolean_value1335} - result1337 := _t2101 - p.recordSpan(int(span_start1336), "ExportColumn") - return result1337 + _t2104 := &pb.ExportColumn{Name: string1336, Nullable: boolean_value1337} + result1339 := _t2104 + p.recordSpan(int(span_start1338), "ExportColumn") + return result1339 } func (p *Parser) parse_iceberg_table_properties() [][]interface{} { p.consumeLiteral("(") p.consumeLiteral("table_properties") - xs1338 := [][]interface{}{} - cond1339 := p.matchLookaheadLiteral("(", 0) - for cond1339 { - _t2102 := p.parse_iceberg_property_entry() - item1340 := _t2102 - xs1338 = append(xs1338, item1340) - cond1339 = p.matchLookaheadLiteral("(", 0) - } - iceberg_property_entrys1341 := xs1338 + xs1340 := [][]interface{}{} + cond1341 := p.matchLookaheadLiteral("(", 0) + for cond1341 { + _t2105 := p.parse_iceberg_property_entry() + item1342 := _t2105 + xs1340 = append(xs1340, item1342) + cond1341 = p.matchLookaheadLiteral("(", 0) + } + iceberg_property_entrys1343 := xs1340 p.consumeLiteral(")") - return iceberg_property_entrys1341 + return iceberg_property_entrys1343 } diff --git a/sdks/go/src/pretty.go b/sdks/go/src/pretty.go index 7240c767..2c048bd2 100644 --- a/sdks/go/src/pretty.go +++ b/sdks/go/src/pretty.go @@ -343,157 +343,157 @@ func formatBool(b bool) string { // --- Helper functions --- func (p *PrettyPrinter) _make_value_int32(v int32) *pb.Value { - _t1737 := &pb.Value{} - _t1737.Value = &pb.Value_Int32Value{Int32Value: v} - return _t1737 + _t1741 := &pb.Value{} + _t1741.Value = &pb.Value_Int32Value{Int32Value: v} + return _t1741 } func (p *PrettyPrinter) _make_value_int64(v int64) *pb.Value { - _t1738 := &pb.Value{} - _t1738.Value = &pb.Value_IntValue{IntValue: v} - return _t1738 + _t1742 := &pb.Value{} + _t1742.Value = &pb.Value_IntValue{IntValue: v} + return _t1742 } func (p *PrettyPrinter) _make_value_float64(v float64) *pb.Value { - _t1739 := &pb.Value{} - _t1739.Value = &pb.Value_FloatValue{FloatValue: v} - return _t1739 + _t1743 := &pb.Value{} + _t1743.Value = &pb.Value_FloatValue{FloatValue: v} + return _t1743 } func (p *PrettyPrinter) _make_value_string(v string) *pb.Value { - _t1740 := &pb.Value{} - _t1740.Value = &pb.Value_StringValue{StringValue: v} - return _t1740 + _t1744 := &pb.Value{} + _t1744.Value = &pb.Value_StringValue{StringValue: v} + return _t1744 } func (p *PrettyPrinter) _make_value_boolean(v bool) *pb.Value { - _t1741 := &pb.Value{} - _t1741.Value = &pb.Value_BooleanValue{BooleanValue: v} - return _t1741 + _t1745 := &pb.Value{} + _t1745.Value = &pb.Value_BooleanValue{BooleanValue: v} + return _t1745 } func (p *PrettyPrinter) _make_value_uint128(v *pb.UInt128Value) *pb.Value { - _t1742 := &pb.Value{} - _t1742.Value = &pb.Value_Uint128Value{Uint128Value: v} - return _t1742 + _t1746 := &pb.Value{} + _t1746.Value = &pb.Value_Uint128Value{Uint128Value: v} + return _t1746 } func (p *PrettyPrinter) deconstruct_configure(msg *pb.Configure) [][]interface{} { result := [][]interface{}{} if msg.GetIvmConfig().GetLevel() == pb.MaintenanceLevel_MAINTENANCE_LEVEL_AUTO { - _t1743 := p._make_value_string("auto") - result = append(result, []interface{}{"ivm.maintenance_level", _t1743}) + _t1747 := p._make_value_string("auto") + result = append(result, []interface{}{"ivm.maintenance_level", _t1747}) } else { if msg.GetIvmConfig().GetLevel() == pb.MaintenanceLevel_MAINTENANCE_LEVEL_ALL { - _t1744 := p._make_value_string("all") - result = append(result, []interface{}{"ivm.maintenance_level", _t1744}) + _t1748 := p._make_value_string("all") + result = append(result, []interface{}{"ivm.maintenance_level", _t1748}) } else { if msg.GetIvmConfig().GetLevel() == pb.MaintenanceLevel_MAINTENANCE_LEVEL_OFF { - _t1745 := p._make_value_string("off") - result = append(result, []interface{}{"ivm.maintenance_level", _t1745}) + _t1749 := p._make_value_string("off") + result = append(result, []interface{}{"ivm.maintenance_level", _t1749}) } } } - _t1746 := p._make_value_int64(msg.GetSemanticsVersion()) - result = append(result, []interface{}{"semantics_version", _t1746}) + _t1750 := p._make_value_int64(msg.GetSemanticsVersion()) + result = append(result, []interface{}{"semantics_version", _t1750}) return listSort(result) } func (p *PrettyPrinter) deconstruct_csv_config(msg *pb.CSVConfig) [][]interface{} { result := [][]interface{}{} - _t1747 := p._make_value_int32(msg.GetHeaderRow()) - result = append(result, []interface{}{"csv_header_row", _t1747}) - _t1748 := p._make_value_int64(msg.GetSkip()) - result = append(result, []interface{}{"csv_skip", _t1748}) + _t1751 := p._make_value_int32(msg.GetHeaderRow()) + result = append(result, []interface{}{"csv_header_row", _t1751}) + _t1752 := p._make_value_int64(msg.GetSkip()) + result = append(result, []interface{}{"csv_skip", _t1752}) if msg.GetNewLine() != "" { - _t1749 := p._make_value_string(msg.GetNewLine()) - result = append(result, []interface{}{"csv_new_line", _t1749}) - } - _t1750 := p._make_value_string(msg.GetDelimiter()) - result = append(result, []interface{}{"csv_delimiter", _t1750}) - _t1751 := p._make_value_string(msg.GetQuotechar()) - result = append(result, []interface{}{"csv_quotechar", _t1751}) - _t1752 := p._make_value_string(msg.GetEscapechar()) - result = append(result, []interface{}{"csv_escapechar", _t1752}) + _t1753 := p._make_value_string(msg.GetNewLine()) + result = append(result, []interface{}{"csv_new_line", _t1753}) + } + _t1754 := p._make_value_string(msg.GetDelimiter()) + result = append(result, []interface{}{"csv_delimiter", _t1754}) + _t1755 := p._make_value_string(msg.GetQuotechar()) + result = append(result, []interface{}{"csv_quotechar", _t1755}) + _t1756 := p._make_value_string(msg.GetEscapechar()) + result = append(result, []interface{}{"csv_escapechar", _t1756}) if msg.GetComment() != "" { - _t1753 := p._make_value_string(msg.GetComment()) - result = append(result, []interface{}{"csv_comment", _t1753}) + _t1757 := p._make_value_string(msg.GetComment()) + result = append(result, []interface{}{"csv_comment", _t1757}) } for _, missing_string := range msg.GetMissingStrings() { - _t1754 := p._make_value_string(missing_string) - result = append(result, []interface{}{"csv_missing_strings", _t1754}) - } - _t1755 := p._make_value_string(msg.GetDecimalSeparator()) - result = append(result, []interface{}{"csv_decimal_separator", _t1755}) - _t1756 := p._make_value_string(msg.GetEncoding()) - result = append(result, []interface{}{"csv_encoding", _t1756}) - _t1757 := p._make_value_string(msg.GetCompression()) - result = append(result, []interface{}{"csv_compression", _t1757}) + _t1758 := p._make_value_string(missing_string) + result = append(result, []interface{}{"csv_missing_strings", _t1758}) + } + _t1759 := p._make_value_string(msg.GetDecimalSeparator()) + result = append(result, []interface{}{"csv_decimal_separator", _t1759}) + _t1760 := p._make_value_string(msg.GetEncoding()) + result = append(result, []interface{}{"csv_encoding", _t1760}) + _t1761 := p._make_value_string(msg.GetCompression()) + result = append(result, []interface{}{"csv_compression", _t1761}) if msg.GetPartitionSizeMb() != 0 { - _t1758 := p._make_value_int64(msg.GetPartitionSizeMb()) - result = append(result, []interface{}{"csv_partition_size_mb", _t1758}) + _t1762 := p._make_value_int64(msg.GetPartitionSizeMb()) + result = append(result, []interface{}{"csv_partition_size_mb", _t1762}) } return listSort(result) } func (p *PrettyPrinter) deconstruct_betree_info_config(msg *pb.BeTreeInfo) [][]interface{} { result := [][]interface{}{} - _t1759 := p._make_value_float64(msg.GetStorageConfig().GetEpsilon()) - result = append(result, []interface{}{"betree_config_epsilon", _t1759}) - _t1760 := p._make_value_int64(msg.GetStorageConfig().GetMaxPivots()) - result = append(result, []interface{}{"betree_config_max_pivots", _t1760}) - _t1761 := p._make_value_int64(msg.GetStorageConfig().GetMaxDeltas()) - result = append(result, []interface{}{"betree_config_max_deltas", _t1761}) - _t1762 := p._make_value_int64(msg.GetStorageConfig().GetMaxLeaf()) - result = append(result, []interface{}{"betree_config_max_leaf", _t1762}) + _t1763 := p._make_value_float64(msg.GetStorageConfig().GetEpsilon()) + result = append(result, []interface{}{"betree_config_epsilon", _t1763}) + _t1764 := p._make_value_int64(msg.GetStorageConfig().GetMaxPivots()) + result = append(result, []interface{}{"betree_config_max_pivots", _t1764}) + _t1765 := p._make_value_int64(msg.GetStorageConfig().GetMaxDeltas()) + result = append(result, []interface{}{"betree_config_max_deltas", _t1765}) + _t1766 := p._make_value_int64(msg.GetStorageConfig().GetMaxLeaf()) + result = append(result, []interface{}{"betree_config_max_leaf", _t1766}) if hasProtoField(msg.GetRelationLocator(), "root_pageid") { if msg.GetRelationLocator().GetRootPageid() != nil { - _t1763 := p._make_value_uint128(msg.GetRelationLocator().GetRootPageid()) - result = append(result, []interface{}{"betree_locator_root_pageid", _t1763}) + _t1767 := p._make_value_uint128(msg.GetRelationLocator().GetRootPageid()) + result = append(result, []interface{}{"betree_locator_root_pageid", _t1767}) } } if hasProtoField(msg.GetRelationLocator(), "inline_data") { if msg.GetRelationLocator().GetInlineData() != nil { - _t1764 := p._make_value_string(string(msg.GetRelationLocator().GetInlineData())) - result = append(result, []interface{}{"betree_locator_inline_data", _t1764}) + _t1768 := p._make_value_string(string(msg.GetRelationLocator().GetInlineData())) + result = append(result, []interface{}{"betree_locator_inline_data", _t1768}) } } - _t1765 := p._make_value_int64(msg.GetRelationLocator().GetElementCount()) - result = append(result, []interface{}{"betree_locator_element_count", _t1765}) - _t1766 := p._make_value_int64(msg.GetRelationLocator().GetTreeHeight()) - result = append(result, []interface{}{"betree_locator_tree_height", _t1766}) + _t1769 := p._make_value_int64(msg.GetRelationLocator().GetElementCount()) + result = append(result, []interface{}{"betree_locator_element_count", _t1769}) + _t1770 := p._make_value_int64(msg.GetRelationLocator().GetTreeHeight()) + result = append(result, []interface{}{"betree_locator_tree_height", _t1770}) return listSort(result) } func (p *PrettyPrinter) deconstruct_export_csv_config(msg *pb.ExportCSVConfig) [][]interface{} { result := [][]interface{}{} if msg.PartitionSize != nil { - _t1767 := p._make_value_int64(*msg.PartitionSize) - result = append(result, []interface{}{"partition_size", _t1767}) + _t1771 := p._make_value_int64(*msg.PartitionSize) + result = append(result, []interface{}{"partition_size", _t1771}) } if msg.Compression != nil { - _t1768 := p._make_value_string(*msg.Compression) - result = append(result, []interface{}{"compression", _t1768}) + _t1772 := p._make_value_string(*msg.Compression) + result = append(result, []interface{}{"compression", _t1772}) } if msg.SyntaxHeaderRow != nil { - _t1769 := p._make_value_boolean(*msg.SyntaxHeaderRow) - result = append(result, []interface{}{"syntax_header_row", _t1769}) + _t1773 := p._make_value_boolean(*msg.SyntaxHeaderRow) + result = append(result, []interface{}{"syntax_header_row", _t1773}) } if msg.SyntaxMissingString != nil { - _t1770 := p._make_value_string(*msg.SyntaxMissingString) - result = append(result, []interface{}{"syntax_missing_string", _t1770}) + _t1774 := p._make_value_string(*msg.SyntaxMissingString) + result = append(result, []interface{}{"syntax_missing_string", _t1774}) } if msg.SyntaxDelim != nil { - _t1771 := p._make_value_string(*msg.SyntaxDelim) - result = append(result, []interface{}{"syntax_delim", _t1771}) + _t1775 := p._make_value_string(*msg.SyntaxDelim) + result = append(result, []interface{}{"syntax_delim", _t1775}) } if msg.SyntaxQuotechar != nil { - _t1772 := p._make_value_string(*msg.SyntaxQuotechar) - result = append(result, []interface{}{"syntax_quotechar", _t1772}) + _t1776 := p._make_value_string(*msg.SyntaxQuotechar) + result = append(result, []interface{}{"syntax_quotechar", _t1776}) } if msg.SyntaxEscapechar != nil { - _t1773 := p._make_value_string(*msg.SyntaxEscapechar) - result = append(result, []interface{}{"syntax_escapechar", _t1773}) + _t1777 := p._make_value_string(*msg.SyntaxEscapechar) + result = append(result, []interface{}{"syntax_escapechar", _t1777}) } return listSort(result) } @@ -503,51 +503,51 @@ func (p *PrettyPrinter) mask_secret_value(pair []interface{}) string { } func (p *PrettyPrinter) deconstruct_iceberg_catalog_config_scope_optional(msg *pb.IcebergCatalogConfig) *string { - var _t1774 interface{} + var _t1778 interface{} if *msg.Scope != "" { return ptr(*msg.Scope) } - _ = _t1774 + _ = _t1778 return nil } func (p *PrettyPrinter) deconstruct_iceberg_data_from_snapshot_optional(msg *pb.IcebergData) *string { - var _t1775 interface{} + var _t1779 interface{} if *msg.FromSnapshot != "" { return ptr(*msg.FromSnapshot) } - _ = _t1775 + _ = _t1779 return nil } func (p *PrettyPrinter) deconstruct_iceberg_data_to_snapshot_optional(msg *pb.IcebergData) *string { - var _t1776 interface{} + var _t1780 interface{} if *msg.ToSnapshot != "" { return ptr(*msg.ToSnapshot) } - _ = _t1776 + _ = _t1780 return nil } func (p *PrettyPrinter) deconstruct_export_iceberg_config_optional(msg *pb.ExportIcebergConfig) [][]interface{} { result := [][]interface{}{} if *msg.Prefix != "" { - _t1777 := p._make_value_string(*msg.Prefix) - result = append(result, []interface{}{"prefix", _t1777}) + _t1781 := p._make_value_string(*msg.Prefix) + result = append(result, []interface{}{"prefix", _t1781}) } if *msg.TargetFileSizeBytes != 0 { - _t1778 := p._make_value_int64(*msg.TargetFileSizeBytes) - result = append(result, []interface{}{"target_file_size_bytes", _t1778}) + _t1782 := p._make_value_int64(*msg.TargetFileSizeBytes) + result = append(result, []interface{}{"target_file_size_bytes", _t1782}) } if msg.GetCompression() != "" { - _t1779 := p._make_value_string(msg.GetCompression()) - result = append(result, []interface{}{"compression", _t1779}) + _t1783 := p._make_value_string(msg.GetCompression()) + result = append(result, []interface{}{"compression", _t1783}) } - var _t1780 interface{} + var _t1784 interface{} if int64(len(result)) == 0 { return nil } - _ = _t1780 + _ = _t1784 return listSort(result) } @@ -558,11 +558,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 _t1781 interface{} + var _t1785 interface{} if name == nil { return p.relationIdToUint128(msg) } - _ = _t1781 + _ = _t1785 return nil } @@ -580,45 +580,45 @@ func (p *PrettyPrinter) deconstruct_bindings_with_arity(abs *pb.Abstraction, val // --- Pretty-print methods --- func (p *PrettyPrinter) pretty_transaction(msg *pb.Transaction) interface{} { - flat807 := p.tryFlat(msg, func() { p.pretty_transaction(msg) }) - if flat807 != nil { - p.write(*flat807) + flat809 := p.tryFlat(msg, func() { p.pretty_transaction(msg) }) + if flat809 != nil { + p.write(*flat809) return nil } else { _dollar_dollar := msg - var _t1596 *pb.Configure + var _t1600 *pb.Configure if hasProtoField(_dollar_dollar, "configure") { - _t1596 = _dollar_dollar.GetConfigure() + _t1600 = _dollar_dollar.GetConfigure() } - var _t1597 *pb.Sync + var _t1601 *pb.Sync if hasProtoField(_dollar_dollar, "sync") { - _t1597 = _dollar_dollar.GetSync() + _t1601 = _dollar_dollar.GetSync() } - fields798 := []interface{}{_t1596, _t1597, _dollar_dollar.GetEpochs()} - unwrapped_fields799 := fields798 + fields800 := []interface{}{_t1600, _t1601, _dollar_dollar.GetEpochs()} + unwrapped_fields801 := fields800 p.write("(") p.write("transaction") p.indentSexp() - field800 := unwrapped_fields799[0].(*pb.Configure) - if field800 != nil { - p.newline() - opt_val801 := field800 - p.pretty_configure(opt_val801) - } - field802 := unwrapped_fields799[1].(*pb.Sync) + field802 := unwrapped_fields801[0].(*pb.Configure) if field802 != nil { p.newline() opt_val803 := field802 - p.pretty_sync(opt_val803) + p.pretty_configure(opt_val803) } - field804 := unwrapped_fields799[2].([]*pb.Epoch) - if !(len(field804) == 0) { + field804 := unwrapped_fields801[1].(*pb.Sync) + if field804 != nil { p.newline() - for i806, elem805 := range field804 { - if (i806 > 0) { + opt_val805 := field804 + p.pretty_sync(opt_val805) + } + field806 := unwrapped_fields801[2].([]*pb.Epoch) + if !(len(field806) == 0) { + p.newline() + for i808, elem807 := range field806 { + if (i808 > 0) { p.newline() } - p.pretty_epoch(elem805) + p.pretty_epoch(elem807) } } p.dedent() @@ -628,20 +628,20 @@ func (p *PrettyPrinter) pretty_transaction(msg *pb.Transaction) interface{} { } func (p *PrettyPrinter) pretty_configure(msg *pb.Configure) interface{} { - flat810 := p.tryFlat(msg, func() { p.pretty_configure(msg) }) - if flat810 != nil { - p.write(*flat810) + flat812 := p.tryFlat(msg, func() { p.pretty_configure(msg) }) + if flat812 != nil { + p.write(*flat812) return nil } else { _dollar_dollar := msg - _t1598 := p.deconstruct_configure(_dollar_dollar) - fields808 := _t1598 - unwrapped_fields809 := fields808 + _t1602 := p.deconstruct_configure(_dollar_dollar) + fields810 := _t1602 + unwrapped_fields811 := fields810 p.write("(") p.write("configure") p.indentSexp() p.newline() - p.pretty_config_dict(unwrapped_fields809) + p.pretty_config_dict(unwrapped_fields811) p.dedent() p.write(")") } @@ -649,21 +649,21 @@ func (p *PrettyPrinter) pretty_configure(msg *pb.Configure) interface{} { } func (p *PrettyPrinter) pretty_config_dict(msg [][]interface{}) interface{} { - flat814 := p.tryFlat(msg, func() { p.pretty_config_dict(msg) }) - if flat814 != nil { - p.write(*flat814) + flat816 := p.tryFlat(msg, func() { p.pretty_config_dict(msg) }) + if flat816 != nil { + p.write(*flat816) return nil } else { - fields811 := msg + fields813 := msg p.write("{") p.indent() - if !(len(fields811) == 0) { + if !(len(fields813) == 0) { p.newline() - for i813, elem812 := range fields811 { - if (i813 > 0) { + for i815, elem814 := range fields813 { + if (i815 > 0) { p.newline() } - p.pretty_config_key_value(elem812) + p.pretty_config_key_value(elem814) } } p.dedent() @@ -673,152 +673,152 @@ func (p *PrettyPrinter) pretty_config_dict(msg [][]interface{}) interface{} { } func (p *PrettyPrinter) pretty_config_key_value(msg []interface{}) interface{} { - flat819 := p.tryFlat(msg, func() { p.pretty_config_key_value(msg) }) - if flat819 != nil { - p.write(*flat819) + flat821 := p.tryFlat(msg, func() { p.pretty_config_key_value(msg) }) + if flat821 != nil { + p.write(*flat821) return nil } else { _dollar_dollar := msg - fields815 := []interface{}{_dollar_dollar[0].(string), _dollar_dollar[1].(*pb.Value)} - unwrapped_fields816 := fields815 + fields817 := []interface{}{_dollar_dollar[0].(string), _dollar_dollar[1].(*pb.Value)} + unwrapped_fields818 := fields817 p.write(":") - field817 := unwrapped_fields816[0].(string) - p.write(field817) + field819 := unwrapped_fields818[0].(string) + p.write(field819) p.write(" ") - field818 := unwrapped_fields816[1].(*pb.Value) - p.pretty_raw_value(field818) + field820 := unwrapped_fields818[1].(*pb.Value) + p.pretty_raw_value(field820) } return nil } func (p *PrettyPrinter) pretty_raw_value(msg *pb.Value) interface{} { - flat845 := p.tryFlat(msg, func() { p.pretty_raw_value(msg) }) - if flat845 != nil { - p.write(*flat845) + flat847 := p.tryFlat(msg, func() { p.pretty_raw_value(msg) }) + if flat847 != nil { + p.write(*flat847) return nil } else { _dollar_dollar := msg - var _t1599 *pb.DateValue + var _t1603 *pb.DateValue if hasProtoField(_dollar_dollar, "date_value") { - _t1599 = _dollar_dollar.GetDateValue() + _t1603 = _dollar_dollar.GetDateValue() } - deconstruct_result843 := _t1599 - if deconstruct_result843 != nil { - unwrapped844 := deconstruct_result843 - p.pretty_raw_date(unwrapped844) + deconstruct_result845 := _t1603 + if deconstruct_result845 != nil { + unwrapped846 := deconstruct_result845 + p.pretty_raw_date(unwrapped846) } else { _dollar_dollar := msg - var _t1600 *pb.DateTimeValue + var _t1604 *pb.DateTimeValue if hasProtoField(_dollar_dollar, "datetime_value") { - _t1600 = _dollar_dollar.GetDatetimeValue() + _t1604 = _dollar_dollar.GetDatetimeValue() } - deconstruct_result841 := _t1600 - if deconstruct_result841 != nil { - unwrapped842 := deconstruct_result841 - p.pretty_raw_datetime(unwrapped842) + deconstruct_result843 := _t1604 + if deconstruct_result843 != nil { + unwrapped844 := deconstruct_result843 + p.pretty_raw_datetime(unwrapped844) } else { _dollar_dollar := msg - var _t1601 *string + var _t1605 *string if hasProtoField(_dollar_dollar, "string_value") { - _t1601 = ptr(_dollar_dollar.GetStringValue()) + _t1605 = ptr(_dollar_dollar.GetStringValue()) } - deconstruct_result839 := _t1601 - if deconstruct_result839 != nil { - unwrapped840 := *deconstruct_result839 - p.write(p.formatStringValue(unwrapped840)) + deconstruct_result841 := _t1605 + if deconstruct_result841 != nil { + unwrapped842 := *deconstruct_result841 + p.write(p.formatStringValue(unwrapped842)) } else { _dollar_dollar := msg - var _t1602 *int32 + var _t1606 *int32 if hasProtoField(_dollar_dollar, "int32_value") { - _t1602 = ptr(_dollar_dollar.GetInt32Value()) + _t1606 = ptr(_dollar_dollar.GetInt32Value()) } - deconstruct_result837 := _t1602 - if deconstruct_result837 != nil { - unwrapped838 := *deconstruct_result837 - p.write(fmt.Sprintf("%di32", unwrapped838)) + deconstruct_result839 := _t1606 + if deconstruct_result839 != nil { + unwrapped840 := *deconstruct_result839 + p.write(fmt.Sprintf("%di32", unwrapped840)) } else { _dollar_dollar := msg - var _t1603 *int64 + var _t1607 *int64 if hasProtoField(_dollar_dollar, "int_value") { - _t1603 = ptr(_dollar_dollar.GetIntValue()) + _t1607 = ptr(_dollar_dollar.GetIntValue()) } - deconstruct_result835 := _t1603 - if deconstruct_result835 != nil { - unwrapped836 := *deconstruct_result835 - p.write(fmt.Sprintf("%d", unwrapped836)) + deconstruct_result837 := _t1607 + if deconstruct_result837 != nil { + unwrapped838 := *deconstruct_result837 + p.write(fmt.Sprintf("%d", unwrapped838)) } else { _dollar_dollar := msg - var _t1604 *float32 + var _t1608 *float32 if hasProtoField(_dollar_dollar, "float32_value") { - _t1604 = ptr(_dollar_dollar.GetFloat32Value()) + _t1608 = ptr(_dollar_dollar.GetFloat32Value()) } - deconstruct_result833 := _t1604 - if deconstruct_result833 != nil { - unwrapped834 := *deconstruct_result833 - p.write(formatFloat32(unwrapped834)) + deconstruct_result835 := _t1608 + if deconstruct_result835 != nil { + unwrapped836 := *deconstruct_result835 + p.write(formatFloat32(unwrapped836)) } else { _dollar_dollar := msg - var _t1605 *float64 + var _t1609 *float64 if hasProtoField(_dollar_dollar, "float_value") { - _t1605 = ptr(_dollar_dollar.GetFloatValue()) + _t1609 = ptr(_dollar_dollar.GetFloatValue()) } - deconstruct_result831 := _t1605 - if deconstruct_result831 != nil { - unwrapped832 := *deconstruct_result831 - p.write(formatFloat64(unwrapped832)) + deconstruct_result833 := _t1609 + if deconstruct_result833 != nil { + unwrapped834 := *deconstruct_result833 + p.write(formatFloat64(unwrapped834)) } else { _dollar_dollar := msg - var _t1606 *uint32 + var _t1610 *uint32 if hasProtoField(_dollar_dollar, "uint32_value") { - _t1606 = ptr(_dollar_dollar.GetUint32Value()) + _t1610 = ptr(_dollar_dollar.GetUint32Value()) } - deconstruct_result829 := _t1606 - if deconstruct_result829 != nil { - unwrapped830 := *deconstruct_result829 - p.write(fmt.Sprintf("%du32", unwrapped830)) + deconstruct_result831 := _t1610 + if deconstruct_result831 != nil { + unwrapped832 := *deconstruct_result831 + p.write(fmt.Sprintf("%du32", unwrapped832)) } else { _dollar_dollar := msg - var _t1607 *pb.UInt128Value + var _t1611 *pb.UInt128Value if hasProtoField(_dollar_dollar, "uint128_value") { - _t1607 = _dollar_dollar.GetUint128Value() + _t1611 = _dollar_dollar.GetUint128Value() } - deconstruct_result827 := _t1607 - if deconstruct_result827 != nil { - unwrapped828 := deconstruct_result827 - p.write(p.formatUint128(unwrapped828)) + deconstruct_result829 := _t1611 + if deconstruct_result829 != nil { + unwrapped830 := deconstruct_result829 + p.write(p.formatUint128(unwrapped830)) } else { _dollar_dollar := msg - var _t1608 *pb.Int128Value + var _t1612 *pb.Int128Value if hasProtoField(_dollar_dollar, "int128_value") { - _t1608 = _dollar_dollar.GetInt128Value() + _t1612 = _dollar_dollar.GetInt128Value() } - deconstruct_result825 := _t1608 - if deconstruct_result825 != nil { - unwrapped826 := deconstruct_result825 - p.write(p.formatInt128(unwrapped826)) + deconstruct_result827 := _t1612 + if deconstruct_result827 != nil { + unwrapped828 := deconstruct_result827 + p.write(p.formatInt128(unwrapped828)) } else { _dollar_dollar := msg - var _t1609 *pb.DecimalValue + var _t1613 *pb.DecimalValue if hasProtoField(_dollar_dollar, "decimal_value") { - _t1609 = _dollar_dollar.GetDecimalValue() + _t1613 = _dollar_dollar.GetDecimalValue() } - deconstruct_result823 := _t1609 - if deconstruct_result823 != nil { - unwrapped824 := deconstruct_result823 - p.write(p.formatDecimal(unwrapped824)) + deconstruct_result825 := _t1613 + if deconstruct_result825 != nil { + unwrapped826 := deconstruct_result825 + p.write(p.formatDecimal(unwrapped826)) } else { _dollar_dollar := msg - var _t1610 *bool + var _t1614 *bool if hasProtoField(_dollar_dollar, "boolean_value") { - _t1610 = ptr(_dollar_dollar.GetBooleanValue()) + _t1614 = ptr(_dollar_dollar.GetBooleanValue()) } - deconstruct_result821 := _t1610 - if deconstruct_result821 != nil { - unwrapped822 := *deconstruct_result821 - p.pretty_boolean_value(unwrapped822) + deconstruct_result823 := _t1614 + if deconstruct_result823 != nil { + unwrapped824 := *deconstruct_result823 + p.pretty_boolean_value(unwrapped824) } else { - fields820 := msg - _ = fields820 + fields822 := msg + _ = fields822 p.write("missing") } } @@ -837,26 +837,26 @@ func (p *PrettyPrinter) pretty_raw_value(msg *pb.Value) interface{} { } func (p *PrettyPrinter) pretty_raw_date(msg *pb.DateValue) interface{} { - flat851 := p.tryFlat(msg, func() { p.pretty_raw_date(msg) }) - if flat851 != nil { - p.write(*flat851) + flat853 := p.tryFlat(msg, func() { p.pretty_raw_date(msg) }) + if flat853 != nil { + p.write(*flat853) return nil } else { _dollar_dollar := msg - fields846 := []interface{}{int64(_dollar_dollar.GetYear()), int64(_dollar_dollar.GetMonth()), int64(_dollar_dollar.GetDay())} - unwrapped_fields847 := fields846 + fields848 := []interface{}{int64(_dollar_dollar.GetYear()), int64(_dollar_dollar.GetMonth()), int64(_dollar_dollar.GetDay())} + unwrapped_fields849 := fields848 p.write("(") p.write("date") p.indentSexp() p.newline() - field848 := unwrapped_fields847[0].(int64) - p.write(fmt.Sprintf("%d", field848)) + field850 := unwrapped_fields849[0].(int64) + p.write(fmt.Sprintf("%d", field850)) p.newline() - field849 := unwrapped_fields847[1].(int64) - p.write(fmt.Sprintf("%d", field849)) + field851 := unwrapped_fields849[1].(int64) + p.write(fmt.Sprintf("%d", field851)) p.newline() - field850 := unwrapped_fields847[2].(int64) - p.write(fmt.Sprintf("%d", field850)) + field852 := unwrapped_fields849[2].(int64) + p.write(fmt.Sprintf("%d", field852)) p.dedent() p.write(")") } @@ -864,40 +864,40 @@ func (p *PrettyPrinter) pretty_raw_date(msg *pb.DateValue) interface{} { } func (p *PrettyPrinter) pretty_raw_datetime(msg *pb.DateTimeValue) interface{} { - flat862 := p.tryFlat(msg, func() { p.pretty_raw_datetime(msg) }) - if flat862 != nil { - p.write(*flat862) + flat864 := p.tryFlat(msg, func() { p.pretty_raw_datetime(msg) }) + if flat864 != nil { + p.write(*flat864) return nil } else { _dollar_dollar := msg - fields852 := []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_fields853 := fields852 + fields854 := []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_fields855 := fields854 p.write("(") p.write("datetime") p.indentSexp() p.newline() - field854 := unwrapped_fields853[0].(int64) - p.write(fmt.Sprintf("%d", field854)) - p.newline() - field855 := unwrapped_fields853[1].(int64) - p.write(fmt.Sprintf("%d", field855)) - p.newline() - field856 := unwrapped_fields853[2].(int64) + field856 := unwrapped_fields855[0].(int64) p.write(fmt.Sprintf("%d", field856)) p.newline() - field857 := unwrapped_fields853[3].(int64) + field857 := unwrapped_fields855[1].(int64) p.write(fmt.Sprintf("%d", field857)) p.newline() - field858 := unwrapped_fields853[4].(int64) + field858 := unwrapped_fields855[2].(int64) p.write(fmt.Sprintf("%d", field858)) p.newline() - field859 := unwrapped_fields853[5].(int64) + field859 := unwrapped_fields855[3].(int64) p.write(fmt.Sprintf("%d", field859)) - field860 := unwrapped_fields853[6].(*int64) - if field860 != nil { + p.newline() + field860 := unwrapped_fields855[4].(int64) + p.write(fmt.Sprintf("%d", field860)) + p.newline() + field861 := unwrapped_fields855[5].(int64) + p.write(fmt.Sprintf("%d", field861)) + field862 := unwrapped_fields855[6].(*int64) + if field862 != nil { p.newline() - opt_val861 := *field860 - p.write(fmt.Sprintf("%d", opt_val861)) + opt_val863 := *field862 + p.write(fmt.Sprintf("%d", opt_val863)) } p.dedent() p.write(")") @@ -907,25 +907,25 @@ func (p *PrettyPrinter) pretty_raw_datetime(msg *pb.DateTimeValue) interface{} { func (p *PrettyPrinter) pretty_boolean_value(msg bool) interface{} { _dollar_dollar := msg - var _t1611 []interface{} + var _t1615 []interface{} if _dollar_dollar { - _t1611 = []interface{}{} + _t1615 = []interface{}{} } - deconstruct_result865 := _t1611 - if deconstruct_result865 != nil { - unwrapped866 := deconstruct_result865 - _ = unwrapped866 + deconstruct_result867 := _t1615 + if deconstruct_result867 != nil { + unwrapped868 := deconstruct_result867 + _ = unwrapped868 p.write("true") } else { _dollar_dollar := msg - var _t1612 []interface{} + var _t1616 []interface{} if !(_dollar_dollar) { - _t1612 = []interface{}{} + _t1616 = []interface{}{} } - deconstruct_result863 := _t1612 - if deconstruct_result863 != nil { - unwrapped864 := deconstruct_result863 - _ = unwrapped864 + deconstruct_result865 := _t1616 + if deconstruct_result865 != nil { + unwrapped866 := deconstruct_result865 + _ = unwrapped866 p.write("false") } else { panic(ParseError{msg: "No matching rule for boolean_value"}) @@ -935,24 +935,24 @@ func (p *PrettyPrinter) pretty_boolean_value(msg bool) interface{} { } func (p *PrettyPrinter) pretty_sync(msg *pb.Sync) interface{} { - flat871 := p.tryFlat(msg, func() { p.pretty_sync(msg) }) - if flat871 != nil { - p.write(*flat871) + flat873 := p.tryFlat(msg, func() { p.pretty_sync(msg) }) + if flat873 != nil { + p.write(*flat873) return nil } else { _dollar_dollar := msg - fields867 := _dollar_dollar.GetFragments() - unwrapped_fields868 := fields867 + fields869 := _dollar_dollar.GetFragments() + unwrapped_fields870 := fields869 p.write("(") p.write("sync") p.indentSexp() - if !(len(unwrapped_fields868) == 0) { + if !(len(unwrapped_fields870) == 0) { p.newline() - for i870, elem869 := range unwrapped_fields868 { - if (i870 > 0) { + for i872, elem871 := range unwrapped_fields870 { + if (i872 > 0) { p.newline() } - p.pretty_fragment_id(elem869) + p.pretty_fragment_id(elem871) } } p.dedent() @@ -962,51 +962,51 @@ func (p *PrettyPrinter) pretty_sync(msg *pb.Sync) interface{} { } func (p *PrettyPrinter) pretty_fragment_id(msg *pb.FragmentId) interface{} { - flat874 := p.tryFlat(msg, func() { p.pretty_fragment_id(msg) }) - if flat874 != nil { - p.write(*flat874) + flat876 := p.tryFlat(msg, func() { p.pretty_fragment_id(msg) }) + if flat876 != nil { + p.write(*flat876) return nil } else { _dollar_dollar := msg - fields872 := p.fragmentIdToString(_dollar_dollar) - unwrapped_fields873 := fields872 + fields874 := p.fragmentIdToString(_dollar_dollar) + unwrapped_fields875 := fields874 p.write(":") - p.write(unwrapped_fields873) + p.write(unwrapped_fields875) } return nil } func (p *PrettyPrinter) pretty_epoch(msg *pb.Epoch) interface{} { - flat881 := p.tryFlat(msg, func() { p.pretty_epoch(msg) }) - if flat881 != nil { - p.write(*flat881) + flat883 := p.tryFlat(msg, func() { p.pretty_epoch(msg) }) + if flat883 != nil { + p.write(*flat883) return nil } else { _dollar_dollar := msg - var _t1613 []*pb.Write + var _t1617 []*pb.Write if !(len(_dollar_dollar.GetWrites()) == 0) { - _t1613 = _dollar_dollar.GetWrites() + _t1617 = _dollar_dollar.GetWrites() } - var _t1614 []*pb.Read + var _t1618 []*pb.Read if !(len(_dollar_dollar.GetReads()) == 0) { - _t1614 = _dollar_dollar.GetReads() + _t1618 = _dollar_dollar.GetReads() } - fields875 := []interface{}{_t1613, _t1614} - unwrapped_fields876 := fields875 + fields877 := []interface{}{_t1617, _t1618} + unwrapped_fields878 := fields877 p.write("(") p.write("epoch") p.indentSexp() - field877 := unwrapped_fields876[0].([]*pb.Write) - if field877 != nil { - p.newline() - opt_val878 := field877 - p.pretty_epoch_writes(opt_val878) - } - field879 := unwrapped_fields876[1].([]*pb.Read) + field879 := unwrapped_fields878[0].([]*pb.Write) if field879 != nil { p.newline() opt_val880 := field879 - p.pretty_epoch_reads(opt_val880) + p.pretty_epoch_writes(opt_val880) + } + field881 := unwrapped_fields878[1].([]*pb.Read) + if field881 != nil { + p.newline() + opt_val882 := field881 + p.pretty_epoch_reads(opt_val882) } p.dedent() p.write(")") @@ -1015,22 +1015,22 @@ func (p *PrettyPrinter) pretty_epoch(msg *pb.Epoch) interface{} { } func (p *PrettyPrinter) pretty_epoch_writes(msg []*pb.Write) interface{} { - flat885 := p.tryFlat(msg, func() { p.pretty_epoch_writes(msg) }) - if flat885 != nil { - p.write(*flat885) + flat887 := p.tryFlat(msg, func() { p.pretty_epoch_writes(msg) }) + if flat887 != nil { + p.write(*flat887) return nil } else { - fields882 := msg + fields884 := msg p.write("(") p.write("writes") p.indentSexp() - if !(len(fields882) == 0) { + if !(len(fields884) == 0) { p.newline() - for i884, elem883 := range fields882 { - if (i884 > 0) { + for i886, elem885 := range fields884 { + if (i886 > 0) { p.newline() } - p.pretty_write(elem883) + p.pretty_write(elem885) } } p.dedent() @@ -1040,50 +1040,50 @@ func (p *PrettyPrinter) pretty_epoch_writes(msg []*pb.Write) interface{} { } func (p *PrettyPrinter) pretty_write(msg *pb.Write) interface{} { - flat894 := p.tryFlat(msg, func() { p.pretty_write(msg) }) - if flat894 != nil { - p.write(*flat894) + flat896 := p.tryFlat(msg, func() { p.pretty_write(msg) }) + if flat896 != nil { + p.write(*flat896) return nil } else { _dollar_dollar := msg - var _t1615 *pb.Define + var _t1619 *pb.Define if hasProtoField(_dollar_dollar, "define") { - _t1615 = _dollar_dollar.GetDefine() + _t1619 = _dollar_dollar.GetDefine() } - deconstruct_result892 := _t1615 - if deconstruct_result892 != nil { - unwrapped893 := deconstruct_result892 - p.pretty_define(unwrapped893) + deconstruct_result894 := _t1619 + if deconstruct_result894 != nil { + unwrapped895 := deconstruct_result894 + p.pretty_define(unwrapped895) } else { _dollar_dollar := msg - var _t1616 *pb.Undefine + var _t1620 *pb.Undefine if hasProtoField(_dollar_dollar, "undefine") { - _t1616 = _dollar_dollar.GetUndefine() + _t1620 = _dollar_dollar.GetUndefine() } - deconstruct_result890 := _t1616 - if deconstruct_result890 != nil { - unwrapped891 := deconstruct_result890 - p.pretty_undefine(unwrapped891) + deconstruct_result892 := _t1620 + if deconstruct_result892 != nil { + unwrapped893 := deconstruct_result892 + p.pretty_undefine(unwrapped893) } else { _dollar_dollar := msg - var _t1617 *pb.Context + var _t1621 *pb.Context if hasProtoField(_dollar_dollar, "context") { - _t1617 = _dollar_dollar.GetContext() + _t1621 = _dollar_dollar.GetContext() } - deconstruct_result888 := _t1617 - if deconstruct_result888 != nil { - unwrapped889 := deconstruct_result888 - p.pretty_context(unwrapped889) + deconstruct_result890 := _t1621 + if deconstruct_result890 != nil { + unwrapped891 := deconstruct_result890 + p.pretty_context(unwrapped891) } else { _dollar_dollar := msg - var _t1618 *pb.Snapshot + var _t1622 *pb.Snapshot if hasProtoField(_dollar_dollar, "snapshot") { - _t1618 = _dollar_dollar.GetSnapshot() + _t1622 = _dollar_dollar.GetSnapshot() } - deconstruct_result886 := _t1618 - if deconstruct_result886 != nil { - unwrapped887 := deconstruct_result886 - p.pretty_snapshot(unwrapped887) + deconstruct_result888 := _t1622 + if deconstruct_result888 != nil { + unwrapped889 := deconstruct_result888 + p.pretty_snapshot(unwrapped889) } else { panic(ParseError{msg: "No matching rule for write"}) } @@ -1095,19 +1095,19 @@ func (p *PrettyPrinter) pretty_write(msg *pb.Write) interface{} { } func (p *PrettyPrinter) pretty_define(msg *pb.Define) interface{} { - flat897 := p.tryFlat(msg, func() { p.pretty_define(msg) }) - if flat897 != nil { - p.write(*flat897) + flat899 := p.tryFlat(msg, func() { p.pretty_define(msg) }) + if flat899 != nil { + p.write(*flat899) return nil } else { _dollar_dollar := msg - fields895 := _dollar_dollar.GetFragment() - unwrapped_fields896 := fields895 + fields897 := _dollar_dollar.GetFragment() + unwrapped_fields898 := fields897 p.write("(") p.write("define") p.indentSexp() p.newline() - p.pretty_fragment(unwrapped_fields896) + p.pretty_fragment(unwrapped_fields898) p.dedent() p.write(")") } @@ -1115,29 +1115,29 @@ func (p *PrettyPrinter) pretty_define(msg *pb.Define) interface{} { } func (p *PrettyPrinter) pretty_fragment(msg *pb.Fragment) interface{} { - flat904 := p.tryFlat(msg, func() { p.pretty_fragment(msg) }) - if flat904 != nil { - p.write(*flat904) + flat906 := p.tryFlat(msg, func() { p.pretty_fragment(msg) }) + if flat906 != nil { + p.write(*flat906) return nil } else { _dollar_dollar := msg p.startPrettyFragment(_dollar_dollar) - fields898 := []interface{}{_dollar_dollar.GetId(), _dollar_dollar.GetDeclarations()} - unwrapped_fields899 := fields898 + fields900 := []interface{}{_dollar_dollar.GetId(), _dollar_dollar.GetDeclarations()} + unwrapped_fields901 := fields900 p.write("(") p.write("fragment") p.indentSexp() p.newline() - field900 := unwrapped_fields899[0].(*pb.FragmentId) - p.pretty_new_fragment_id(field900) - field901 := unwrapped_fields899[1].([]*pb.Declaration) - if !(len(field901) == 0) { + field902 := unwrapped_fields901[0].(*pb.FragmentId) + p.pretty_new_fragment_id(field902) + field903 := unwrapped_fields901[1].([]*pb.Declaration) + if !(len(field903) == 0) { p.newline() - for i903, elem902 := range field901 { - if (i903 > 0) { + for i905, elem904 := range field903 { + if (i905 > 0) { p.newline() } - p.pretty_declaration(elem902) + p.pretty_declaration(elem904) } } p.dedent() @@ -1147,62 +1147,62 @@ func (p *PrettyPrinter) pretty_fragment(msg *pb.Fragment) interface{} { } func (p *PrettyPrinter) pretty_new_fragment_id(msg *pb.FragmentId) interface{} { - flat906 := p.tryFlat(msg, func() { p.pretty_new_fragment_id(msg) }) - if flat906 != nil { - p.write(*flat906) + flat908 := p.tryFlat(msg, func() { p.pretty_new_fragment_id(msg) }) + if flat908 != nil { + p.write(*flat908) return nil } else { - fields905 := msg - p.pretty_fragment_id(fields905) + fields907 := msg + p.pretty_fragment_id(fields907) } return nil } func (p *PrettyPrinter) pretty_declaration(msg *pb.Declaration) interface{} { - flat915 := p.tryFlat(msg, func() { p.pretty_declaration(msg) }) - if flat915 != nil { - p.write(*flat915) + flat917 := p.tryFlat(msg, func() { p.pretty_declaration(msg) }) + if flat917 != nil { + p.write(*flat917) return nil } else { _dollar_dollar := msg - var _t1619 *pb.Def + var _t1623 *pb.Def if hasProtoField(_dollar_dollar, "def") { - _t1619 = _dollar_dollar.GetDef() + _t1623 = _dollar_dollar.GetDef() } - deconstruct_result913 := _t1619 - if deconstruct_result913 != nil { - unwrapped914 := deconstruct_result913 - p.pretty_def(unwrapped914) + deconstruct_result915 := _t1623 + if deconstruct_result915 != nil { + unwrapped916 := deconstruct_result915 + p.pretty_def(unwrapped916) } else { _dollar_dollar := msg - var _t1620 *pb.Algorithm + var _t1624 *pb.Algorithm if hasProtoField(_dollar_dollar, "algorithm") { - _t1620 = _dollar_dollar.GetAlgorithm() + _t1624 = _dollar_dollar.GetAlgorithm() } - deconstruct_result911 := _t1620 - if deconstruct_result911 != nil { - unwrapped912 := deconstruct_result911 - p.pretty_algorithm(unwrapped912) + deconstruct_result913 := _t1624 + if deconstruct_result913 != nil { + unwrapped914 := deconstruct_result913 + p.pretty_algorithm(unwrapped914) } else { _dollar_dollar := msg - var _t1621 *pb.Constraint + var _t1625 *pb.Constraint if hasProtoField(_dollar_dollar, "constraint") { - _t1621 = _dollar_dollar.GetConstraint() + _t1625 = _dollar_dollar.GetConstraint() } - deconstruct_result909 := _t1621 - if deconstruct_result909 != nil { - unwrapped910 := deconstruct_result909 - p.pretty_constraint(unwrapped910) + deconstruct_result911 := _t1625 + if deconstruct_result911 != nil { + unwrapped912 := deconstruct_result911 + p.pretty_constraint(unwrapped912) } else { _dollar_dollar := msg - var _t1622 *pb.Data + var _t1626 *pb.Data if hasProtoField(_dollar_dollar, "data") { - _t1622 = _dollar_dollar.GetData() + _t1626 = _dollar_dollar.GetData() } - deconstruct_result907 := _t1622 - if deconstruct_result907 != nil { - unwrapped908 := deconstruct_result907 - p.pretty_data(unwrapped908) + deconstruct_result909 := _t1626 + if deconstruct_result909 != nil { + unwrapped910 := deconstruct_result909 + p.pretty_data(unwrapped910) } else { panic(ParseError{msg: "No matching rule for declaration"}) } @@ -1214,32 +1214,32 @@ func (p *PrettyPrinter) pretty_declaration(msg *pb.Declaration) interface{} { } func (p *PrettyPrinter) pretty_def(msg *pb.Def) interface{} { - flat922 := p.tryFlat(msg, func() { p.pretty_def(msg) }) - if flat922 != nil { - p.write(*flat922) + flat924 := p.tryFlat(msg, func() { p.pretty_def(msg) }) + if flat924 != nil { + p.write(*flat924) return nil } else { _dollar_dollar := msg - var _t1623 []*pb.Attribute + var _t1627 []*pb.Attribute if !(len(_dollar_dollar.GetAttrs()) == 0) { - _t1623 = _dollar_dollar.GetAttrs() + _t1627 = _dollar_dollar.GetAttrs() } - fields916 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetBody(), _t1623} - unwrapped_fields917 := fields916 + fields918 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetBody(), _t1627} + unwrapped_fields919 := fields918 p.write("(") p.write("def") p.indentSexp() p.newline() - field918 := unwrapped_fields917[0].(*pb.RelationId) - p.pretty_relation_id(field918) + field920 := unwrapped_fields919[0].(*pb.RelationId) + p.pretty_relation_id(field920) p.newline() - field919 := unwrapped_fields917[1].(*pb.Abstraction) - p.pretty_abstraction(field919) - field920 := unwrapped_fields917[2].([]*pb.Attribute) - if field920 != nil { + field921 := unwrapped_fields919[1].(*pb.Abstraction) + p.pretty_abstraction(field921) + field922 := unwrapped_fields919[2].([]*pb.Attribute) + if field922 != nil { p.newline() - opt_val921 := field920 - p.pretty_attrs(opt_val921) + opt_val923 := field922 + p.pretty_attrs(opt_val923) } p.dedent() p.write(")") @@ -1248,29 +1248,29 @@ func (p *PrettyPrinter) pretty_def(msg *pb.Def) interface{} { } func (p *PrettyPrinter) pretty_relation_id(msg *pb.RelationId) interface{} { - flat927 := p.tryFlat(msg, func() { p.pretty_relation_id(msg) }) - if flat927 != nil { - p.write(*flat927) + flat929 := p.tryFlat(msg, func() { p.pretty_relation_id(msg) }) + if flat929 != nil { + p.write(*flat929) return nil } else { _dollar_dollar := msg - var _t1624 *string + var _t1628 *string if p.relationIdToString(_dollar_dollar) != nil { - _t1625 := p.deconstruct_relation_id_string(_dollar_dollar) - _t1624 = ptr(_t1625) + _t1629 := p.deconstruct_relation_id_string(_dollar_dollar) + _t1628 = ptr(_t1629) } - deconstruct_result925 := _t1624 - if deconstruct_result925 != nil { - unwrapped926 := *deconstruct_result925 + deconstruct_result927 := _t1628 + if deconstruct_result927 != nil { + unwrapped928 := *deconstruct_result927 p.write(":") - p.write(unwrapped926) + p.write(unwrapped928) } else { _dollar_dollar := msg - _t1626 := p.deconstruct_relation_id_uint128(_dollar_dollar) - deconstruct_result923 := _t1626 - if deconstruct_result923 != nil { - unwrapped924 := deconstruct_result923 - p.write(p.formatUint128(unwrapped924)) + _t1630 := p.deconstruct_relation_id_uint128(_dollar_dollar) + deconstruct_result925 := _t1630 + if deconstruct_result925 != nil { + unwrapped926 := deconstruct_result925 + p.write(p.formatUint128(unwrapped926)) } else { panic(ParseError{msg: "No matching rule for relation_id"}) } @@ -1280,22 +1280,22 @@ func (p *PrettyPrinter) pretty_relation_id(msg *pb.RelationId) interface{} { } func (p *PrettyPrinter) pretty_abstraction(msg *pb.Abstraction) interface{} { - flat932 := p.tryFlat(msg, func() { p.pretty_abstraction(msg) }) - if flat932 != nil { - p.write(*flat932) + flat934 := p.tryFlat(msg, func() { p.pretty_abstraction(msg) }) + if flat934 != nil { + p.write(*flat934) return nil } else { _dollar_dollar := msg - _t1627 := p.deconstruct_bindings(_dollar_dollar) - fields928 := []interface{}{_t1627, _dollar_dollar.GetValue()} - unwrapped_fields929 := fields928 + _t1631 := p.deconstruct_bindings(_dollar_dollar) + fields930 := []interface{}{_t1631, _dollar_dollar.GetValue()} + unwrapped_fields931 := fields930 p.write("(") p.indent() - field930 := unwrapped_fields929[0].([]interface{}) - p.pretty_bindings(field930) + field932 := unwrapped_fields931[0].([]interface{}) + p.pretty_bindings(field932) p.newline() - field931 := unwrapped_fields929[1].(*pb.Formula) - p.pretty_formula(field931) + field933 := unwrapped_fields931[1].(*pb.Formula) + p.pretty_formula(field933) p.dedent() p.write(")") } @@ -1303,32 +1303,32 @@ func (p *PrettyPrinter) pretty_abstraction(msg *pb.Abstraction) interface{} { } func (p *PrettyPrinter) pretty_bindings(msg []interface{}) interface{} { - flat940 := p.tryFlat(msg, func() { p.pretty_bindings(msg) }) - if flat940 != nil { - p.write(*flat940) + flat942 := p.tryFlat(msg, func() { p.pretty_bindings(msg) }) + if flat942 != nil { + p.write(*flat942) return nil } else { _dollar_dollar := msg - var _t1628 []*pb.Binding + var _t1632 []*pb.Binding if !(len(_dollar_dollar[1].([]*pb.Binding)) == 0) { - _t1628 = _dollar_dollar[1].([]*pb.Binding) + _t1632 = _dollar_dollar[1].([]*pb.Binding) } - fields933 := []interface{}{_dollar_dollar[0].([]*pb.Binding), _t1628} - unwrapped_fields934 := fields933 + fields935 := []interface{}{_dollar_dollar[0].([]*pb.Binding), _t1632} + unwrapped_fields936 := fields935 p.write("[") p.indent() - field935 := unwrapped_fields934[0].([]*pb.Binding) - for i937, elem936 := range field935 { - if (i937 > 0) { + field937 := unwrapped_fields936[0].([]*pb.Binding) + for i939, elem938 := range field937 { + if (i939 > 0) { p.newline() } - p.pretty_binding(elem936) + p.pretty_binding(elem938) } - field938 := unwrapped_fields934[1].([]*pb.Binding) - if field938 != nil { + field940 := unwrapped_fields936[1].([]*pb.Binding) + if field940 != nil { p.newline() - opt_val939 := field938 - p.pretty_value_bindings(opt_val939) + opt_val941 := field940 + p.pretty_value_bindings(opt_val941) } p.dedent() p.write("]") @@ -1337,168 +1337,168 @@ func (p *PrettyPrinter) pretty_bindings(msg []interface{}) interface{} { } func (p *PrettyPrinter) pretty_binding(msg *pb.Binding) interface{} { - flat945 := p.tryFlat(msg, func() { p.pretty_binding(msg) }) - if flat945 != nil { - p.write(*flat945) + flat947 := p.tryFlat(msg, func() { p.pretty_binding(msg) }) + if flat947 != nil { + p.write(*flat947) return nil } else { _dollar_dollar := msg - fields941 := []interface{}{_dollar_dollar.GetVar().GetName(), _dollar_dollar.GetType()} - unwrapped_fields942 := fields941 - field943 := unwrapped_fields942[0].(string) - p.write(field943) + fields943 := []interface{}{_dollar_dollar.GetVar().GetName(), _dollar_dollar.GetType()} + unwrapped_fields944 := fields943 + field945 := unwrapped_fields944[0].(string) + p.write(field945) p.write("::") - field944 := unwrapped_fields942[1].(*pb.Type) - p.pretty_type(field944) + field946 := unwrapped_fields944[1].(*pb.Type) + p.pretty_type(field946) } return nil } func (p *PrettyPrinter) pretty_type(msg *pb.Type) interface{} { - flat974 := p.tryFlat(msg, func() { p.pretty_type(msg) }) - if flat974 != nil { - p.write(*flat974) + flat976 := p.tryFlat(msg, func() { p.pretty_type(msg) }) + if flat976 != nil { + p.write(*flat976) return nil } else { _dollar_dollar := msg - var _t1629 *pb.UnspecifiedType + var _t1633 *pb.UnspecifiedType if hasProtoField(_dollar_dollar, "unspecified_type") { - _t1629 = _dollar_dollar.GetUnspecifiedType() + _t1633 = _dollar_dollar.GetUnspecifiedType() } - deconstruct_result972 := _t1629 - if deconstruct_result972 != nil { - unwrapped973 := deconstruct_result972 - p.pretty_unspecified_type(unwrapped973) + deconstruct_result974 := _t1633 + if deconstruct_result974 != nil { + unwrapped975 := deconstruct_result974 + p.pretty_unspecified_type(unwrapped975) } else { _dollar_dollar := msg - var _t1630 *pb.StringType + var _t1634 *pb.StringType if hasProtoField(_dollar_dollar, "string_type") { - _t1630 = _dollar_dollar.GetStringType() + _t1634 = _dollar_dollar.GetStringType() } - deconstruct_result970 := _t1630 - if deconstruct_result970 != nil { - unwrapped971 := deconstruct_result970 - p.pretty_string_type(unwrapped971) + deconstruct_result972 := _t1634 + if deconstruct_result972 != nil { + unwrapped973 := deconstruct_result972 + p.pretty_string_type(unwrapped973) } else { _dollar_dollar := msg - var _t1631 *pb.IntType + var _t1635 *pb.IntType if hasProtoField(_dollar_dollar, "int_type") { - _t1631 = _dollar_dollar.GetIntType() + _t1635 = _dollar_dollar.GetIntType() } - deconstruct_result968 := _t1631 - if deconstruct_result968 != nil { - unwrapped969 := deconstruct_result968 - p.pretty_int_type(unwrapped969) + deconstruct_result970 := _t1635 + if deconstruct_result970 != nil { + unwrapped971 := deconstruct_result970 + p.pretty_int_type(unwrapped971) } else { _dollar_dollar := msg - var _t1632 *pb.FloatType + var _t1636 *pb.FloatType if hasProtoField(_dollar_dollar, "float_type") { - _t1632 = _dollar_dollar.GetFloatType() + _t1636 = _dollar_dollar.GetFloatType() } - deconstruct_result966 := _t1632 - if deconstruct_result966 != nil { - unwrapped967 := deconstruct_result966 - p.pretty_float_type(unwrapped967) + deconstruct_result968 := _t1636 + if deconstruct_result968 != nil { + unwrapped969 := deconstruct_result968 + p.pretty_float_type(unwrapped969) } else { _dollar_dollar := msg - var _t1633 *pb.UInt128Type + var _t1637 *pb.UInt128Type if hasProtoField(_dollar_dollar, "uint128_type") { - _t1633 = _dollar_dollar.GetUint128Type() + _t1637 = _dollar_dollar.GetUint128Type() } - deconstruct_result964 := _t1633 - if deconstruct_result964 != nil { - unwrapped965 := deconstruct_result964 - p.pretty_uint128_type(unwrapped965) + deconstruct_result966 := _t1637 + if deconstruct_result966 != nil { + unwrapped967 := deconstruct_result966 + p.pretty_uint128_type(unwrapped967) } else { _dollar_dollar := msg - var _t1634 *pb.Int128Type + var _t1638 *pb.Int128Type if hasProtoField(_dollar_dollar, "int128_type") { - _t1634 = _dollar_dollar.GetInt128Type() + _t1638 = _dollar_dollar.GetInt128Type() } - deconstruct_result962 := _t1634 - if deconstruct_result962 != nil { - unwrapped963 := deconstruct_result962 - p.pretty_int128_type(unwrapped963) + deconstruct_result964 := _t1638 + if deconstruct_result964 != nil { + unwrapped965 := deconstruct_result964 + p.pretty_int128_type(unwrapped965) } else { _dollar_dollar := msg - var _t1635 *pb.DateType + var _t1639 *pb.DateType if hasProtoField(_dollar_dollar, "date_type") { - _t1635 = _dollar_dollar.GetDateType() + _t1639 = _dollar_dollar.GetDateType() } - deconstruct_result960 := _t1635 - if deconstruct_result960 != nil { - unwrapped961 := deconstruct_result960 - p.pretty_date_type(unwrapped961) + deconstruct_result962 := _t1639 + if deconstruct_result962 != nil { + unwrapped963 := deconstruct_result962 + p.pretty_date_type(unwrapped963) } else { _dollar_dollar := msg - var _t1636 *pb.DateTimeType + var _t1640 *pb.DateTimeType if hasProtoField(_dollar_dollar, "datetime_type") { - _t1636 = _dollar_dollar.GetDatetimeType() + _t1640 = _dollar_dollar.GetDatetimeType() } - deconstruct_result958 := _t1636 - if deconstruct_result958 != nil { - unwrapped959 := deconstruct_result958 - p.pretty_datetime_type(unwrapped959) + deconstruct_result960 := _t1640 + if deconstruct_result960 != nil { + unwrapped961 := deconstruct_result960 + p.pretty_datetime_type(unwrapped961) } else { _dollar_dollar := msg - var _t1637 *pb.MissingType + var _t1641 *pb.MissingType if hasProtoField(_dollar_dollar, "missing_type") { - _t1637 = _dollar_dollar.GetMissingType() + _t1641 = _dollar_dollar.GetMissingType() } - deconstruct_result956 := _t1637 - if deconstruct_result956 != nil { - unwrapped957 := deconstruct_result956 - p.pretty_missing_type(unwrapped957) + deconstruct_result958 := _t1641 + if deconstruct_result958 != nil { + unwrapped959 := deconstruct_result958 + p.pretty_missing_type(unwrapped959) } else { _dollar_dollar := msg - var _t1638 *pb.DecimalType + var _t1642 *pb.DecimalType if hasProtoField(_dollar_dollar, "decimal_type") { - _t1638 = _dollar_dollar.GetDecimalType() + _t1642 = _dollar_dollar.GetDecimalType() } - deconstruct_result954 := _t1638 - if deconstruct_result954 != nil { - unwrapped955 := deconstruct_result954 - p.pretty_decimal_type(unwrapped955) + deconstruct_result956 := _t1642 + if deconstruct_result956 != nil { + unwrapped957 := deconstruct_result956 + p.pretty_decimal_type(unwrapped957) } else { _dollar_dollar := msg - var _t1639 *pb.BooleanType + var _t1643 *pb.BooleanType if hasProtoField(_dollar_dollar, "boolean_type") { - _t1639 = _dollar_dollar.GetBooleanType() + _t1643 = _dollar_dollar.GetBooleanType() } - deconstruct_result952 := _t1639 - if deconstruct_result952 != nil { - unwrapped953 := deconstruct_result952 - p.pretty_boolean_type(unwrapped953) + deconstruct_result954 := _t1643 + if deconstruct_result954 != nil { + unwrapped955 := deconstruct_result954 + p.pretty_boolean_type(unwrapped955) } else { _dollar_dollar := msg - var _t1640 *pb.Int32Type + var _t1644 *pb.Int32Type if hasProtoField(_dollar_dollar, "int32_type") { - _t1640 = _dollar_dollar.GetInt32Type() + _t1644 = _dollar_dollar.GetInt32Type() } - deconstruct_result950 := _t1640 - if deconstruct_result950 != nil { - unwrapped951 := deconstruct_result950 - p.pretty_int32_type(unwrapped951) + deconstruct_result952 := _t1644 + if deconstruct_result952 != nil { + unwrapped953 := deconstruct_result952 + p.pretty_int32_type(unwrapped953) } else { _dollar_dollar := msg - var _t1641 *pb.Float32Type + var _t1645 *pb.Float32Type if hasProtoField(_dollar_dollar, "float32_type") { - _t1641 = _dollar_dollar.GetFloat32Type() + _t1645 = _dollar_dollar.GetFloat32Type() } - deconstruct_result948 := _t1641 - if deconstruct_result948 != nil { - unwrapped949 := deconstruct_result948 - p.pretty_float32_type(unwrapped949) + deconstruct_result950 := _t1645 + if deconstruct_result950 != nil { + unwrapped951 := deconstruct_result950 + p.pretty_float32_type(unwrapped951) } else { _dollar_dollar := msg - var _t1642 *pb.UInt32Type + var _t1646 *pb.UInt32Type if hasProtoField(_dollar_dollar, "uint32_type") { - _t1642 = _dollar_dollar.GetUint32Type() + _t1646 = _dollar_dollar.GetUint32Type() } - deconstruct_result946 := _t1642 - if deconstruct_result946 != nil { - unwrapped947 := deconstruct_result946 - p.pretty_uint32_type(unwrapped947) + deconstruct_result948 := _t1646 + if deconstruct_result948 != nil { + unwrapped949 := deconstruct_result948 + p.pretty_uint32_type(unwrapped949) } else { panic(ParseError{msg: "No matching rule for type"}) } @@ -1520,86 +1520,86 @@ func (p *PrettyPrinter) pretty_type(msg *pb.Type) interface{} { } func (p *PrettyPrinter) pretty_unspecified_type(msg *pb.UnspecifiedType) interface{} { - fields975 := msg - _ = fields975 + fields977 := msg + _ = fields977 p.write("UNKNOWN") return nil } func (p *PrettyPrinter) pretty_string_type(msg *pb.StringType) interface{} { - fields976 := msg - _ = fields976 + fields978 := msg + _ = fields978 p.write("STRING") return nil } func (p *PrettyPrinter) pretty_int_type(msg *pb.IntType) interface{} { - fields977 := msg - _ = fields977 + fields979 := msg + _ = fields979 p.write("INT") return nil } func (p *PrettyPrinter) pretty_float_type(msg *pb.FloatType) interface{} { - fields978 := msg - _ = fields978 + fields980 := msg + _ = fields980 p.write("FLOAT") return nil } func (p *PrettyPrinter) pretty_uint128_type(msg *pb.UInt128Type) interface{} { - fields979 := msg - _ = fields979 + fields981 := msg + _ = fields981 p.write("UINT128") return nil } func (p *PrettyPrinter) pretty_int128_type(msg *pb.Int128Type) interface{} { - fields980 := msg - _ = fields980 + fields982 := msg + _ = fields982 p.write("INT128") return nil } func (p *PrettyPrinter) pretty_date_type(msg *pb.DateType) interface{} { - fields981 := msg - _ = fields981 + fields983 := msg + _ = fields983 p.write("DATE") return nil } func (p *PrettyPrinter) pretty_datetime_type(msg *pb.DateTimeType) interface{} { - fields982 := msg - _ = fields982 + fields984 := msg + _ = fields984 p.write("DATETIME") return nil } func (p *PrettyPrinter) pretty_missing_type(msg *pb.MissingType) interface{} { - fields983 := msg - _ = fields983 + fields985 := msg + _ = fields985 p.write("MISSING") return nil } func (p *PrettyPrinter) pretty_decimal_type(msg *pb.DecimalType) interface{} { - flat988 := p.tryFlat(msg, func() { p.pretty_decimal_type(msg) }) - if flat988 != nil { - p.write(*flat988) + flat990 := p.tryFlat(msg, func() { p.pretty_decimal_type(msg) }) + if flat990 != nil { + p.write(*flat990) return nil } else { _dollar_dollar := msg - fields984 := []interface{}{int64(_dollar_dollar.GetPrecision()), int64(_dollar_dollar.GetScale())} - unwrapped_fields985 := fields984 + fields986 := []interface{}{int64(_dollar_dollar.GetPrecision()), int64(_dollar_dollar.GetScale())} + unwrapped_fields987 := fields986 p.write("(") p.write("DECIMAL") p.indentSexp() p.newline() - field986 := unwrapped_fields985[0].(int64) - p.write(fmt.Sprintf("%d", field986)) + field988 := unwrapped_fields987[0].(int64) + p.write(fmt.Sprintf("%d", field988)) p.newline() - field987 := unwrapped_fields985[1].(int64) - p.write(fmt.Sprintf("%d", field987)) + field989 := unwrapped_fields987[1].(int64) + p.write(fmt.Sprintf("%d", field989)) p.dedent() p.write(")") } @@ -1607,48 +1607,48 @@ func (p *PrettyPrinter) pretty_decimal_type(msg *pb.DecimalType) interface{} { } func (p *PrettyPrinter) pretty_boolean_type(msg *pb.BooleanType) interface{} { - fields989 := msg - _ = fields989 + fields991 := msg + _ = fields991 p.write("BOOLEAN") return nil } func (p *PrettyPrinter) pretty_int32_type(msg *pb.Int32Type) interface{} { - fields990 := msg - _ = fields990 + fields992 := msg + _ = fields992 p.write("INT32") return nil } func (p *PrettyPrinter) pretty_float32_type(msg *pb.Float32Type) interface{} { - fields991 := msg - _ = fields991 + fields993 := msg + _ = fields993 p.write("FLOAT32") return nil } func (p *PrettyPrinter) pretty_uint32_type(msg *pb.UInt32Type) interface{} { - fields992 := msg - _ = fields992 + fields994 := msg + _ = fields994 p.write("UINT32") return nil } func (p *PrettyPrinter) pretty_value_bindings(msg []*pb.Binding) interface{} { - flat996 := p.tryFlat(msg, func() { p.pretty_value_bindings(msg) }) - if flat996 != nil { - p.write(*flat996) + flat998 := p.tryFlat(msg, func() { p.pretty_value_bindings(msg) }) + if flat998 != nil { + p.write(*flat998) return nil } else { - fields993 := msg + fields995 := msg p.write("|") - if !(len(fields993) == 0) { + if !(len(fields995) == 0) { p.write(" ") - for i995, elem994 := range fields993 { - if (i995 > 0) { + for i997, elem996 := range fields995 { + if (i997 > 0) { p.newline() } - p.pretty_binding(elem994) + p.pretty_binding(elem996) } } } @@ -1656,140 +1656,140 @@ func (p *PrettyPrinter) pretty_value_bindings(msg []*pb.Binding) interface{} { } func (p *PrettyPrinter) pretty_formula(msg *pb.Formula) interface{} { - flat1023 := p.tryFlat(msg, func() { p.pretty_formula(msg) }) - if flat1023 != nil { - p.write(*flat1023) + flat1025 := p.tryFlat(msg, func() { p.pretty_formula(msg) }) + if flat1025 != nil { + p.write(*flat1025) return nil } else { _dollar_dollar := msg - var _t1643 *pb.Conjunction + var _t1647 *pb.Conjunction if (hasProtoField(_dollar_dollar, "conjunction") && len(_dollar_dollar.GetConjunction().GetArgs()) == 0) { - _t1643 = _dollar_dollar.GetConjunction() + _t1647 = _dollar_dollar.GetConjunction() } - deconstruct_result1021 := _t1643 - if deconstruct_result1021 != nil { - unwrapped1022 := deconstruct_result1021 - p.pretty_true(unwrapped1022) + deconstruct_result1023 := _t1647 + if deconstruct_result1023 != nil { + unwrapped1024 := deconstruct_result1023 + p.pretty_true(unwrapped1024) } else { _dollar_dollar := msg - var _t1644 *pb.Disjunction + var _t1648 *pb.Disjunction if (hasProtoField(_dollar_dollar, "disjunction") && len(_dollar_dollar.GetDisjunction().GetArgs()) == 0) { - _t1644 = _dollar_dollar.GetDisjunction() + _t1648 = _dollar_dollar.GetDisjunction() } - deconstruct_result1019 := _t1644 - if deconstruct_result1019 != nil { - unwrapped1020 := deconstruct_result1019 - p.pretty_false(unwrapped1020) + deconstruct_result1021 := _t1648 + if deconstruct_result1021 != nil { + unwrapped1022 := deconstruct_result1021 + p.pretty_false(unwrapped1022) } else { _dollar_dollar := msg - var _t1645 *pb.Exists + var _t1649 *pb.Exists if hasProtoField(_dollar_dollar, "exists") { - _t1645 = _dollar_dollar.GetExists() + _t1649 = _dollar_dollar.GetExists() } - deconstruct_result1017 := _t1645 - if deconstruct_result1017 != nil { - unwrapped1018 := deconstruct_result1017 - p.pretty_exists(unwrapped1018) + deconstruct_result1019 := _t1649 + if deconstruct_result1019 != nil { + unwrapped1020 := deconstruct_result1019 + p.pretty_exists(unwrapped1020) } else { _dollar_dollar := msg - var _t1646 *pb.Reduce + var _t1650 *pb.Reduce if hasProtoField(_dollar_dollar, "reduce") { - _t1646 = _dollar_dollar.GetReduce() + _t1650 = _dollar_dollar.GetReduce() } - deconstruct_result1015 := _t1646 - if deconstruct_result1015 != nil { - unwrapped1016 := deconstruct_result1015 - p.pretty_reduce(unwrapped1016) + deconstruct_result1017 := _t1650 + if deconstruct_result1017 != nil { + unwrapped1018 := deconstruct_result1017 + p.pretty_reduce(unwrapped1018) } else { _dollar_dollar := msg - var _t1647 *pb.Conjunction + var _t1651 *pb.Conjunction if (hasProtoField(_dollar_dollar, "conjunction") && !(len(_dollar_dollar.GetConjunction().GetArgs()) == 0)) { - _t1647 = _dollar_dollar.GetConjunction() + _t1651 = _dollar_dollar.GetConjunction() } - deconstruct_result1013 := _t1647 - if deconstruct_result1013 != nil { - unwrapped1014 := deconstruct_result1013 - p.pretty_conjunction(unwrapped1014) + deconstruct_result1015 := _t1651 + if deconstruct_result1015 != nil { + unwrapped1016 := deconstruct_result1015 + p.pretty_conjunction(unwrapped1016) } else { _dollar_dollar := msg - var _t1648 *pb.Disjunction + var _t1652 *pb.Disjunction if (hasProtoField(_dollar_dollar, "disjunction") && !(len(_dollar_dollar.GetDisjunction().GetArgs()) == 0)) { - _t1648 = _dollar_dollar.GetDisjunction() + _t1652 = _dollar_dollar.GetDisjunction() } - deconstruct_result1011 := _t1648 - if deconstruct_result1011 != nil { - unwrapped1012 := deconstruct_result1011 - p.pretty_disjunction(unwrapped1012) + deconstruct_result1013 := _t1652 + if deconstruct_result1013 != nil { + unwrapped1014 := deconstruct_result1013 + p.pretty_disjunction(unwrapped1014) } else { _dollar_dollar := msg - var _t1649 *pb.Not + var _t1653 *pb.Not if hasProtoField(_dollar_dollar, "not") { - _t1649 = _dollar_dollar.GetNot() + _t1653 = _dollar_dollar.GetNot() } - deconstruct_result1009 := _t1649 - if deconstruct_result1009 != nil { - unwrapped1010 := deconstruct_result1009 - p.pretty_not(unwrapped1010) + deconstruct_result1011 := _t1653 + if deconstruct_result1011 != nil { + unwrapped1012 := deconstruct_result1011 + p.pretty_not(unwrapped1012) } else { _dollar_dollar := msg - var _t1650 *pb.FFI + var _t1654 *pb.FFI if hasProtoField(_dollar_dollar, "ffi") { - _t1650 = _dollar_dollar.GetFfi() + _t1654 = _dollar_dollar.GetFfi() } - deconstruct_result1007 := _t1650 - if deconstruct_result1007 != nil { - unwrapped1008 := deconstruct_result1007 - p.pretty_ffi(unwrapped1008) + deconstruct_result1009 := _t1654 + if deconstruct_result1009 != nil { + unwrapped1010 := deconstruct_result1009 + p.pretty_ffi(unwrapped1010) } else { _dollar_dollar := msg - var _t1651 *pb.Atom + var _t1655 *pb.Atom if hasProtoField(_dollar_dollar, "atom") { - _t1651 = _dollar_dollar.GetAtom() + _t1655 = _dollar_dollar.GetAtom() } - deconstruct_result1005 := _t1651 - if deconstruct_result1005 != nil { - unwrapped1006 := deconstruct_result1005 - p.pretty_atom(unwrapped1006) + deconstruct_result1007 := _t1655 + if deconstruct_result1007 != nil { + unwrapped1008 := deconstruct_result1007 + p.pretty_atom(unwrapped1008) } else { _dollar_dollar := msg - var _t1652 *pb.Pragma + var _t1656 *pb.Pragma if hasProtoField(_dollar_dollar, "pragma") { - _t1652 = _dollar_dollar.GetPragma() + _t1656 = _dollar_dollar.GetPragma() } - deconstruct_result1003 := _t1652 - if deconstruct_result1003 != nil { - unwrapped1004 := deconstruct_result1003 - p.pretty_pragma(unwrapped1004) + deconstruct_result1005 := _t1656 + if deconstruct_result1005 != nil { + unwrapped1006 := deconstruct_result1005 + p.pretty_pragma(unwrapped1006) } else { _dollar_dollar := msg - var _t1653 *pb.Primitive + var _t1657 *pb.Primitive if hasProtoField(_dollar_dollar, "primitive") { - _t1653 = _dollar_dollar.GetPrimitive() + _t1657 = _dollar_dollar.GetPrimitive() } - deconstruct_result1001 := _t1653 - if deconstruct_result1001 != nil { - unwrapped1002 := deconstruct_result1001 - p.pretty_primitive(unwrapped1002) + deconstruct_result1003 := _t1657 + if deconstruct_result1003 != nil { + unwrapped1004 := deconstruct_result1003 + p.pretty_primitive(unwrapped1004) } else { _dollar_dollar := msg - var _t1654 *pb.RelAtom + var _t1658 *pb.RelAtom if hasProtoField(_dollar_dollar, "rel_atom") { - _t1654 = _dollar_dollar.GetRelAtom() + _t1658 = _dollar_dollar.GetRelAtom() } - deconstruct_result999 := _t1654 - if deconstruct_result999 != nil { - unwrapped1000 := deconstruct_result999 - p.pretty_rel_atom(unwrapped1000) + deconstruct_result1001 := _t1658 + if deconstruct_result1001 != nil { + unwrapped1002 := deconstruct_result1001 + p.pretty_rel_atom(unwrapped1002) } else { _dollar_dollar := msg - var _t1655 *pb.Cast + var _t1659 *pb.Cast if hasProtoField(_dollar_dollar, "cast") { - _t1655 = _dollar_dollar.GetCast() + _t1659 = _dollar_dollar.GetCast() } - deconstruct_result997 := _t1655 - if deconstruct_result997 != nil { - unwrapped998 := deconstruct_result997 - p.pretty_cast(unwrapped998) + deconstruct_result999 := _t1659 + if deconstruct_result999 != nil { + unwrapped1000 := deconstruct_result999 + p.pretty_cast(unwrapped1000) } else { panic(ParseError{msg: "No matching rule for formula"}) } @@ -1810,8 +1810,8 @@ func (p *PrettyPrinter) pretty_formula(msg *pb.Formula) interface{} { } func (p *PrettyPrinter) pretty_true(msg *pb.Conjunction) interface{} { - fields1024 := msg - _ = fields1024 + fields1026 := msg + _ = fields1026 p.write("(") p.write("true") p.write(")") @@ -1819,8 +1819,8 @@ func (p *PrettyPrinter) pretty_true(msg *pb.Conjunction) interface{} { } func (p *PrettyPrinter) pretty_false(msg *pb.Disjunction) interface{} { - fields1025 := msg - _ = fields1025 + fields1027 := msg + _ = fields1027 p.write("(") p.write("false") p.write(")") @@ -1828,24 +1828,24 @@ func (p *PrettyPrinter) pretty_false(msg *pb.Disjunction) interface{} { } func (p *PrettyPrinter) pretty_exists(msg *pb.Exists) interface{} { - flat1030 := p.tryFlat(msg, func() { p.pretty_exists(msg) }) - if flat1030 != nil { - p.write(*flat1030) + flat1032 := p.tryFlat(msg, func() { p.pretty_exists(msg) }) + if flat1032 != nil { + p.write(*flat1032) return nil } else { _dollar_dollar := msg - _t1656 := p.deconstruct_bindings(_dollar_dollar.GetBody()) - fields1026 := []interface{}{_t1656, _dollar_dollar.GetBody().GetValue()} - unwrapped_fields1027 := fields1026 + _t1660 := p.deconstruct_bindings(_dollar_dollar.GetBody()) + fields1028 := []interface{}{_t1660, _dollar_dollar.GetBody().GetValue()} + unwrapped_fields1029 := fields1028 p.write("(") p.write("exists") p.indentSexp() p.newline() - field1028 := unwrapped_fields1027[0].([]interface{}) - p.pretty_bindings(field1028) + field1030 := unwrapped_fields1029[0].([]interface{}) + p.pretty_bindings(field1030) p.newline() - field1029 := unwrapped_fields1027[1].(*pb.Formula) - p.pretty_formula(field1029) + field1031 := unwrapped_fields1029[1].(*pb.Formula) + p.pretty_formula(field1031) p.dedent() p.write(")") } @@ -1853,26 +1853,26 @@ func (p *PrettyPrinter) pretty_exists(msg *pb.Exists) interface{} { } func (p *PrettyPrinter) pretty_reduce(msg *pb.Reduce) interface{} { - flat1036 := p.tryFlat(msg, func() { p.pretty_reduce(msg) }) - if flat1036 != nil { - p.write(*flat1036) + flat1038 := p.tryFlat(msg, func() { p.pretty_reduce(msg) }) + if flat1038 != nil { + p.write(*flat1038) return nil } else { _dollar_dollar := msg - fields1031 := []interface{}{_dollar_dollar.GetOp(), _dollar_dollar.GetBody(), _dollar_dollar.GetTerms()} - unwrapped_fields1032 := fields1031 + fields1033 := []interface{}{_dollar_dollar.GetOp(), _dollar_dollar.GetBody(), _dollar_dollar.GetTerms()} + unwrapped_fields1034 := fields1033 p.write("(") p.write("reduce") p.indentSexp() p.newline() - field1033 := unwrapped_fields1032[0].(*pb.Abstraction) - p.pretty_abstraction(field1033) + field1035 := unwrapped_fields1034[0].(*pb.Abstraction) + p.pretty_abstraction(field1035) p.newline() - field1034 := unwrapped_fields1032[1].(*pb.Abstraction) - p.pretty_abstraction(field1034) + field1036 := unwrapped_fields1034[1].(*pb.Abstraction) + p.pretty_abstraction(field1036) p.newline() - field1035 := unwrapped_fields1032[2].([]*pb.Term) - p.pretty_terms(field1035) + field1037 := unwrapped_fields1034[2].([]*pb.Term) + p.pretty_terms(field1037) p.dedent() p.write(")") } @@ -1880,22 +1880,22 @@ func (p *PrettyPrinter) pretty_reduce(msg *pb.Reduce) interface{} { } func (p *PrettyPrinter) pretty_terms(msg []*pb.Term) interface{} { - flat1040 := p.tryFlat(msg, func() { p.pretty_terms(msg) }) - if flat1040 != nil { - p.write(*flat1040) + flat1042 := p.tryFlat(msg, func() { p.pretty_terms(msg) }) + if flat1042 != nil { + p.write(*flat1042) return nil } else { - fields1037 := msg + fields1039 := msg p.write("(") p.write("terms") p.indentSexp() - if !(len(fields1037) == 0) { + if !(len(fields1039) == 0) { p.newline() - for i1039, elem1038 := range fields1037 { - if (i1039 > 0) { + for i1041, elem1040 := range fields1039 { + if (i1041 > 0) { p.newline() } - p.pretty_term(elem1038) + p.pretty_term(elem1040) } } p.dedent() @@ -1905,30 +1905,30 @@ func (p *PrettyPrinter) pretty_terms(msg []*pb.Term) interface{} { } func (p *PrettyPrinter) pretty_term(msg *pb.Term) interface{} { - flat1045 := p.tryFlat(msg, func() { p.pretty_term(msg) }) - if flat1045 != nil { - p.write(*flat1045) + flat1047 := p.tryFlat(msg, func() { p.pretty_term(msg) }) + if flat1047 != nil { + p.write(*flat1047) return nil } else { _dollar_dollar := msg - var _t1657 *pb.Var + var _t1661 *pb.Var if hasProtoField(_dollar_dollar, "var") { - _t1657 = _dollar_dollar.GetVar() + _t1661 = _dollar_dollar.GetVar() } - deconstruct_result1043 := _t1657 - if deconstruct_result1043 != nil { - unwrapped1044 := deconstruct_result1043 - p.pretty_var(unwrapped1044) + deconstruct_result1045 := _t1661 + if deconstruct_result1045 != nil { + unwrapped1046 := deconstruct_result1045 + p.pretty_var(unwrapped1046) } else { _dollar_dollar := msg - var _t1658 *pb.Value + var _t1662 *pb.Value if hasProtoField(_dollar_dollar, "constant") { - _t1658 = _dollar_dollar.GetConstant() + _t1662 = _dollar_dollar.GetConstant() } - deconstruct_result1041 := _t1658 - if deconstruct_result1041 != nil { - unwrapped1042 := deconstruct_result1041 - p.pretty_value(unwrapped1042) + deconstruct_result1043 := _t1662 + if deconstruct_result1043 != nil { + unwrapped1044 := deconstruct_result1043 + p.pretty_value(unwrapped1044) } else { panic(ParseError{msg: "No matching rule for term"}) } @@ -1938,147 +1938,147 @@ func (p *PrettyPrinter) pretty_term(msg *pb.Term) interface{} { } func (p *PrettyPrinter) pretty_var(msg *pb.Var) interface{} { - flat1048 := p.tryFlat(msg, func() { p.pretty_var(msg) }) - if flat1048 != nil { - p.write(*flat1048) + flat1050 := p.tryFlat(msg, func() { p.pretty_var(msg) }) + if flat1050 != nil { + p.write(*flat1050) return nil } else { _dollar_dollar := msg - fields1046 := _dollar_dollar.GetName() - unwrapped_fields1047 := fields1046 - p.write(unwrapped_fields1047) + fields1048 := _dollar_dollar.GetName() + unwrapped_fields1049 := fields1048 + p.write(unwrapped_fields1049) } return nil } func (p *PrettyPrinter) pretty_value(msg *pb.Value) interface{} { - flat1074 := p.tryFlat(msg, func() { p.pretty_value(msg) }) - if flat1074 != nil { - p.write(*flat1074) + flat1076 := p.tryFlat(msg, func() { p.pretty_value(msg) }) + if flat1076 != nil { + p.write(*flat1076) return nil } else { _dollar_dollar := msg - var _t1659 *pb.DateValue + var _t1663 *pb.DateValue if hasProtoField(_dollar_dollar, "date_value") { - _t1659 = _dollar_dollar.GetDateValue() + _t1663 = _dollar_dollar.GetDateValue() } - deconstruct_result1072 := _t1659 - if deconstruct_result1072 != nil { - unwrapped1073 := deconstruct_result1072 - p.pretty_date(unwrapped1073) + deconstruct_result1074 := _t1663 + if deconstruct_result1074 != nil { + unwrapped1075 := deconstruct_result1074 + p.pretty_date(unwrapped1075) } else { _dollar_dollar := msg - var _t1660 *pb.DateTimeValue + var _t1664 *pb.DateTimeValue if hasProtoField(_dollar_dollar, "datetime_value") { - _t1660 = _dollar_dollar.GetDatetimeValue() + _t1664 = _dollar_dollar.GetDatetimeValue() } - deconstruct_result1070 := _t1660 - if deconstruct_result1070 != nil { - unwrapped1071 := deconstruct_result1070 - p.pretty_datetime(unwrapped1071) + deconstruct_result1072 := _t1664 + if deconstruct_result1072 != nil { + unwrapped1073 := deconstruct_result1072 + p.pretty_datetime(unwrapped1073) } else { _dollar_dollar := msg - var _t1661 *string + var _t1665 *string if hasProtoField(_dollar_dollar, "string_value") { - _t1661 = ptr(_dollar_dollar.GetStringValue()) + _t1665 = ptr(_dollar_dollar.GetStringValue()) } - deconstruct_result1068 := _t1661 - if deconstruct_result1068 != nil { - unwrapped1069 := *deconstruct_result1068 - p.write(p.formatStringValue(unwrapped1069)) + deconstruct_result1070 := _t1665 + if deconstruct_result1070 != nil { + unwrapped1071 := *deconstruct_result1070 + p.write(p.formatStringValue(unwrapped1071)) } else { _dollar_dollar := msg - var _t1662 *int32 + var _t1666 *int32 if hasProtoField(_dollar_dollar, "int32_value") { - _t1662 = ptr(_dollar_dollar.GetInt32Value()) + _t1666 = ptr(_dollar_dollar.GetInt32Value()) } - deconstruct_result1066 := _t1662 - if deconstruct_result1066 != nil { - unwrapped1067 := *deconstruct_result1066 - p.write(fmt.Sprintf("%di32", unwrapped1067)) + deconstruct_result1068 := _t1666 + if deconstruct_result1068 != nil { + unwrapped1069 := *deconstruct_result1068 + p.write(fmt.Sprintf("%di32", unwrapped1069)) } else { _dollar_dollar := msg - var _t1663 *int64 + var _t1667 *int64 if hasProtoField(_dollar_dollar, "int_value") { - _t1663 = ptr(_dollar_dollar.GetIntValue()) + _t1667 = ptr(_dollar_dollar.GetIntValue()) } - deconstruct_result1064 := _t1663 - if deconstruct_result1064 != nil { - unwrapped1065 := *deconstruct_result1064 - p.write(fmt.Sprintf("%d", unwrapped1065)) + deconstruct_result1066 := _t1667 + if deconstruct_result1066 != nil { + unwrapped1067 := *deconstruct_result1066 + p.write(fmt.Sprintf("%d", unwrapped1067)) } else { _dollar_dollar := msg - var _t1664 *float32 + var _t1668 *float32 if hasProtoField(_dollar_dollar, "float32_value") { - _t1664 = ptr(_dollar_dollar.GetFloat32Value()) + _t1668 = ptr(_dollar_dollar.GetFloat32Value()) } - deconstruct_result1062 := _t1664 - if deconstruct_result1062 != nil { - unwrapped1063 := *deconstruct_result1062 - p.write(formatFloat32(unwrapped1063)) + deconstruct_result1064 := _t1668 + if deconstruct_result1064 != nil { + unwrapped1065 := *deconstruct_result1064 + p.write(formatFloat32(unwrapped1065)) } else { _dollar_dollar := msg - var _t1665 *float64 + var _t1669 *float64 if hasProtoField(_dollar_dollar, "float_value") { - _t1665 = ptr(_dollar_dollar.GetFloatValue()) + _t1669 = ptr(_dollar_dollar.GetFloatValue()) } - deconstruct_result1060 := _t1665 - if deconstruct_result1060 != nil { - unwrapped1061 := *deconstruct_result1060 - p.write(formatFloat64(unwrapped1061)) + deconstruct_result1062 := _t1669 + if deconstruct_result1062 != nil { + unwrapped1063 := *deconstruct_result1062 + p.write(formatFloat64(unwrapped1063)) } else { _dollar_dollar := msg - var _t1666 *uint32 + var _t1670 *uint32 if hasProtoField(_dollar_dollar, "uint32_value") { - _t1666 = ptr(_dollar_dollar.GetUint32Value()) + _t1670 = ptr(_dollar_dollar.GetUint32Value()) } - deconstruct_result1058 := _t1666 - if deconstruct_result1058 != nil { - unwrapped1059 := *deconstruct_result1058 - p.write(fmt.Sprintf("%du32", unwrapped1059)) + deconstruct_result1060 := _t1670 + if deconstruct_result1060 != nil { + unwrapped1061 := *deconstruct_result1060 + p.write(fmt.Sprintf("%du32", unwrapped1061)) } else { _dollar_dollar := msg - var _t1667 *pb.UInt128Value + var _t1671 *pb.UInt128Value if hasProtoField(_dollar_dollar, "uint128_value") { - _t1667 = _dollar_dollar.GetUint128Value() + _t1671 = _dollar_dollar.GetUint128Value() } - deconstruct_result1056 := _t1667 - if deconstruct_result1056 != nil { - unwrapped1057 := deconstruct_result1056 - p.write(p.formatUint128(unwrapped1057)) + deconstruct_result1058 := _t1671 + if deconstruct_result1058 != nil { + unwrapped1059 := deconstruct_result1058 + p.write(p.formatUint128(unwrapped1059)) } else { _dollar_dollar := msg - var _t1668 *pb.Int128Value + var _t1672 *pb.Int128Value if hasProtoField(_dollar_dollar, "int128_value") { - _t1668 = _dollar_dollar.GetInt128Value() + _t1672 = _dollar_dollar.GetInt128Value() } - deconstruct_result1054 := _t1668 - if deconstruct_result1054 != nil { - unwrapped1055 := deconstruct_result1054 - p.write(p.formatInt128(unwrapped1055)) + deconstruct_result1056 := _t1672 + if deconstruct_result1056 != nil { + unwrapped1057 := deconstruct_result1056 + p.write(p.formatInt128(unwrapped1057)) } else { _dollar_dollar := msg - var _t1669 *pb.DecimalValue + var _t1673 *pb.DecimalValue if hasProtoField(_dollar_dollar, "decimal_value") { - _t1669 = _dollar_dollar.GetDecimalValue() + _t1673 = _dollar_dollar.GetDecimalValue() } - deconstruct_result1052 := _t1669 - if deconstruct_result1052 != nil { - unwrapped1053 := deconstruct_result1052 - p.write(p.formatDecimal(unwrapped1053)) + deconstruct_result1054 := _t1673 + if deconstruct_result1054 != nil { + unwrapped1055 := deconstruct_result1054 + p.write(p.formatDecimal(unwrapped1055)) } else { _dollar_dollar := msg - var _t1670 *bool + var _t1674 *bool if hasProtoField(_dollar_dollar, "boolean_value") { - _t1670 = ptr(_dollar_dollar.GetBooleanValue()) + _t1674 = ptr(_dollar_dollar.GetBooleanValue()) } - deconstruct_result1050 := _t1670 - if deconstruct_result1050 != nil { - unwrapped1051 := *deconstruct_result1050 - p.pretty_boolean_value(unwrapped1051) + deconstruct_result1052 := _t1674 + if deconstruct_result1052 != nil { + unwrapped1053 := *deconstruct_result1052 + p.pretty_boolean_value(unwrapped1053) } else { - fields1049 := msg - _ = fields1049 + fields1051 := msg + _ = fields1051 p.write("missing") } } @@ -2097,26 +2097,26 @@ func (p *PrettyPrinter) pretty_value(msg *pb.Value) interface{} { } func (p *PrettyPrinter) pretty_date(msg *pb.DateValue) interface{} { - flat1080 := p.tryFlat(msg, func() { p.pretty_date(msg) }) - if flat1080 != nil { - p.write(*flat1080) + flat1082 := p.tryFlat(msg, func() { p.pretty_date(msg) }) + if flat1082 != nil { + p.write(*flat1082) return nil } else { _dollar_dollar := msg - fields1075 := []interface{}{int64(_dollar_dollar.GetYear()), int64(_dollar_dollar.GetMonth()), int64(_dollar_dollar.GetDay())} - unwrapped_fields1076 := fields1075 + fields1077 := []interface{}{int64(_dollar_dollar.GetYear()), int64(_dollar_dollar.GetMonth()), int64(_dollar_dollar.GetDay())} + unwrapped_fields1078 := fields1077 p.write("(") p.write("date") p.indentSexp() p.newline() - field1077 := unwrapped_fields1076[0].(int64) - p.write(fmt.Sprintf("%d", field1077)) + field1079 := unwrapped_fields1078[0].(int64) + p.write(fmt.Sprintf("%d", field1079)) p.newline() - field1078 := unwrapped_fields1076[1].(int64) - p.write(fmt.Sprintf("%d", field1078)) + field1080 := unwrapped_fields1078[1].(int64) + p.write(fmt.Sprintf("%d", field1080)) p.newline() - field1079 := unwrapped_fields1076[2].(int64) - p.write(fmt.Sprintf("%d", field1079)) + field1081 := unwrapped_fields1078[2].(int64) + p.write(fmt.Sprintf("%d", field1081)) p.dedent() p.write(")") } @@ -2124,40 +2124,40 @@ func (p *PrettyPrinter) pretty_date(msg *pb.DateValue) interface{} { } func (p *PrettyPrinter) pretty_datetime(msg *pb.DateTimeValue) interface{} { - flat1091 := p.tryFlat(msg, func() { p.pretty_datetime(msg) }) - if flat1091 != nil { - p.write(*flat1091) + flat1093 := p.tryFlat(msg, func() { p.pretty_datetime(msg) }) + if flat1093 != nil { + p.write(*flat1093) return nil } else { _dollar_dollar := msg - fields1081 := []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_fields1082 := fields1081 + fields1083 := []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_fields1084 := fields1083 p.write("(") p.write("datetime") p.indentSexp() p.newline() - field1083 := unwrapped_fields1082[0].(int64) - p.write(fmt.Sprintf("%d", field1083)) - p.newline() - field1084 := unwrapped_fields1082[1].(int64) - p.write(fmt.Sprintf("%d", field1084)) - p.newline() - field1085 := unwrapped_fields1082[2].(int64) + field1085 := unwrapped_fields1084[0].(int64) p.write(fmt.Sprintf("%d", field1085)) p.newline() - field1086 := unwrapped_fields1082[3].(int64) + field1086 := unwrapped_fields1084[1].(int64) p.write(fmt.Sprintf("%d", field1086)) p.newline() - field1087 := unwrapped_fields1082[4].(int64) + field1087 := unwrapped_fields1084[2].(int64) p.write(fmt.Sprintf("%d", field1087)) p.newline() - field1088 := unwrapped_fields1082[5].(int64) + field1088 := unwrapped_fields1084[3].(int64) p.write(fmt.Sprintf("%d", field1088)) - field1089 := unwrapped_fields1082[6].(*int64) - if field1089 != nil { + p.newline() + field1089 := unwrapped_fields1084[4].(int64) + p.write(fmt.Sprintf("%d", field1089)) + p.newline() + field1090 := unwrapped_fields1084[5].(int64) + p.write(fmt.Sprintf("%d", field1090)) + field1091 := unwrapped_fields1084[6].(*int64) + if field1091 != nil { p.newline() - opt_val1090 := *field1089 - p.write(fmt.Sprintf("%d", opt_val1090)) + opt_val1092 := *field1091 + p.write(fmt.Sprintf("%d", opt_val1092)) } p.dedent() p.write(")") @@ -2166,24 +2166,24 @@ func (p *PrettyPrinter) pretty_datetime(msg *pb.DateTimeValue) interface{} { } func (p *PrettyPrinter) pretty_conjunction(msg *pb.Conjunction) interface{} { - flat1096 := p.tryFlat(msg, func() { p.pretty_conjunction(msg) }) - if flat1096 != nil { - p.write(*flat1096) + flat1098 := p.tryFlat(msg, func() { p.pretty_conjunction(msg) }) + if flat1098 != nil { + p.write(*flat1098) return nil } else { _dollar_dollar := msg - fields1092 := _dollar_dollar.GetArgs() - unwrapped_fields1093 := fields1092 + fields1094 := _dollar_dollar.GetArgs() + unwrapped_fields1095 := fields1094 p.write("(") p.write("and") p.indentSexp() - if !(len(unwrapped_fields1093) == 0) { + if !(len(unwrapped_fields1095) == 0) { p.newline() - for i1095, elem1094 := range unwrapped_fields1093 { - if (i1095 > 0) { + for i1097, elem1096 := range unwrapped_fields1095 { + if (i1097 > 0) { p.newline() } - p.pretty_formula(elem1094) + p.pretty_formula(elem1096) } } p.dedent() @@ -2193,24 +2193,24 @@ func (p *PrettyPrinter) pretty_conjunction(msg *pb.Conjunction) interface{} { } func (p *PrettyPrinter) pretty_disjunction(msg *pb.Disjunction) interface{} { - flat1101 := p.tryFlat(msg, func() { p.pretty_disjunction(msg) }) - if flat1101 != nil { - p.write(*flat1101) + flat1103 := p.tryFlat(msg, func() { p.pretty_disjunction(msg) }) + if flat1103 != nil { + p.write(*flat1103) return nil } else { _dollar_dollar := msg - fields1097 := _dollar_dollar.GetArgs() - unwrapped_fields1098 := fields1097 + fields1099 := _dollar_dollar.GetArgs() + unwrapped_fields1100 := fields1099 p.write("(") p.write("or") p.indentSexp() - if !(len(unwrapped_fields1098) == 0) { + if !(len(unwrapped_fields1100) == 0) { p.newline() - for i1100, elem1099 := range unwrapped_fields1098 { - if (i1100 > 0) { + for i1102, elem1101 := range unwrapped_fields1100 { + if (i1102 > 0) { p.newline() } - p.pretty_formula(elem1099) + p.pretty_formula(elem1101) } } p.dedent() @@ -2220,19 +2220,19 @@ func (p *PrettyPrinter) pretty_disjunction(msg *pb.Disjunction) interface{} { } func (p *PrettyPrinter) pretty_not(msg *pb.Not) interface{} { - flat1104 := p.tryFlat(msg, func() { p.pretty_not(msg) }) - if flat1104 != nil { - p.write(*flat1104) + flat1106 := p.tryFlat(msg, func() { p.pretty_not(msg) }) + if flat1106 != nil { + p.write(*flat1106) return nil } else { _dollar_dollar := msg - fields1102 := _dollar_dollar.GetArg() - unwrapped_fields1103 := fields1102 + fields1104 := _dollar_dollar.GetArg() + unwrapped_fields1105 := fields1104 p.write("(") p.write("not") p.indentSexp() p.newline() - p.pretty_formula(unwrapped_fields1103) + p.pretty_formula(unwrapped_fields1105) p.dedent() p.write(")") } @@ -2240,26 +2240,26 @@ func (p *PrettyPrinter) pretty_not(msg *pb.Not) interface{} { } func (p *PrettyPrinter) pretty_ffi(msg *pb.FFI) interface{} { - flat1110 := p.tryFlat(msg, func() { p.pretty_ffi(msg) }) - if flat1110 != nil { - p.write(*flat1110) + flat1112 := p.tryFlat(msg, func() { p.pretty_ffi(msg) }) + if flat1112 != nil { + p.write(*flat1112) return nil } else { _dollar_dollar := msg - fields1105 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetArgs(), _dollar_dollar.GetTerms()} - unwrapped_fields1106 := fields1105 + fields1107 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetArgs(), _dollar_dollar.GetTerms()} + unwrapped_fields1108 := fields1107 p.write("(") p.write("ffi") p.indentSexp() p.newline() - field1107 := unwrapped_fields1106[0].(string) - p.pretty_name(field1107) + field1109 := unwrapped_fields1108[0].(string) + p.pretty_name(field1109) p.newline() - field1108 := unwrapped_fields1106[1].([]*pb.Abstraction) - p.pretty_ffi_args(field1108) + field1110 := unwrapped_fields1108[1].([]*pb.Abstraction) + p.pretty_ffi_args(field1110) p.newline() - field1109 := unwrapped_fields1106[2].([]*pb.Term) - p.pretty_terms(field1109) + field1111 := unwrapped_fields1108[2].([]*pb.Term) + p.pretty_terms(field1111) p.dedent() p.write(")") } @@ -2267,35 +2267,35 @@ func (p *PrettyPrinter) pretty_ffi(msg *pb.FFI) interface{} { } func (p *PrettyPrinter) pretty_name(msg string) interface{} { - flat1112 := p.tryFlat(msg, func() { p.pretty_name(msg) }) - if flat1112 != nil { - p.write(*flat1112) + flat1114 := p.tryFlat(msg, func() { p.pretty_name(msg) }) + if flat1114 != nil { + p.write(*flat1114) return nil } else { - fields1111 := msg + fields1113 := msg p.write(":") - p.write(fields1111) + p.write(fields1113) } return nil } func (p *PrettyPrinter) pretty_ffi_args(msg []*pb.Abstraction) interface{} { - flat1116 := p.tryFlat(msg, func() { p.pretty_ffi_args(msg) }) - if flat1116 != nil { - p.write(*flat1116) + flat1118 := p.tryFlat(msg, func() { p.pretty_ffi_args(msg) }) + if flat1118 != nil { + p.write(*flat1118) return nil } else { - fields1113 := msg + fields1115 := msg p.write("(") p.write("args") p.indentSexp() - if !(len(fields1113) == 0) { + if !(len(fields1115) == 0) { p.newline() - for i1115, elem1114 := range fields1113 { - if (i1115 > 0) { + for i1117, elem1116 := range fields1115 { + if (i1117 > 0) { p.newline() } - p.pretty_abstraction(elem1114) + p.pretty_abstraction(elem1116) } } p.dedent() @@ -2305,28 +2305,28 @@ func (p *PrettyPrinter) pretty_ffi_args(msg []*pb.Abstraction) interface{} { } func (p *PrettyPrinter) pretty_atom(msg *pb.Atom) interface{} { - flat1123 := p.tryFlat(msg, func() { p.pretty_atom(msg) }) - if flat1123 != nil { - p.write(*flat1123) + flat1125 := p.tryFlat(msg, func() { p.pretty_atom(msg) }) + if flat1125 != nil { + p.write(*flat1125) return nil } else { _dollar_dollar := msg - fields1117 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetTerms()} - unwrapped_fields1118 := fields1117 + fields1119 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetTerms()} + unwrapped_fields1120 := fields1119 p.write("(") p.write("atom") p.indentSexp() p.newline() - field1119 := unwrapped_fields1118[0].(*pb.RelationId) - p.pretty_relation_id(field1119) - field1120 := unwrapped_fields1118[1].([]*pb.Term) - if !(len(field1120) == 0) { + field1121 := unwrapped_fields1120[0].(*pb.RelationId) + p.pretty_relation_id(field1121) + field1122 := unwrapped_fields1120[1].([]*pb.Term) + if !(len(field1122) == 0) { p.newline() - for i1122, elem1121 := range field1120 { - if (i1122 > 0) { + for i1124, elem1123 := range field1122 { + if (i1124 > 0) { p.newline() } - p.pretty_term(elem1121) + p.pretty_term(elem1123) } } p.dedent() @@ -2336,28 +2336,28 @@ func (p *PrettyPrinter) pretty_atom(msg *pb.Atom) interface{} { } func (p *PrettyPrinter) pretty_pragma(msg *pb.Pragma) interface{} { - flat1130 := p.tryFlat(msg, func() { p.pretty_pragma(msg) }) - if flat1130 != nil { - p.write(*flat1130) + flat1132 := p.tryFlat(msg, func() { p.pretty_pragma(msg) }) + if flat1132 != nil { + p.write(*flat1132) return nil } else { _dollar_dollar := msg - fields1124 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetTerms()} - unwrapped_fields1125 := fields1124 + fields1126 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetTerms()} + unwrapped_fields1127 := fields1126 p.write("(") p.write("pragma") p.indentSexp() p.newline() - field1126 := unwrapped_fields1125[0].(string) - p.pretty_name(field1126) - field1127 := unwrapped_fields1125[1].([]*pb.Term) - if !(len(field1127) == 0) { + field1128 := unwrapped_fields1127[0].(string) + p.pretty_name(field1128) + field1129 := unwrapped_fields1127[1].([]*pb.Term) + if !(len(field1129) == 0) { p.newline() - for i1129, elem1128 := range field1127 { - if (i1129 > 0) { + for i1131, elem1130 := range field1129 { + if (i1131 > 0) { p.newline() } - p.pretty_term(elem1128) + p.pretty_term(elem1130) } } p.dedent() @@ -2367,109 +2367,109 @@ func (p *PrettyPrinter) pretty_pragma(msg *pb.Pragma) interface{} { } func (p *PrettyPrinter) pretty_primitive(msg *pb.Primitive) interface{} { - flat1146 := p.tryFlat(msg, func() { p.pretty_primitive(msg) }) - if flat1146 != nil { - p.write(*flat1146) + flat1148 := p.tryFlat(msg, func() { p.pretty_primitive(msg) }) + if flat1148 != nil { + p.write(*flat1148) return nil } else { _dollar_dollar := msg - var _t1671 []interface{} + var _t1675 []interface{} if _dollar_dollar.GetName() == "rel_primitive_eq" { - _t1671 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} + _t1675 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} } - guard_result1145 := _t1671 - if guard_result1145 != nil { + guard_result1147 := _t1675 + if guard_result1147 != nil { p.pretty_eq(msg) } else { _dollar_dollar := msg - var _t1672 []interface{} + var _t1676 []interface{} if _dollar_dollar.GetName() == "rel_primitive_lt_monotype" { - _t1672 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} + _t1676 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} } - guard_result1144 := _t1672 - if guard_result1144 != nil { + guard_result1146 := _t1676 + if guard_result1146 != nil { p.pretty_lt(msg) } else { _dollar_dollar := msg - var _t1673 []interface{} + var _t1677 []interface{} if _dollar_dollar.GetName() == "rel_primitive_lt_eq_monotype" { - _t1673 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} + _t1677 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} } - guard_result1143 := _t1673 - if guard_result1143 != nil { + guard_result1145 := _t1677 + if guard_result1145 != nil { p.pretty_lt_eq(msg) } else { _dollar_dollar := msg - var _t1674 []interface{} + var _t1678 []interface{} if _dollar_dollar.GetName() == "rel_primitive_gt_monotype" { - _t1674 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} + _t1678 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} } - guard_result1142 := _t1674 - if guard_result1142 != nil { + guard_result1144 := _t1678 + if guard_result1144 != nil { p.pretty_gt(msg) } else { _dollar_dollar := msg - var _t1675 []interface{} + var _t1679 []interface{} if _dollar_dollar.GetName() == "rel_primitive_gt_eq_monotype" { - _t1675 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} + _t1679 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} } - guard_result1141 := _t1675 - if guard_result1141 != nil { + guard_result1143 := _t1679 + if guard_result1143 != nil { p.pretty_gt_eq(msg) } else { _dollar_dollar := msg - var _t1676 []interface{} + var _t1680 []interface{} if _dollar_dollar.GetName() == "rel_primitive_add_monotype" { - _t1676 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} + _t1680 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} } - guard_result1140 := _t1676 - if guard_result1140 != nil { + guard_result1142 := _t1680 + if guard_result1142 != nil { p.pretty_add(msg) } else { _dollar_dollar := msg - var _t1677 []interface{} + var _t1681 []interface{} if _dollar_dollar.GetName() == "rel_primitive_subtract_monotype" { - _t1677 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} + _t1681 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} } - guard_result1139 := _t1677 - if guard_result1139 != nil { + guard_result1141 := _t1681 + if guard_result1141 != nil { p.pretty_minus(msg) } else { _dollar_dollar := msg - var _t1678 []interface{} + var _t1682 []interface{} if _dollar_dollar.GetName() == "rel_primitive_multiply_monotype" { - _t1678 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} + _t1682 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} } - guard_result1138 := _t1678 - if guard_result1138 != nil { + guard_result1140 := _t1682 + if guard_result1140 != nil { p.pretty_multiply(msg) } else { _dollar_dollar := msg - var _t1679 []interface{} + var _t1683 []interface{} if _dollar_dollar.GetName() == "rel_primitive_divide_monotype" { - _t1679 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} + _t1683 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} } - guard_result1137 := _t1679 - if guard_result1137 != nil { + guard_result1139 := _t1683 + if guard_result1139 != nil { p.pretty_divide(msg) } else { _dollar_dollar := msg - fields1131 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetTerms()} - unwrapped_fields1132 := fields1131 + fields1133 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetTerms()} + unwrapped_fields1134 := fields1133 p.write("(") p.write("primitive") p.indentSexp() p.newline() - field1133 := unwrapped_fields1132[0].(string) - p.pretty_name(field1133) - field1134 := unwrapped_fields1132[1].([]*pb.RelTerm) - if !(len(field1134) == 0) { + field1135 := unwrapped_fields1134[0].(string) + p.pretty_name(field1135) + field1136 := unwrapped_fields1134[1].([]*pb.RelTerm) + if !(len(field1136) == 0) { p.newline() - for i1136, elem1135 := range field1134 { - if (i1136 > 0) { + for i1138, elem1137 := range field1136 { + if (i1138 > 0) { p.newline() } - p.pretty_rel_term(elem1135) + p.pretty_rel_term(elem1137) } } p.dedent() @@ -2488,27 +2488,27 @@ func (p *PrettyPrinter) pretty_primitive(msg *pb.Primitive) interface{} { } func (p *PrettyPrinter) pretty_eq(msg *pb.Primitive) interface{} { - flat1151 := p.tryFlat(msg, func() { p.pretty_eq(msg) }) - if flat1151 != nil { - p.write(*flat1151) + flat1153 := p.tryFlat(msg, func() { p.pretty_eq(msg) }) + if flat1153 != nil { + p.write(*flat1153) return nil } else { _dollar_dollar := msg - var _t1680 []interface{} + var _t1684 []interface{} if _dollar_dollar.GetName() == "rel_primitive_eq" { - _t1680 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} + _t1684 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} } - fields1147 := _t1680 - unwrapped_fields1148 := fields1147 + fields1149 := _t1684 + unwrapped_fields1150 := fields1149 p.write("(") p.write("=") p.indentSexp() p.newline() - field1149 := unwrapped_fields1148[0].(*pb.Term) - p.pretty_term(field1149) + field1151 := unwrapped_fields1150[0].(*pb.Term) + p.pretty_term(field1151) p.newline() - field1150 := unwrapped_fields1148[1].(*pb.Term) - p.pretty_term(field1150) + field1152 := unwrapped_fields1150[1].(*pb.Term) + p.pretty_term(field1152) p.dedent() p.write(")") } @@ -2516,27 +2516,27 @@ func (p *PrettyPrinter) pretty_eq(msg *pb.Primitive) interface{} { } func (p *PrettyPrinter) pretty_lt(msg *pb.Primitive) interface{} { - flat1156 := p.tryFlat(msg, func() { p.pretty_lt(msg) }) - if flat1156 != nil { - p.write(*flat1156) + flat1158 := p.tryFlat(msg, func() { p.pretty_lt(msg) }) + if flat1158 != nil { + p.write(*flat1158) return nil } else { _dollar_dollar := msg - var _t1681 []interface{} + var _t1685 []interface{} if _dollar_dollar.GetName() == "rel_primitive_lt_monotype" { - _t1681 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} + _t1685 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} } - fields1152 := _t1681 - unwrapped_fields1153 := fields1152 + fields1154 := _t1685 + unwrapped_fields1155 := fields1154 p.write("(") p.write("<") p.indentSexp() p.newline() - field1154 := unwrapped_fields1153[0].(*pb.Term) - p.pretty_term(field1154) + field1156 := unwrapped_fields1155[0].(*pb.Term) + p.pretty_term(field1156) p.newline() - field1155 := unwrapped_fields1153[1].(*pb.Term) - p.pretty_term(field1155) + field1157 := unwrapped_fields1155[1].(*pb.Term) + p.pretty_term(field1157) p.dedent() p.write(")") } @@ -2544,27 +2544,27 @@ func (p *PrettyPrinter) pretty_lt(msg *pb.Primitive) interface{} { } func (p *PrettyPrinter) pretty_lt_eq(msg *pb.Primitive) interface{} { - flat1161 := p.tryFlat(msg, func() { p.pretty_lt_eq(msg) }) - if flat1161 != nil { - p.write(*flat1161) + flat1163 := p.tryFlat(msg, func() { p.pretty_lt_eq(msg) }) + if flat1163 != nil { + p.write(*flat1163) return nil } else { _dollar_dollar := msg - var _t1682 []interface{} + var _t1686 []interface{} if _dollar_dollar.GetName() == "rel_primitive_lt_eq_monotype" { - _t1682 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} + _t1686 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} } - fields1157 := _t1682 - unwrapped_fields1158 := fields1157 + fields1159 := _t1686 + unwrapped_fields1160 := fields1159 p.write("(") p.write("<=") p.indentSexp() p.newline() - field1159 := unwrapped_fields1158[0].(*pb.Term) - p.pretty_term(field1159) + field1161 := unwrapped_fields1160[0].(*pb.Term) + p.pretty_term(field1161) p.newline() - field1160 := unwrapped_fields1158[1].(*pb.Term) - p.pretty_term(field1160) + field1162 := unwrapped_fields1160[1].(*pb.Term) + p.pretty_term(field1162) p.dedent() p.write(")") } @@ -2572,27 +2572,27 @@ func (p *PrettyPrinter) pretty_lt_eq(msg *pb.Primitive) interface{} { } func (p *PrettyPrinter) pretty_gt(msg *pb.Primitive) interface{} { - flat1166 := p.tryFlat(msg, func() { p.pretty_gt(msg) }) - if flat1166 != nil { - p.write(*flat1166) + flat1168 := p.tryFlat(msg, func() { p.pretty_gt(msg) }) + if flat1168 != nil { + p.write(*flat1168) return nil } else { _dollar_dollar := msg - var _t1683 []interface{} + var _t1687 []interface{} if _dollar_dollar.GetName() == "rel_primitive_gt_monotype" { - _t1683 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} + _t1687 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} } - fields1162 := _t1683 - unwrapped_fields1163 := fields1162 + fields1164 := _t1687 + unwrapped_fields1165 := fields1164 p.write("(") p.write(">") p.indentSexp() p.newline() - field1164 := unwrapped_fields1163[0].(*pb.Term) - p.pretty_term(field1164) + field1166 := unwrapped_fields1165[0].(*pb.Term) + p.pretty_term(field1166) p.newline() - field1165 := unwrapped_fields1163[1].(*pb.Term) - p.pretty_term(field1165) + field1167 := unwrapped_fields1165[1].(*pb.Term) + p.pretty_term(field1167) p.dedent() p.write(")") } @@ -2600,27 +2600,27 @@ func (p *PrettyPrinter) pretty_gt(msg *pb.Primitive) interface{} { } func (p *PrettyPrinter) pretty_gt_eq(msg *pb.Primitive) interface{} { - flat1171 := p.tryFlat(msg, func() { p.pretty_gt_eq(msg) }) - if flat1171 != nil { - p.write(*flat1171) + flat1173 := p.tryFlat(msg, func() { p.pretty_gt_eq(msg) }) + if flat1173 != nil { + p.write(*flat1173) return nil } else { _dollar_dollar := msg - var _t1684 []interface{} + var _t1688 []interface{} if _dollar_dollar.GetName() == "rel_primitive_gt_eq_monotype" { - _t1684 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} + _t1688 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} } - fields1167 := _t1684 - unwrapped_fields1168 := fields1167 + fields1169 := _t1688 + unwrapped_fields1170 := fields1169 p.write("(") p.write(">=") p.indentSexp() p.newline() - field1169 := unwrapped_fields1168[0].(*pb.Term) - p.pretty_term(field1169) + field1171 := unwrapped_fields1170[0].(*pb.Term) + p.pretty_term(field1171) p.newline() - field1170 := unwrapped_fields1168[1].(*pb.Term) - p.pretty_term(field1170) + field1172 := unwrapped_fields1170[1].(*pb.Term) + p.pretty_term(field1172) p.dedent() p.write(")") } @@ -2628,30 +2628,30 @@ func (p *PrettyPrinter) pretty_gt_eq(msg *pb.Primitive) interface{} { } func (p *PrettyPrinter) pretty_add(msg *pb.Primitive) interface{} { - flat1177 := p.tryFlat(msg, func() { p.pretty_add(msg) }) - if flat1177 != nil { - p.write(*flat1177) + flat1179 := p.tryFlat(msg, func() { p.pretty_add(msg) }) + if flat1179 != nil { + p.write(*flat1179) return nil } else { _dollar_dollar := msg - var _t1685 []interface{} + var _t1689 []interface{} if _dollar_dollar.GetName() == "rel_primitive_add_monotype" { - _t1685 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} + _t1689 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} } - fields1172 := _t1685 - unwrapped_fields1173 := fields1172 + fields1174 := _t1689 + unwrapped_fields1175 := fields1174 p.write("(") p.write("+") p.indentSexp() p.newline() - field1174 := unwrapped_fields1173[0].(*pb.Term) - p.pretty_term(field1174) + field1176 := unwrapped_fields1175[0].(*pb.Term) + p.pretty_term(field1176) p.newline() - field1175 := unwrapped_fields1173[1].(*pb.Term) - p.pretty_term(field1175) + field1177 := unwrapped_fields1175[1].(*pb.Term) + p.pretty_term(field1177) p.newline() - field1176 := unwrapped_fields1173[2].(*pb.Term) - p.pretty_term(field1176) + field1178 := unwrapped_fields1175[2].(*pb.Term) + p.pretty_term(field1178) p.dedent() p.write(")") } @@ -2659,30 +2659,30 @@ func (p *PrettyPrinter) pretty_add(msg *pb.Primitive) interface{} { } func (p *PrettyPrinter) pretty_minus(msg *pb.Primitive) interface{} { - flat1183 := p.tryFlat(msg, func() { p.pretty_minus(msg) }) - if flat1183 != nil { - p.write(*flat1183) + flat1185 := p.tryFlat(msg, func() { p.pretty_minus(msg) }) + if flat1185 != nil { + p.write(*flat1185) return nil } else { _dollar_dollar := msg - var _t1686 []interface{} + var _t1690 []interface{} if _dollar_dollar.GetName() == "rel_primitive_subtract_monotype" { - _t1686 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} + _t1690 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} } - fields1178 := _t1686 - unwrapped_fields1179 := fields1178 + fields1180 := _t1690 + 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.newline() - field1182 := unwrapped_fields1179[2].(*pb.Term) - p.pretty_term(field1182) + field1184 := unwrapped_fields1181[2].(*pb.Term) + p.pretty_term(field1184) p.dedent() p.write(")") } @@ -2690,30 +2690,30 @@ func (p *PrettyPrinter) pretty_minus(msg *pb.Primitive) interface{} { } func (p *PrettyPrinter) pretty_multiply(msg *pb.Primitive) interface{} { - flat1189 := p.tryFlat(msg, func() { p.pretty_multiply(msg) }) - if flat1189 != nil { - p.write(*flat1189) + flat1191 := p.tryFlat(msg, func() { p.pretty_multiply(msg) }) + if flat1191 != nil { + p.write(*flat1191) return nil } else { _dollar_dollar := msg - var _t1687 []interface{} + var _t1691 []interface{} if _dollar_dollar.GetName() == "rel_primitive_multiply_monotype" { - _t1687 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} + _t1691 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} } - fields1184 := _t1687 - unwrapped_fields1185 := fields1184 + fields1186 := _t1691 + unwrapped_fields1187 := fields1186 p.write("(") p.write("*") p.indentSexp() p.newline() - field1186 := unwrapped_fields1185[0].(*pb.Term) - p.pretty_term(field1186) + field1188 := unwrapped_fields1187[0].(*pb.Term) + p.pretty_term(field1188) p.newline() - field1187 := unwrapped_fields1185[1].(*pb.Term) - p.pretty_term(field1187) + field1189 := unwrapped_fields1187[1].(*pb.Term) + p.pretty_term(field1189) p.newline() - field1188 := unwrapped_fields1185[2].(*pb.Term) - p.pretty_term(field1188) + field1190 := unwrapped_fields1187[2].(*pb.Term) + p.pretty_term(field1190) p.dedent() p.write(")") } @@ -2721,30 +2721,30 @@ func (p *PrettyPrinter) pretty_multiply(msg *pb.Primitive) interface{} { } func (p *PrettyPrinter) pretty_divide(msg *pb.Primitive) interface{} { - flat1195 := p.tryFlat(msg, func() { p.pretty_divide(msg) }) - if flat1195 != nil { - p.write(*flat1195) + flat1197 := p.tryFlat(msg, func() { p.pretty_divide(msg) }) + if flat1197 != nil { + p.write(*flat1197) return nil } else { _dollar_dollar := msg - var _t1688 []interface{} + var _t1692 []interface{} if _dollar_dollar.GetName() == "rel_primitive_divide_monotype" { - _t1688 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} + _t1692 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} } - fields1190 := _t1688 - unwrapped_fields1191 := fields1190 + fields1192 := _t1692 + unwrapped_fields1193 := fields1192 p.write("(") p.write("/") p.indentSexp() p.newline() - field1192 := unwrapped_fields1191[0].(*pb.Term) - p.pretty_term(field1192) + field1194 := unwrapped_fields1193[0].(*pb.Term) + p.pretty_term(field1194) p.newline() - field1193 := unwrapped_fields1191[1].(*pb.Term) - p.pretty_term(field1193) + field1195 := unwrapped_fields1193[1].(*pb.Term) + p.pretty_term(field1195) p.newline() - field1194 := unwrapped_fields1191[2].(*pb.Term) - p.pretty_term(field1194) + field1196 := unwrapped_fields1193[2].(*pb.Term) + p.pretty_term(field1196) p.dedent() p.write(")") } @@ -2752,30 +2752,30 @@ func (p *PrettyPrinter) pretty_divide(msg *pb.Primitive) interface{} { } func (p *PrettyPrinter) pretty_rel_term(msg *pb.RelTerm) interface{} { - flat1200 := p.tryFlat(msg, func() { p.pretty_rel_term(msg) }) - if flat1200 != nil { - p.write(*flat1200) + flat1202 := p.tryFlat(msg, func() { p.pretty_rel_term(msg) }) + if flat1202 != nil { + p.write(*flat1202) return nil } else { _dollar_dollar := msg - var _t1689 *pb.Value + var _t1693 *pb.Value if hasProtoField(_dollar_dollar, "specialized_value") { - _t1689 = _dollar_dollar.GetSpecializedValue() + _t1693 = _dollar_dollar.GetSpecializedValue() } - deconstruct_result1198 := _t1689 - if deconstruct_result1198 != nil { - unwrapped1199 := deconstruct_result1198 - p.pretty_specialized_value(unwrapped1199) + deconstruct_result1200 := _t1693 + if deconstruct_result1200 != nil { + unwrapped1201 := deconstruct_result1200 + p.pretty_specialized_value(unwrapped1201) } else { _dollar_dollar := msg - var _t1690 *pb.Term + var _t1694 *pb.Term if hasProtoField(_dollar_dollar, "term") { - _t1690 = _dollar_dollar.GetTerm() + _t1694 = _dollar_dollar.GetTerm() } - deconstruct_result1196 := _t1690 - if deconstruct_result1196 != nil { - unwrapped1197 := deconstruct_result1196 - p.pretty_term(unwrapped1197) + deconstruct_result1198 := _t1694 + if deconstruct_result1198 != nil { + unwrapped1199 := deconstruct_result1198 + p.pretty_term(unwrapped1199) } else { panic(ParseError{msg: "No matching rule for rel_term"}) } @@ -2785,41 +2785,41 @@ func (p *PrettyPrinter) pretty_rel_term(msg *pb.RelTerm) interface{} { } func (p *PrettyPrinter) pretty_specialized_value(msg *pb.Value) interface{} { - flat1202 := p.tryFlat(msg, func() { p.pretty_specialized_value(msg) }) - if flat1202 != nil { - p.write(*flat1202) + flat1204 := p.tryFlat(msg, func() { p.pretty_specialized_value(msg) }) + if flat1204 != nil { + p.write(*flat1204) return nil } else { - fields1201 := msg + fields1203 := msg p.write("#") - p.pretty_raw_value(fields1201) + p.pretty_raw_value(fields1203) } return nil } func (p *PrettyPrinter) pretty_rel_atom(msg *pb.RelAtom) interface{} { - flat1209 := p.tryFlat(msg, func() { p.pretty_rel_atom(msg) }) - if flat1209 != nil { - p.write(*flat1209) + flat1211 := p.tryFlat(msg, func() { p.pretty_rel_atom(msg) }) + if flat1211 != nil { + p.write(*flat1211) return nil } else { _dollar_dollar := msg - fields1203 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetTerms()} - unwrapped_fields1204 := fields1203 + fields1205 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetTerms()} + unwrapped_fields1206 := fields1205 p.write("(") p.write("relatom") p.indentSexp() p.newline() - field1205 := unwrapped_fields1204[0].(string) - p.pretty_name(field1205) - field1206 := unwrapped_fields1204[1].([]*pb.RelTerm) - if !(len(field1206) == 0) { + field1207 := unwrapped_fields1206[0].(string) + p.pretty_name(field1207) + field1208 := unwrapped_fields1206[1].([]*pb.RelTerm) + if !(len(field1208) == 0) { p.newline() - for i1208, elem1207 := range field1206 { - if (i1208 > 0) { + for i1210, elem1209 := range field1208 { + if (i1210 > 0) { p.newline() } - p.pretty_rel_term(elem1207) + p.pretty_rel_term(elem1209) } } p.dedent() @@ -2829,23 +2829,23 @@ func (p *PrettyPrinter) pretty_rel_atom(msg *pb.RelAtom) interface{} { } func (p *PrettyPrinter) pretty_cast(msg *pb.Cast) interface{} { - flat1214 := p.tryFlat(msg, func() { p.pretty_cast(msg) }) - if flat1214 != nil { - p.write(*flat1214) + flat1216 := p.tryFlat(msg, func() { p.pretty_cast(msg) }) + if flat1216 != nil { + p.write(*flat1216) return nil } else { _dollar_dollar := msg - fields1210 := []interface{}{_dollar_dollar.GetInput(), _dollar_dollar.GetResult()} - unwrapped_fields1211 := fields1210 + fields1212 := []interface{}{_dollar_dollar.GetInput(), _dollar_dollar.GetResult()} + unwrapped_fields1213 := fields1212 p.write("(") p.write("cast") p.indentSexp() p.newline() - field1212 := unwrapped_fields1211[0].(*pb.Term) - p.pretty_term(field1212) + field1214 := unwrapped_fields1213[0].(*pb.Term) + p.pretty_term(field1214) p.newline() - field1213 := unwrapped_fields1211[1].(*pb.Term) - p.pretty_term(field1213) + field1215 := unwrapped_fields1213[1].(*pb.Term) + p.pretty_term(field1215) p.dedent() p.write(")") } @@ -2853,22 +2853,22 @@ func (p *PrettyPrinter) pretty_cast(msg *pb.Cast) interface{} { } func (p *PrettyPrinter) pretty_attrs(msg []*pb.Attribute) interface{} { - flat1218 := p.tryFlat(msg, func() { p.pretty_attrs(msg) }) - if flat1218 != nil { - p.write(*flat1218) + flat1220 := p.tryFlat(msg, func() { p.pretty_attrs(msg) }) + if flat1220 != nil { + p.write(*flat1220) return nil } else { - fields1215 := msg + fields1217 := msg p.write("(") p.write("attrs") p.indentSexp() - if !(len(fields1215) == 0) { + if !(len(fields1217) == 0) { p.newline() - for i1217, elem1216 := range fields1215 { - if (i1217 > 0) { + for i1219, elem1218 := range fields1217 { + if (i1219 > 0) { p.newline() } - p.pretty_attribute(elem1216) + p.pretty_attribute(elem1218) } } p.dedent() @@ -2878,28 +2878,28 @@ func (p *PrettyPrinter) pretty_attrs(msg []*pb.Attribute) interface{} { } func (p *PrettyPrinter) pretty_attribute(msg *pb.Attribute) interface{} { - flat1225 := p.tryFlat(msg, func() { p.pretty_attribute(msg) }) - if flat1225 != nil { - p.write(*flat1225) + flat1227 := p.tryFlat(msg, func() { p.pretty_attribute(msg) }) + if flat1227 != nil { + p.write(*flat1227) return nil } else { _dollar_dollar := msg - fields1219 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetArgs()} - unwrapped_fields1220 := fields1219 + fields1221 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetArgs()} + unwrapped_fields1222 := fields1221 p.write("(") p.write("attribute") p.indentSexp() p.newline() - field1221 := unwrapped_fields1220[0].(string) - p.pretty_name(field1221) - field1222 := unwrapped_fields1220[1].([]*pb.Value) - if !(len(field1222) == 0) { + field1223 := unwrapped_fields1222[0].(string) + p.pretty_name(field1223) + field1224 := unwrapped_fields1222[1].([]*pb.Value) + if !(len(field1224) == 0) { p.newline() - for i1224, elem1223 := range field1222 { - if (i1224 > 0) { + for i1226, elem1225 := range field1224 { + if (i1226 > 0) { p.newline() } - p.pretty_raw_value(elem1223) + p.pretty_raw_value(elem1225) } } p.dedent() @@ -2909,30 +2909,30 @@ func (p *PrettyPrinter) pretty_attribute(msg *pb.Attribute) interface{} { } func (p *PrettyPrinter) pretty_algorithm(msg *pb.Algorithm) interface{} { - flat1232 := p.tryFlat(msg, func() { p.pretty_algorithm(msg) }) - if flat1232 != nil { - p.write(*flat1232) + flat1234 := p.tryFlat(msg, func() { p.pretty_algorithm(msg) }) + if flat1234 != nil { + p.write(*flat1234) return nil } else { _dollar_dollar := msg - fields1226 := []interface{}{_dollar_dollar.GetGlobal(), _dollar_dollar.GetBody()} - unwrapped_fields1227 := fields1226 + fields1228 := []interface{}{_dollar_dollar.GetGlobal(), _dollar_dollar.GetBody()} + unwrapped_fields1229 := fields1228 p.write("(") p.write("algorithm") p.indentSexp() - field1228 := unwrapped_fields1227[0].([]*pb.RelationId) - if !(len(field1228) == 0) { + field1230 := unwrapped_fields1229[0].([]*pb.RelationId) + if !(len(field1230) == 0) { p.newline() - for i1230, elem1229 := range field1228 { - if (i1230 > 0) { + for i1232, elem1231 := range field1230 { + if (i1232 > 0) { p.newline() } - p.pretty_relation_id(elem1229) + p.pretty_relation_id(elem1231) } } p.newline() - field1231 := unwrapped_fields1227[1].(*pb.Script) - p.pretty_script(field1231) + field1233 := unwrapped_fields1229[1].(*pb.Script) + p.pretty_script(field1233) p.dedent() p.write(")") } @@ -2940,24 +2940,24 @@ func (p *PrettyPrinter) pretty_algorithm(msg *pb.Algorithm) interface{} { } func (p *PrettyPrinter) pretty_script(msg *pb.Script) interface{} { - flat1237 := p.tryFlat(msg, func() { p.pretty_script(msg) }) - if flat1237 != nil { - p.write(*flat1237) + flat1239 := p.tryFlat(msg, func() { p.pretty_script(msg) }) + if flat1239 != nil { + p.write(*flat1239) return nil } else { _dollar_dollar := msg - fields1233 := _dollar_dollar.GetConstructs() - unwrapped_fields1234 := fields1233 + fields1235 := _dollar_dollar.GetConstructs() + unwrapped_fields1236 := fields1235 p.write("(") p.write("script") p.indentSexp() - if !(len(unwrapped_fields1234) == 0) { + if !(len(unwrapped_fields1236) == 0) { p.newline() - for i1236, elem1235 := range unwrapped_fields1234 { - if (i1236 > 0) { + for i1238, elem1237 := range unwrapped_fields1236 { + if (i1238 > 0) { p.newline() } - p.pretty_construct(elem1235) + p.pretty_construct(elem1237) } } p.dedent() @@ -2967,30 +2967,30 @@ func (p *PrettyPrinter) pretty_script(msg *pb.Script) interface{} { } func (p *PrettyPrinter) pretty_construct(msg *pb.Construct) interface{} { - flat1242 := p.tryFlat(msg, func() { p.pretty_construct(msg) }) - if flat1242 != nil { - p.write(*flat1242) + flat1244 := p.tryFlat(msg, func() { p.pretty_construct(msg) }) + if flat1244 != nil { + p.write(*flat1244) return nil } else { _dollar_dollar := msg - var _t1691 *pb.Loop + var _t1695 *pb.Loop if hasProtoField(_dollar_dollar, "loop") { - _t1691 = _dollar_dollar.GetLoop() + _t1695 = _dollar_dollar.GetLoop() } - deconstruct_result1240 := _t1691 - if deconstruct_result1240 != nil { - unwrapped1241 := deconstruct_result1240 - p.pretty_loop(unwrapped1241) + deconstruct_result1242 := _t1695 + if deconstruct_result1242 != nil { + unwrapped1243 := deconstruct_result1242 + p.pretty_loop(unwrapped1243) } else { _dollar_dollar := msg - var _t1692 *pb.Instruction + var _t1696 *pb.Instruction if hasProtoField(_dollar_dollar, "instruction") { - _t1692 = _dollar_dollar.GetInstruction() + _t1696 = _dollar_dollar.GetInstruction() } - deconstruct_result1238 := _t1692 - if deconstruct_result1238 != nil { - unwrapped1239 := deconstruct_result1238 - p.pretty_instruction(unwrapped1239) + deconstruct_result1240 := _t1696 + if deconstruct_result1240 != nil { + unwrapped1241 := deconstruct_result1240 + p.pretty_instruction(unwrapped1241) } else { panic(ParseError{msg: "No matching rule for construct"}) } @@ -3000,23 +3000,23 @@ func (p *PrettyPrinter) pretty_construct(msg *pb.Construct) interface{} { } func (p *PrettyPrinter) pretty_loop(msg *pb.Loop) interface{} { - flat1247 := p.tryFlat(msg, func() { p.pretty_loop(msg) }) - if flat1247 != nil { - p.write(*flat1247) + flat1249 := p.tryFlat(msg, func() { p.pretty_loop(msg) }) + if flat1249 != nil { + p.write(*flat1249) return nil } else { _dollar_dollar := msg - fields1243 := []interface{}{_dollar_dollar.GetInit(), _dollar_dollar.GetBody()} - unwrapped_fields1244 := fields1243 + fields1245 := []interface{}{_dollar_dollar.GetInit(), _dollar_dollar.GetBody()} + unwrapped_fields1246 := fields1245 p.write("(") p.write("loop") p.indentSexp() p.newline() - field1245 := unwrapped_fields1244[0].([]*pb.Instruction) - p.pretty_init(field1245) + field1247 := unwrapped_fields1246[0].([]*pb.Instruction) + p.pretty_init(field1247) p.newline() - field1246 := unwrapped_fields1244[1].(*pb.Script) - p.pretty_script(field1246) + field1248 := unwrapped_fields1246[1].(*pb.Script) + p.pretty_script(field1248) p.dedent() p.write(")") } @@ -3024,22 +3024,22 @@ func (p *PrettyPrinter) pretty_loop(msg *pb.Loop) interface{} { } func (p *PrettyPrinter) pretty_init(msg []*pb.Instruction) interface{} { - flat1251 := p.tryFlat(msg, func() { p.pretty_init(msg) }) - if flat1251 != nil { - p.write(*flat1251) + flat1253 := p.tryFlat(msg, func() { p.pretty_init(msg) }) + if flat1253 != nil { + p.write(*flat1253) return nil } else { - fields1248 := msg + fields1250 := msg p.write("(") p.write("init") p.indentSexp() - if !(len(fields1248) == 0) { + if !(len(fields1250) == 0) { p.newline() - for i1250, elem1249 := range fields1248 { - if (i1250 > 0) { + for i1252, elem1251 := range fields1250 { + if (i1252 > 0) { p.newline() } - p.pretty_instruction(elem1249) + p.pretty_instruction(elem1251) } } p.dedent() @@ -3049,60 +3049,60 @@ func (p *PrettyPrinter) pretty_init(msg []*pb.Instruction) interface{} { } func (p *PrettyPrinter) pretty_instruction(msg *pb.Instruction) interface{} { - flat1262 := p.tryFlat(msg, func() { p.pretty_instruction(msg) }) - if flat1262 != nil { - p.write(*flat1262) + flat1264 := p.tryFlat(msg, func() { p.pretty_instruction(msg) }) + if flat1264 != nil { + p.write(*flat1264) return nil } else { _dollar_dollar := msg - var _t1693 *pb.Assign + var _t1697 *pb.Assign if hasProtoField(_dollar_dollar, "assign") { - _t1693 = _dollar_dollar.GetAssign() + _t1697 = _dollar_dollar.GetAssign() } - deconstruct_result1260 := _t1693 - if deconstruct_result1260 != nil { - unwrapped1261 := deconstruct_result1260 - p.pretty_assign(unwrapped1261) + deconstruct_result1262 := _t1697 + if deconstruct_result1262 != nil { + unwrapped1263 := deconstruct_result1262 + p.pretty_assign(unwrapped1263) } else { _dollar_dollar := msg - var _t1694 *pb.Upsert + var _t1698 *pb.Upsert if hasProtoField(_dollar_dollar, "upsert") { - _t1694 = _dollar_dollar.GetUpsert() + _t1698 = _dollar_dollar.GetUpsert() } - deconstruct_result1258 := _t1694 - if deconstruct_result1258 != nil { - unwrapped1259 := deconstruct_result1258 - p.pretty_upsert(unwrapped1259) + deconstruct_result1260 := _t1698 + if deconstruct_result1260 != nil { + unwrapped1261 := deconstruct_result1260 + p.pretty_upsert(unwrapped1261) } else { _dollar_dollar := msg - var _t1695 *pb.Break + var _t1699 *pb.Break if hasProtoField(_dollar_dollar, "break") { - _t1695 = _dollar_dollar.GetBreak() + _t1699 = _dollar_dollar.GetBreak() } - deconstruct_result1256 := _t1695 - if deconstruct_result1256 != nil { - unwrapped1257 := deconstruct_result1256 - p.pretty_break(unwrapped1257) + deconstruct_result1258 := _t1699 + if deconstruct_result1258 != nil { + unwrapped1259 := deconstruct_result1258 + p.pretty_break(unwrapped1259) } else { _dollar_dollar := msg - var _t1696 *pb.MonoidDef + var _t1700 *pb.MonoidDef if hasProtoField(_dollar_dollar, "monoid_def") { - _t1696 = _dollar_dollar.GetMonoidDef() + _t1700 = _dollar_dollar.GetMonoidDef() } - deconstruct_result1254 := _t1696 - if deconstruct_result1254 != nil { - unwrapped1255 := deconstruct_result1254 - p.pretty_monoid_def(unwrapped1255) + deconstruct_result1256 := _t1700 + if deconstruct_result1256 != nil { + unwrapped1257 := deconstruct_result1256 + p.pretty_monoid_def(unwrapped1257) } else { _dollar_dollar := msg - var _t1697 *pb.MonusDef + var _t1701 *pb.MonusDef if hasProtoField(_dollar_dollar, "monus_def") { - _t1697 = _dollar_dollar.GetMonusDef() + _t1701 = _dollar_dollar.GetMonusDef() } - deconstruct_result1252 := _t1697 - if deconstruct_result1252 != nil { - unwrapped1253 := deconstruct_result1252 - p.pretty_monus_def(unwrapped1253) + deconstruct_result1254 := _t1701 + if deconstruct_result1254 != nil { + unwrapped1255 := deconstruct_result1254 + p.pretty_monus_def(unwrapped1255) } else { panic(ParseError{msg: "No matching rule for instruction"}) } @@ -3115,32 +3115,32 @@ func (p *PrettyPrinter) pretty_instruction(msg *pb.Instruction) interface{} { } func (p *PrettyPrinter) pretty_assign(msg *pb.Assign) interface{} { - flat1269 := p.tryFlat(msg, func() { p.pretty_assign(msg) }) - if flat1269 != nil { - p.write(*flat1269) + flat1271 := p.tryFlat(msg, func() { p.pretty_assign(msg) }) + if flat1271 != nil { + p.write(*flat1271) return nil } else { _dollar_dollar := msg - var _t1698 []*pb.Attribute + var _t1702 []*pb.Attribute if !(len(_dollar_dollar.GetAttrs()) == 0) { - _t1698 = _dollar_dollar.GetAttrs() + _t1702 = _dollar_dollar.GetAttrs() } - fields1263 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetBody(), _t1698} - unwrapped_fields1264 := fields1263 + fields1265 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetBody(), _t1702} + unwrapped_fields1266 := fields1265 p.write("(") p.write("assign") p.indentSexp() p.newline() - field1265 := unwrapped_fields1264[0].(*pb.RelationId) - p.pretty_relation_id(field1265) + field1267 := unwrapped_fields1266[0].(*pb.RelationId) + p.pretty_relation_id(field1267) p.newline() - field1266 := unwrapped_fields1264[1].(*pb.Abstraction) - p.pretty_abstraction(field1266) - field1267 := unwrapped_fields1264[2].([]*pb.Attribute) - if field1267 != nil { + field1268 := unwrapped_fields1266[1].(*pb.Abstraction) + p.pretty_abstraction(field1268) + field1269 := unwrapped_fields1266[2].([]*pb.Attribute) + if field1269 != nil { p.newline() - opt_val1268 := field1267 - p.pretty_attrs(opt_val1268) + opt_val1270 := field1269 + p.pretty_attrs(opt_val1270) } p.dedent() p.write(")") @@ -3149,32 +3149,32 @@ func (p *PrettyPrinter) pretty_assign(msg *pb.Assign) interface{} { } func (p *PrettyPrinter) pretty_upsert(msg *pb.Upsert) interface{} { - flat1276 := p.tryFlat(msg, func() { p.pretty_upsert(msg) }) - if flat1276 != nil { - p.write(*flat1276) + flat1278 := p.tryFlat(msg, func() { p.pretty_upsert(msg) }) + if flat1278 != nil { + p.write(*flat1278) return nil } else { _dollar_dollar := msg - var _t1699 []*pb.Attribute + var _t1703 []*pb.Attribute if !(len(_dollar_dollar.GetAttrs()) == 0) { - _t1699 = _dollar_dollar.GetAttrs() + _t1703 = _dollar_dollar.GetAttrs() } - fields1270 := []interface{}{_dollar_dollar.GetName(), []interface{}{_dollar_dollar.GetBody(), _dollar_dollar.GetValueArity()}, _t1699} - unwrapped_fields1271 := fields1270 + fields1272 := []interface{}{_dollar_dollar.GetName(), []interface{}{_dollar_dollar.GetBody(), _dollar_dollar.GetValueArity()}, _t1703} + unwrapped_fields1273 := fields1272 p.write("(") p.write("upsert") p.indentSexp() p.newline() - field1272 := unwrapped_fields1271[0].(*pb.RelationId) - p.pretty_relation_id(field1272) + field1274 := unwrapped_fields1273[0].(*pb.RelationId) + p.pretty_relation_id(field1274) p.newline() - field1273 := unwrapped_fields1271[1].([]interface{}) - p.pretty_abstraction_with_arity(field1273) - field1274 := unwrapped_fields1271[2].([]*pb.Attribute) - if field1274 != nil { + field1275 := unwrapped_fields1273[1].([]interface{}) + p.pretty_abstraction_with_arity(field1275) + field1276 := unwrapped_fields1273[2].([]*pb.Attribute) + if field1276 != nil { p.newline() - opt_val1275 := field1274 - p.pretty_attrs(opt_val1275) + opt_val1277 := field1276 + p.pretty_attrs(opt_val1277) } p.dedent() p.write(")") @@ -3183,22 +3183,22 @@ func (p *PrettyPrinter) pretty_upsert(msg *pb.Upsert) interface{} { } func (p *PrettyPrinter) pretty_abstraction_with_arity(msg []interface{}) interface{} { - flat1281 := p.tryFlat(msg, func() { p.pretty_abstraction_with_arity(msg) }) - if flat1281 != nil { - p.write(*flat1281) + flat1283 := p.tryFlat(msg, func() { p.pretty_abstraction_with_arity(msg) }) + if flat1283 != nil { + p.write(*flat1283) return nil } else { _dollar_dollar := msg - _t1700 := p.deconstruct_bindings_with_arity(_dollar_dollar[0].(*pb.Abstraction), _dollar_dollar[1].(int64)) - fields1277 := []interface{}{_t1700, _dollar_dollar[0].(*pb.Abstraction).GetValue()} - unwrapped_fields1278 := fields1277 + _t1704 := p.deconstruct_bindings_with_arity(_dollar_dollar[0].(*pb.Abstraction), _dollar_dollar[1].(int64)) + fields1279 := []interface{}{_t1704, _dollar_dollar[0].(*pb.Abstraction).GetValue()} + unwrapped_fields1280 := fields1279 p.write("(") p.indent() - field1279 := unwrapped_fields1278[0].([]interface{}) - p.pretty_bindings(field1279) + field1281 := unwrapped_fields1280[0].([]interface{}) + p.pretty_bindings(field1281) p.newline() - field1280 := unwrapped_fields1278[1].(*pb.Formula) - p.pretty_formula(field1280) + field1282 := unwrapped_fields1280[1].(*pb.Formula) + p.pretty_formula(field1282) p.dedent() p.write(")") } @@ -3206,32 +3206,32 @@ func (p *PrettyPrinter) pretty_abstraction_with_arity(msg []interface{}) interfa } func (p *PrettyPrinter) pretty_break(msg *pb.Break) interface{} { - flat1288 := p.tryFlat(msg, func() { p.pretty_break(msg) }) - if flat1288 != nil { - p.write(*flat1288) + flat1290 := p.tryFlat(msg, func() { p.pretty_break(msg) }) + if flat1290 != nil { + p.write(*flat1290) return nil } else { _dollar_dollar := msg - var _t1701 []*pb.Attribute + var _t1705 []*pb.Attribute if !(len(_dollar_dollar.GetAttrs()) == 0) { - _t1701 = _dollar_dollar.GetAttrs() + _t1705 = _dollar_dollar.GetAttrs() } - fields1282 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetBody(), _t1701} - unwrapped_fields1283 := fields1282 + fields1284 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetBody(), _t1705} + unwrapped_fields1285 := fields1284 p.write("(") p.write("break") p.indentSexp() p.newline() - field1284 := unwrapped_fields1283[0].(*pb.RelationId) - p.pretty_relation_id(field1284) + field1286 := unwrapped_fields1285[0].(*pb.RelationId) + p.pretty_relation_id(field1286) p.newline() - field1285 := unwrapped_fields1283[1].(*pb.Abstraction) - p.pretty_abstraction(field1285) - field1286 := unwrapped_fields1283[2].([]*pb.Attribute) - if field1286 != nil { + field1287 := unwrapped_fields1285[1].(*pb.Abstraction) + p.pretty_abstraction(field1287) + field1288 := unwrapped_fields1285[2].([]*pb.Attribute) + if field1288 != nil { p.newline() - opt_val1287 := field1286 - p.pretty_attrs(opt_val1287) + opt_val1289 := field1288 + p.pretty_attrs(opt_val1289) } p.dedent() p.write(")") @@ -3240,35 +3240,35 @@ func (p *PrettyPrinter) pretty_break(msg *pb.Break) interface{} { } func (p *PrettyPrinter) pretty_monoid_def(msg *pb.MonoidDef) interface{} { - flat1296 := p.tryFlat(msg, func() { p.pretty_monoid_def(msg) }) - if flat1296 != nil { - p.write(*flat1296) + flat1298 := p.tryFlat(msg, func() { p.pretty_monoid_def(msg) }) + if flat1298 != nil { + p.write(*flat1298) return nil } else { _dollar_dollar := msg - var _t1702 []*pb.Attribute + var _t1706 []*pb.Attribute if !(len(_dollar_dollar.GetAttrs()) == 0) { - _t1702 = _dollar_dollar.GetAttrs() + _t1706 = _dollar_dollar.GetAttrs() } - fields1289 := []interface{}{_dollar_dollar.GetMonoid(), _dollar_dollar.GetName(), []interface{}{_dollar_dollar.GetBody(), _dollar_dollar.GetValueArity()}, _t1702} - unwrapped_fields1290 := fields1289 + fields1291 := []interface{}{_dollar_dollar.GetMonoid(), _dollar_dollar.GetName(), []interface{}{_dollar_dollar.GetBody(), _dollar_dollar.GetValueArity()}, _t1706} + unwrapped_fields1292 := fields1291 p.write("(") p.write("monoid") p.indentSexp() p.newline() - field1291 := unwrapped_fields1290[0].(*pb.Monoid) - p.pretty_monoid(field1291) + field1293 := unwrapped_fields1292[0].(*pb.Monoid) + p.pretty_monoid(field1293) p.newline() - field1292 := unwrapped_fields1290[1].(*pb.RelationId) - p.pretty_relation_id(field1292) + field1294 := unwrapped_fields1292[1].(*pb.RelationId) + p.pretty_relation_id(field1294) p.newline() - field1293 := unwrapped_fields1290[2].([]interface{}) - p.pretty_abstraction_with_arity(field1293) - field1294 := unwrapped_fields1290[3].([]*pb.Attribute) - if field1294 != nil { + field1295 := unwrapped_fields1292[2].([]interface{}) + p.pretty_abstraction_with_arity(field1295) + field1296 := unwrapped_fields1292[3].([]*pb.Attribute) + if field1296 != nil { p.newline() - opt_val1295 := field1294 - p.pretty_attrs(opt_val1295) + opt_val1297 := field1296 + p.pretty_attrs(opt_val1297) } p.dedent() p.write(")") @@ -3277,50 +3277,50 @@ func (p *PrettyPrinter) pretty_monoid_def(msg *pb.MonoidDef) interface{} { } func (p *PrettyPrinter) pretty_monoid(msg *pb.Monoid) interface{} { - flat1305 := p.tryFlat(msg, func() { p.pretty_monoid(msg) }) - if flat1305 != nil { - p.write(*flat1305) + flat1307 := p.tryFlat(msg, func() { p.pretty_monoid(msg) }) + if flat1307 != nil { + p.write(*flat1307) return nil } else { _dollar_dollar := msg - var _t1703 *pb.OrMonoid + var _t1707 *pb.OrMonoid if hasProtoField(_dollar_dollar, "or_monoid") { - _t1703 = _dollar_dollar.GetOrMonoid() + _t1707 = _dollar_dollar.GetOrMonoid() } - deconstruct_result1303 := _t1703 - if deconstruct_result1303 != nil { - unwrapped1304 := deconstruct_result1303 - p.pretty_or_monoid(unwrapped1304) + deconstruct_result1305 := _t1707 + if deconstruct_result1305 != nil { + unwrapped1306 := deconstruct_result1305 + p.pretty_or_monoid(unwrapped1306) } else { _dollar_dollar := msg - var _t1704 *pb.MinMonoid + var _t1708 *pb.MinMonoid if hasProtoField(_dollar_dollar, "min_monoid") { - _t1704 = _dollar_dollar.GetMinMonoid() + _t1708 = _dollar_dollar.GetMinMonoid() } - deconstruct_result1301 := _t1704 - if deconstruct_result1301 != nil { - unwrapped1302 := deconstruct_result1301 - p.pretty_min_monoid(unwrapped1302) + deconstruct_result1303 := _t1708 + if deconstruct_result1303 != nil { + unwrapped1304 := deconstruct_result1303 + p.pretty_min_monoid(unwrapped1304) } else { _dollar_dollar := msg - var _t1705 *pb.MaxMonoid + var _t1709 *pb.MaxMonoid if hasProtoField(_dollar_dollar, "max_monoid") { - _t1705 = _dollar_dollar.GetMaxMonoid() + _t1709 = _dollar_dollar.GetMaxMonoid() } - deconstruct_result1299 := _t1705 - if deconstruct_result1299 != nil { - unwrapped1300 := deconstruct_result1299 - p.pretty_max_monoid(unwrapped1300) + deconstruct_result1301 := _t1709 + if deconstruct_result1301 != nil { + unwrapped1302 := deconstruct_result1301 + p.pretty_max_monoid(unwrapped1302) } else { _dollar_dollar := msg - var _t1706 *pb.SumMonoid + var _t1710 *pb.SumMonoid if hasProtoField(_dollar_dollar, "sum_monoid") { - _t1706 = _dollar_dollar.GetSumMonoid() + _t1710 = _dollar_dollar.GetSumMonoid() } - deconstruct_result1297 := _t1706 - if deconstruct_result1297 != nil { - unwrapped1298 := deconstruct_result1297 - p.pretty_sum_monoid(unwrapped1298) + deconstruct_result1299 := _t1710 + if deconstruct_result1299 != nil { + unwrapped1300 := deconstruct_result1299 + p.pretty_sum_monoid(unwrapped1300) } else { panic(ParseError{msg: "No matching rule for monoid"}) } @@ -3332,8 +3332,8 @@ func (p *PrettyPrinter) pretty_monoid(msg *pb.Monoid) interface{} { } func (p *PrettyPrinter) pretty_or_monoid(msg *pb.OrMonoid) interface{} { - fields1306 := msg - _ = fields1306 + fields1308 := msg + _ = fields1308 p.write("(") p.write("or") p.write(")") @@ -3341,19 +3341,19 @@ func (p *PrettyPrinter) pretty_or_monoid(msg *pb.OrMonoid) interface{} { } func (p *PrettyPrinter) pretty_min_monoid(msg *pb.MinMonoid) interface{} { - flat1309 := p.tryFlat(msg, func() { p.pretty_min_monoid(msg) }) - if flat1309 != nil { - p.write(*flat1309) + flat1311 := p.tryFlat(msg, func() { p.pretty_min_monoid(msg) }) + if flat1311 != nil { + p.write(*flat1311) return nil } else { _dollar_dollar := msg - fields1307 := _dollar_dollar.GetType() - unwrapped_fields1308 := fields1307 + fields1309 := _dollar_dollar.GetType() + unwrapped_fields1310 := fields1309 p.write("(") p.write("min") p.indentSexp() p.newline() - p.pretty_type(unwrapped_fields1308) + p.pretty_type(unwrapped_fields1310) p.dedent() p.write(")") } @@ -3361,19 +3361,19 @@ func (p *PrettyPrinter) pretty_min_monoid(msg *pb.MinMonoid) interface{} { } func (p *PrettyPrinter) pretty_max_monoid(msg *pb.MaxMonoid) interface{} { - flat1312 := p.tryFlat(msg, func() { p.pretty_max_monoid(msg) }) - if flat1312 != nil { - p.write(*flat1312) + flat1314 := p.tryFlat(msg, func() { p.pretty_max_monoid(msg) }) + if flat1314 != nil { + p.write(*flat1314) return nil } else { _dollar_dollar := msg - fields1310 := _dollar_dollar.GetType() - unwrapped_fields1311 := fields1310 + fields1312 := _dollar_dollar.GetType() + unwrapped_fields1313 := fields1312 p.write("(") p.write("max") p.indentSexp() p.newline() - p.pretty_type(unwrapped_fields1311) + p.pretty_type(unwrapped_fields1313) p.dedent() p.write(")") } @@ -3381,19 +3381,19 @@ func (p *PrettyPrinter) pretty_max_monoid(msg *pb.MaxMonoid) interface{} { } func (p *PrettyPrinter) pretty_sum_monoid(msg *pb.SumMonoid) interface{} { - flat1315 := p.tryFlat(msg, func() { p.pretty_sum_monoid(msg) }) - if flat1315 != nil { - p.write(*flat1315) + flat1317 := p.tryFlat(msg, func() { p.pretty_sum_monoid(msg) }) + if flat1317 != nil { + p.write(*flat1317) return nil } else { _dollar_dollar := msg - fields1313 := _dollar_dollar.GetType() - unwrapped_fields1314 := fields1313 + fields1315 := _dollar_dollar.GetType() + unwrapped_fields1316 := fields1315 p.write("(") p.write("sum") p.indentSexp() p.newline() - p.pretty_type(unwrapped_fields1314) + p.pretty_type(unwrapped_fields1316) p.dedent() p.write(")") } @@ -3401,35 +3401,35 @@ func (p *PrettyPrinter) pretty_sum_monoid(msg *pb.SumMonoid) interface{} { } func (p *PrettyPrinter) pretty_monus_def(msg *pb.MonusDef) interface{} { - flat1323 := p.tryFlat(msg, func() { p.pretty_monus_def(msg) }) - if flat1323 != nil { - p.write(*flat1323) + flat1325 := p.tryFlat(msg, func() { p.pretty_monus_def(msg) }) + if flat1325 != nil { + p.write(*flat1325) return nil } else { _dollar_dollar := msg - var _t1707 []*pb.Attribute + var _t1711 []*pb.Attribute if !(len(_dollar_dollar.GetAttrs()) == 0) { - _t1707 = _dollar_dollar.GetAttrs() + _t1711 = _dollar_dollar.GetAttrs() } - fields1316 := []interface{}{_dollar_dollar.GetMonoid(), _dollar_dollar.GetName(), []interface{}{_dollar_dollar.GetBody(), _dollar_dollar.GetValueArity()}, _t1707} - unwrapped_fields1317 := fields1316 + fields1318 := []interface{}{_dollar_dollar.GetMonoid(), _dollar_dollar.GetName(), []interface{}{_dollar_dollar.GetBody(), _dollar_dollar.GetValueArity()}, _t1711} + unwrapped_fields1319 := fields1318 p.write("(") p.write("monus") p.indentSexp() p.newline() - field1318 := unwrapped_fields1317[0].(*pb.Monoid) - p.pretty_monoid(field1318) + field1320 := unwrapped_fields1319[0].(*pb.Monoid) + p.pretty_monoid(field1320) p.newline() - field1319 := unwrapped_fields1317[1].(*pb.RelationId) - p.pretty_relation_id(field1319) + field1321 := unwrapped_fields1319[1].(*pb.RelationId) + p.pretty_relation_id(field1321) p.newline() - field1320 := unwrapped_fields1317[2].([]interface{}) - p.pretty_abstraction_with_arity(field1320) - field1321 := unwrapped_fields1317[3].([]*pb.Attribute) - if field1321 != nil { + field1322 := unwrapped_fields1319[2].([]interface{}) + p.pretty_abstraction_with_arity(field1322) + field1323 := unwrapped_fields1319[3].([]*pb.Attribute) + if field1323 != nil { p.newline() - opt_val1322 := field1321 - p.pretty_attrs(opt_val1322) + opt_val1324 := field1323 + p.pretty_attrs(opt_val1324) } p.dedent() p.write(")") @@ -3438,29 +3438,29 @@ func (p *PrettyPrinter) pretty_monus_def(msg *pb.MonusDef) interface{} { } func (p *PrettyPrinter) pretty_constraint(msg *pb.Constraint) interface{} { - flat1330 := p.tryFlat(msg, func() { p.pretty_constraint(msg) }) - if flat1330 != nil { - p.write(*flat1330) + flat1332 := p.tryFlat(msg, func() { p.pretty_constraint(msg) }) + if flat1332 != nil { + p.write(*flat1332) return nil } else { _dollar_dollar := msg - fields1324 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetFunctionalDependency().GetGuard(), _dollar_dollar.GetFunctionalDependency().GetKeys(), _dollar_dollar.GetFunctionalDependency().GetValues()} - unwrapped_fields1325 := fields1324 + fields1326 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetFunctionalDependency().GetGuard(), _dollar_dollar.GetFunctionalDependency().GetKeys(), _dollar_dollar.GetFunctionalDependency().GetValues()} + unwrapped_fields1327 := fields1326 p.write("(") p.write("functional_dependency") p.indentSexp() p.newline() - field1326 := unwrapped_fields1325[0].(*pb.RelationId) - p.pretty_relation_id(field1326) + field1328 := unwrapped_fields1327[0].(*pb.RelationId) + p.pretty_relation_id(field1328) p.newline() - field1327 := unwrapped_fields1325[1].(*pb.Abstraction) - p.pretty_abstraction(field1327) + field1329 := unwrapped_fields1327[1].(*pb.Abstraction) + p.pretty_abstraction(field1329) p.newline() - field1328 := unwrapped_fields1325[2].([]*pb.Var) - p.pretty_functional_dependency_keys(field1328) + field1330 := unwrapped_fields1327[2].([]*pb.Var) + p.pretty_functional_dependency_keys(field1330) p.newline() - field1329 := unwrapped_fields1325[3].([]*pb.Var) - p.pretty_functional_dependency_values(field1329) + field1331 := unwrapped_fields1327[3].([]*pb.Var) + p.pretty_functional_dependency_values(field1331) p.dedent() p.write(")") } @@ -3468,22 +3468,22 @@ func (p *PrettyPrinter) pretty_constraint(msg *pb.Constraint) interface{} { } func (p *PrettyPrinter) pretty_functional_dependency_keys(msg []*pb.Var) interface{} { - flat1334 := p.tryFlat(msg, func() { p.pretty_functional_dependency_keys(msg) }) - if flat1334 != nil { - p.write(*flat1334) + flat1336 := p.tryFlat(msg, func() { p.pretty_functional_dependency_keys(msg) }) + if flat1336 != nil { + p.write(*flat1336) return nil } else { - fields1331 := msg + fields1333 := msg p.write("(") p.write("keys") p.indentSexp() - if !(len(fields1331) == 0) { + if !(len(fields1333) == 0) { p.newline() - for i1333, elem1332 := range fields1331 { - if (i1333 > 0) { + for i1335, elem1334 := range fields1333 { + if (i1335 > 0) { p.newline() } - p.pretty_var(elem1332) + p.pretty_var(elem1334) } } p.dedent() @@ -3493,22 +3493,22 @@ func (p *PrettyPrinter) pretty_functional_dependency_keys(msg []*pb.Var) interfa } func (p *PrettyPrinter) pretty_functional_dependency_values(msg []*pb.Var) interface{} { - flat1338 := p.tryFlat(msg, func() { p.pretty_functional_dependency_values(msg) }) - if flat1338 != nil { - p.write(*flat1338) + flat1340 := p.tryFlat(msg, func() { p.pretty_functional_dependency_values(msg) }) + if flat1340 != nil { + p.write(*flat1340) return nil } else { - fields1335 := msg + fields1337 := msg p.write("(") p.write("values") p.indentSexp() - if !(len(fields1335) == 0) { + if !(len(fields1337) == 0) { p.newline() - for i1337, elem1336 := range fields1335 { - if (i1337 > 0) { + for i1339, elem1338 := range fields1337 { + if (i1339 > 0) { p.newline() } - p.pretty_var(elem1336) + p.pretty_var(elem1338) } } p.dedent() @@ -3518,50 +3518,50 @@ func (p *PrettyPrinter) pretty_functional_dependency_values(msg []*pb.Var) inter } func (p *PrettyPrinter) pretty_data(msg *pb.Data) interface{} { - flat1347 := p.tryFlat(msg, func() { p.pretty_data(msg) }) - if flat1347 != nil { - p.write(*flat1347) + flat1349 := p.tryFlat(msg, func() { p.pretty_data(msg) }) + if flat1349 != nil { + p.write(*flat1349) return nil } else { _dollar_dollar := msg - var _t1708 *pb.EDB + var _t1712 *pb.EDB if hasProtoField(_dollar_dollar, "edb") { - _t1708 = _dollar_dollar.GetEdb() + _t1712 = _dollar_dollar.GetEdb() } - deconstruct_result1345 := _t1708 - if deconstruct_result1345 != nil { - unwrapped1346 := deconstruct_result1345 - p.pretty_edb(unwrapped1346) + deconstruct_result1347 := _t1712 + if deconstruct_result1347 != nil { + unwrapped1348 := deconstruct_result1347 + p.pretty_edb(unwrapped1348) } else { _dollar_dollar := msg - var _t1709 *pb.BeTreeRelation + var _t1713 *pb.BeTreeRelation if hasProtoField(_dollar_dollar, "betree_relation") { - _t1709 = _dollar_dollar.GetBetreeRelation() + _t1713 = _dollar_dollar.GetBetreeRelation() } - deconstruct_result1343 := _t1709 - if deconstruct_result1343 != nil { - unwrapped1344 := deconstruct_result1343 - p.pretty_betree_relation(unwrapped1344) + deconstruct_result1345 := _t1713 + if deconstruct_result1345 != nil { + unwrapped1346 := deconstruct_result1345 + p.pretty_betree_relation(unwrapped1346) } else { _dollar_dollar := msg - var _t1710 *pb.CSVData + var _t1714 *pb.CSVData if hasProtoField(_dollar_dollar, "csv_data") { - _t1710 = _dollar_dollar.GetCsvData() + _t1714 = _dollar_dollar.GetCsvData() } - deconstruct_result1341 := _t1710 - if deconstruct_result1341 != nil { - unwrapped1342 := deconstruct_result1341 - p.pretty_csv_data(unwrapped1342) + deconstruct_result1343 := _t1714 + if deconstruct_result1343 != nil { + unwrapped1344 := deconstruct_result1343 + p.pretty_csv_data(unwrapped1344) } else { _dollar_dollar := msg - var _t1711 *pb.IcebergData + var _t1715 *pb.IcebergData if hasProtoField(_dollar_dollar, "iceberg_data") { - _t1711 = _dollar_dollar.GetIcebergData() + _t1715 = _dollar_dollar.GetIcebergData() } - deconstruct_result1339 := _t1711 - if deconstruct_result1339 != nil { - unwrapped1340 := deconstruct_result1339 - p.pretty_iceberg_data(unwrapped1340) + deconstruct_result1341 := _t1715 + if deconstruct_result1341 != nil { + unwrapped1342 := deconstruct_result1341 + p.pretty_iceberg_data(unwrapped1342) } else { panic(ParseError{msg: "No matching rule for data"}) } @@ -3573,26 +3573,26 @@ func (p *PrettyPrinter) pretty_data(msg *pb.Data) interface{} { } func (p *PrettyPrinter) pretty_edb(msg *pb.EDB) interface{} { - flat1353 := p.tryFlat(msg, func() { p.pretty_edb(msg) }) - if flat1353 != nil { - p.write(*flat1353) + flat1355 := p.tryFlat(msg, func() { p.pretty_edb(msg) }) + if flat1355 != nil { + p.write(*flat1355) return nil } else { _dollar_dollar := msg - fields1348 := []interface{}{_dollar_dollar.GetTargetId(), _dollar_dollar.GetPath(), _dollar_dollar.GetTypes()} - unwrapped_fields1349 := fields1348 + fields1350 := []interface{}{_dollar_dollar.GetTargetId(), _dollar_dollar.GetPath(), _dollar_dollar.GetTypes()} + unwrapped_fields1351 := fields1350 p.write("(") p.write("edb") p.indentSexp() p.newline() - field1350 := unwrapped_fields1349[0].(*pb.RelationId) - p.pretty_relation_id(field1350) + field1352 := unwrapped_fields1351[0].(*pb.RelationId) + p.pretty_relation_id(field1352) p.newline() - field1351 := unwrapped_fields1349[1].([]string) - p.pretty_edb_path(field1351) + field1353 := unwrapped_fields1351[1].([]string) + p.pretty_edb_path(field1353) p.newline() - field1352 := unwrapped_fields1349[2].([]*pb.Type) - p.pretty_edb_types(field1352) + field1354 := unwrapped_fields1351[2].([]*pb.Type) + p.pretty_edb_types(field1354) p.dedent() p.write(")") } @@ -3600,19 +3600,19 @@ func (p *PrettyPrinter) pretty_edb(msg *pb.EDB) interface{} { } func (p *PrettyPrinter) pretty_edb_path(msg []string) interface{} { - flat1357 := p.tryFlat(msg, func() { p.pretty_edb_path(msg) }) - if flat1357 != nil { - p.write(*flat1357) + flat1359 := p.tryFlat(msg, func() { p.pretty_edb_path(msg) }) + if flat1359 != nil { + p.write(*flat1359) return nil } else { - fields1354 := msg + fields1356 := msg p.write("[") p.indent() - for i1356, elem1355 := range fields1354 { - if (i1356 > 0) { + for i1358, elem1357 := range fields1356 { + if (i1358 > 0) { p.newline() } - p.write(p.formatStringValue(elem1355)) + p.write(p.formatStringValue(elem1357)) } p.dedent() p.write("]") @@ -3621,19 +3621,19 @@ func (p *PrettyPrinter) pretty_edb_path(msg []string) interface{} { } func (p *PrettyPrinter) pretty_edb_types(msg []*pb.Type) interface{} { - flat1361 := p.tryFlat(msg, func() { p.pretty_edb_types(msg) }) - if flat1361 != nil { - p.write(*flat1361) + flat1363 := p.tryFlat(msg, func() { p.pretty_edb_types(msg) }) + if flat1363 != nil { + p.write(*flat1363) return nil } else { - fields1358 := msg + fields1360 := msg p.write("[") p.indent() - for i1360, elem1359 := range fields1358 { - if (i1360 > 0) { + for i1362, elem1361 := range fields1360 { + if (i1362 > 0) { p.newline() } - p.pretty_type(elem1359) + p.pretty_type(elem1361) } p.dedent() p.write("]") @@ -3642,23 +3642,23 @@ func (p *PrettyPrinter) pretty_edb_types(msg []*pb.Type) interface{} { } func (p *PrettyPrinter) pretty_betree_relation(msg *pb.BeTreeRelation) interface{} { - flat1366 := p.tryFlat(msg, func() { p.pretty_betree_relation(msg) }) - if flat1366 != nil { - p.write(*flat1366) + flat1368 := p.tryFlat(msg, func() { p.pretty_betree_relation(msg) }) + if flat1368 != nil { + p.write(*flat1368) return nil } else { _dollar_dollar := msg - fields1362 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetRelationInfo()} - unwrapped_fields1363 := fields1362 + fields1364 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetRelationInfo()} + unwrapped_fields1365 := fields1364 p.write("(") p.write("betree_relation") p.indentSexp() p.newline() - field1364 := unwrapped_fields1363[0].(*pb.RelationId) - p.pretty_relation_id(field1364) + field1366 := unwrapped_fields1365[0].(*pb.RelationId) + p.pretty_relation_id(field1366) p.newline() - field1365 := unwrapped_fields1363[1].(*pb.BeTreeInfo) - p.pretty_betree_info(field1365) + field1367 := unwrapped_fields1365[1].(*pb.BeTreeInfo) + p.pretty_betree_info(field1367) p.dedent() p.write(")") } @@ -3666,27 +3666,27 @@ func (p *PrettyPrinter) pretty_betree_relation(msg *pb.BeTreeRelation) interface } func (p *PrettyPrinter) pretty_betree_info(msg *pb.BeTreeInfo) interface{} { - flat1372 := p.tryFlat(msg, func() { p.pretty_betree_info(msg) }) - if flat1372 != nil { - p.write(*flat1372) + flat1374 := p.tryFlat(msg, func() { p.pretty_betree_info(msg) }) + if flat1374 != nil { + p.write(*flat1374) return nil } else { _dollar_dollar := msg - _t1712 := p.deconstruct_betree_info_config(_dollar_dollar) - fields1367 := []interface{}{_dollar_dollar.GetKeyTypes(), _dollar_dollar.GetValueTypes(), _t1712} - unwrapped_fields1368 := fields1367 + _t1716 := p.deconstruct_betree_info_config(_dollar_dollar) + fields1369 := []interface{}{_dollar_dollar.GetKeyTypes(), _dollar_dollar.GetValueTypes(), _t1716} + unwrapped_fields1370 := fields1369 p.write("(") p.write("betree_info") p.indentSexp() p.newline() - field1369 := unwrapped_fields1368[0].([]*pb.Type) - p.pretty_betree_info_key_types(field1369) + field1371 := unwrapped_fields1370[0].([]*pb.Type) + p.pretty_betree_info_key_types(field1371) p.newline() - field1370 := unwrapped_fields1368[1].([]*pb.Type) - p.pretty_betree_info_value_types(field1370) + field1372 := unwrapped_fields1370[1].([]*pb.Type) + p.pretty_betree_info_value_types(field1372) p.newline() - field1371 := unwrapped_fields1368[2].([][]interface{}) - p.pretty_config_dict(field1371) + field1373 := unwrapped_fields1370[2].([][]interface{}) + p.pretty_config_dict(field1373) p.dedent() p.write(")") } @@ -3694,22 +3694,22 @@ func (p *PrettyPrinter) pretty_betree_info(msg *pb.BeTreeInfo) interface{} { } func (p *PrettyPrinter) pretty_betree_info_key_types(msg []*pb.Type) interface{} { - flat1376 := p.tryFlat(msg, func() { p.pretty_betree_info_key_types(msg) }) - if flat1376 != nil { - p.write(*flat1376) + flat1378 := p.tryFlat(msg, func() { p.pretty_betree_info_key_types(msg) }) + if flat1378 != nil { + p.write(*flat1378) return nil } else { - fields1373 := msg + fields1375 := msg p.write("(") p.write("key_types") p.indentSexp() - if !(len(fields1373) == 0) { + if !(len(fields1375) == 0) { p.newline() - 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() @@ -3719,22 +3719,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{} { - flat1380 := p.tryFlat(msg, func() { p.pretty_betree_info_value_types(msg) }) - if flat1380 != nil { - p.write(*flat1380) + flat1382 := p.tryFlat(msg, func() { p.pretty_betree_info_value_types(msg) }) + if flat1382 != nil { + p.write(*flat1382) return nil } else { - fields1377 := msg + fields1379 := msg p.write("(") p.write("value_types") p.indentSexp() - if !(len(fields1377) == 0) { + if !(len(fields1379) == 0) { p.newline() - for i1379, elem1378 := range fields1377 { - if (i1379 > 0) { + for i1381, elem1380 := range fields1379 { + if (i1381 > 0) { p.newline() } - p.pretty_type(elem1378) + p.pretty_type(elem1380) } } p.dedent() @@ -3744,29 +3744,29 @@ func (p *PrettyPrinter) pretty_betree_info_value_types(msg []*pb.Type) interface } func (p *PrettyPrinter) pretty_csv_data(msg *pb.CSVData) interface{} { - flat1387 := p.tryFlat(msg, func() { p.pretty_csv_data(msg) }) - if flat1387 != nil { - p.write(*flat1387) + flat1389 := p.tryFlat(msg, func() { p.pretty_csv_data(msg) }) + if flat1389 != nil { + p.write(*flat1389) return nil } else { _dollar_dollar := msg - fields1381 := []interface{}{_dollar_dollar.GetLocator(), _dollar_dollar.GetConfig(), _dollar_dollar.GetColumns(), _dollar_dollar.GetAsof()} - unwrapped_fields1382 := fields1381 + fields1383 := []interface{}{_dollar_dollar.GetLocator(), _dollar_dollar.GetConfig(), _dollar_dollar.GetColumns(), _dollar_dollar.GetAsof()} + unwrapped_fields1384 := fields1383 p.write("(") p.write("csv_data") p.indentSexp() p.newline() - field1383 := unwrapped_fields1382[0].(*pb.CSVLocator) - p.pretty_csvlocator(field1383) + field1385 := unwrapped_fields1384[0].(*pb.CSVLocator) + p.pretty_csvlocator(field1385) p.newline() - field1384 := unwrapped_fields1382[1].(*pb.CSVConfig) - p.pretty_csv_config(field1384) + field1386 := unwrapped_fields1384[1].(*pb.CSVConfig) + p.pretty_csv_config(field1386) p.newline() - field1385 := unwrapped_fields1382[2].([]*pb.GNFColumn) - p.pretty_gnf_columns(field1385) + field1387 := unwrapped_fields1384[2].([]*pb.GNFColumn) + p.pretty_gnf_columns(field1387) p.newline() - field1386 := unwrapped_fields1382[3].(string) - p.pretty_csv_asof(field1386) + field1388 := unwrapped_fields1384[3].(string) + p.pretty_csv_asof(field1388) p.dedent() p.write(")") } @@ -3774,36 +3774,36 @@ func (p *PrettyPrinter) pretty_csv_data(msg *pb.CSVData) interface{} { } func (p *PrettyPrinter) pretty_csvlocator(msg *pb.CSVLocator) interface{} { - flat1394 := p.tryFlat(msg, func() { p.pretty_csvlocator(msg) }) - if flat1394 != nil { - p.write(*flat1394) + flat1396 := p.tryFlat(msg, func() { p.pretty_csvlocator(msg) }) + if flat1396 != nil { + p.write(*flat1396) return nil } else { _dollar_dollar := msg - var _t1713 []string + var _t1717 []string if !(len(_dollar_dollar.GetPaths()) == 0) { - _t1713 = _dollar_dollar.GetPaths() + _t1717 = _dollar_dollar.GetPaths() } - var _t1714 *string + var _t1718 *string if string(_dollar_dollar.GetInlineData()) != "" { - _t1714 = ptr(string(_dollar_dollar.GetInlineData())) + _t1718 = ptr(string(_dollar_dollar.GetInlineData())) } - fields1388 := []interface{}{_t1713, _t1714} - unwrapped_fields1389 := fields1388 + fields1390 := []interface{}{_t1717, _t1718} + unwrapped_fields1391 := fields1390 p.write("(") p.write("csv_locator") p.indentSexp() - field1390 := unwrapped_fields1389[0].([]string) - if field1390 != nil { + field1392 := unwrapped_fields1391[0].([]string) + if field1392 != nil { p.newline() - opt_val1391 := field1390 - p.pretty_csv_locator_paths(opt_val1391) + opt_val1393 := field1392 + p.pretty_csv_locator_paths(opt_val1393) } - field1392 := unwrapped_fields1389[1].(*string) - if field1392 != nil { + field1394 := unwrapped_fields1391[1].(*string) + if field1394 != nil { p.newline() - opt_val1393 := *field1392 - p.pretty_csv_locator_inline_data(opt_val1393) + opt_val1395 := *field1394 + p.pretty_csv_locator_inline_data(opt_val1395) } p.dedent() p.write(")") @@ -3812,22 +3812,22 @@ func (p *PrettyPrinter) pretty_csvlocator(msg *pb.CSVLocator) interface{} { } func (p *PrettyPrinter) pretty_csv_locator_paths(msg []string) interface{} { - flat1398 := p.tryFlat(msg, func() { p.pretty_csv_locator_paths(msg) }) - if flat1398 != nil { - p.write(*flat1398) + flat1400 := p.tryFlat(msg, func() { p.pretty_csv_locator_paths(msg) }) + if flat1400 != nil { + p.write(*flat1400) return nil } else { - fields1395 := msg + fields1397 := msg p.write("(") p.write("paths") p.indentSexp() - if !(len(fields1395) == 0) { + if !(len(fields1397) == 0) { p.newline() - for i1397, elem1396 := range fields1395 { - if (i1397 > 0) { + for i1399, elem1398 := range fields1397 { + if (i1399 > 0) { p.newline() } - p.write(p.formatStringValue(elem1396)) + p.write(p.formatStringValue(elem1398)) } } p.dedent() @@ -3837,17 +3837,17 @@ func (p *PrettyPrinter) pretty_csv_locator_paths(msg []string) interface{} { } func (p *PrettyPrinter) pretty_csv_locator_inline_data(msg string) interface{} { - flat1400 := p.tryFlat(msg, func() { p.pretty_csv_locator_inline_data(msg) }) - if flat1400 != nil { - p.write(*flat1400) + flat1402 := p.tryFlat(msg, func() { p.pretty_csv_locator_inline_data(msg) }) + if flat1402 != nil { + p.write(*flat1402) return nil } else { - fields1399 := msg + fields1401 := msg p.write("(") p.write("inline_data") p.indentSexp() p.newline() - p.write(p.formatStringValue(fields1399)) + p.write(p.formatStringValue(fields1401)) p.dedent() p.write(")") } @@ -3855,20 +3855,20 @@ func (p *PrettyPrinter) pretty_csv_locator_inline_data(msg string) interface{} { } func (p *PrettyPrinter) pretty_csv_config(msg *pb.CSVConfig) interface{} { - flat1403 := p.tryFlat(msg, func() { p.pretty_csv_config(msg) }) - if flat1403 != nil { - p.write(*flat1403) + flat1405 := p.tryFlat(msg, func() { p.pretty_csv_config(msg) }) + if flat1405 != nil { + p.write(*flat1405) return nil } else { _dollar_dollar := msg - _t1715 := p.deconstruct_csv_config(_dollar_dollar) - fields1401 := _t1715 - unwrapped_fields1402 := fields1401 + _t1719 := p.deconstruct_csv_config(_dollar_dollar) + fields1403 := _t1719 + unwrapped_fields1404 := fields1403 p.write("(") p.write("csv_config") p.indentSexp() p.newline() - p.pretty_config_dict(unwrapped_fields1402) + p.pretty_config_dict(unwrapped_fields1404) p.dedent() p.write(")") } @@ -3876,22 +3876,22 @@ func (p *PrettyPrinter) pretty_csv_config(msg *pb.CSVConfig) interface{} { } func (p *PrettyPrinter) pretty_gnf_columns(msg []*pb.GNFColumn) interface{} { - flat1407 := p.tryFlat(msg, func() { p.pretty_gnf_columns(msg) }) - if flat1407 != nil { - p.write(*flat1407) + flat1409 := p.tryFlat(msg, func() { p.pretty_gnf_columns(msg) }) + if flat1409 != nil { + p.write(*flat1409) return nil } else { - fields1404 := msg + fields1406 := msg p.write("(") p.write("columns") p.indentSexp() - if !(len(fields1404) == 0) { + if !(len(fields1406) == 0) { p.newline() - for i1406, elem1405 := range fields1404 { - if (i1406 > 0) { + for i1408, elem1407 := range fields1406 { + if (i1408 > 0) { p.newline() } - p.pretty_gnf_column(elem1405) + p.pretty_gnf_column(elem1407) } } p.dedent() @@ -3901,38 +3901,38 @@ func (p *PrettyPrinter) pretty_gnf_columns(msg []*pb.GNFColumn) interface{} { } func (p *PrettyPrinter) pretty_gnf_column(msg *pb.GNFColumn) interface{} { - flat1416 := p.tryFlat(msg, func() { p.pretty_gnf_column(msg) }) - if flat1416 != nil { - p.write(*flat1416) + flat1418 := p.tryFlat(msg, func() { p.pretty_gnf_column(msg) }) + if flat1418 != nil { + p.write(*flat1418) return nil } else { _dollar_dollar := msg - var _t1716 *pb.RelationId + var _t1720 *pb.RelationId if hasProtoField(_dollar_dollar, "target_id") { - _t1716 = _dollar_dollar.GetTargetId() + _t1720 = _dollar_dollar.GetTargetId() } - fields1408 := []interface{}{_dollar_dollar.GetColumnPath(), _t1716, _dollar_dollar.GetTypes()} - unwrapped_fields1409 := fields1408 + fields1410 := []interface{}{_dollar_dollar.GetColumnPath(), _t1720, _dollar_dollar.GetTypes()} + unwrapped_fields1411 := fields1410 p.write("(") p.write("column") p.indentSexp() p.newline() - field1410 := unwrapped_fields1409[0].([]string) - p.pretty_gnf_column_path(field1410) - field1411 := unwrapped_fields1409[1].(*pb.RelationId) - if field1411 != nil { + field1412 := unwrapped_fields1411[0].([]string) + p.pretty_gnf_column_path(field1412) + field1413 := unwrapped_fields1411[1].(*pb.RelationId) + if field1413 != nil { p.newline() - opt_val1412 := field1411 - p.pretty_relation_id(opt_val1412) + opt_val1414 := field1413 + p.pretty_relation_id(opt_val1414) } p.newline() p.write("[") - field1413 := unwrapped_fields1409[2].([]*pb.Type) - for i1415, elem1414 := range field1413 { - if (i1415 > 0) { + field1415 := unwrapped_fields1411[2].([]*pb.Type) + for i1417, elem1416 := range field1415 { + if (i1417 > 0) { p.newline() } - p.pretty_type(elem1414) + p.pretty_type(elem1416) } p.write("]") p.dedent() @@ -3942,36 +3942,36 @@ func (p *PrettyPrinter) pretty_gnf_column(msg *pb.GNFColumn) interface{} { } func (p *PrettyPrinter) pretty_gnf_column_path(msg []string) interface{} { - flat1423 := p.tryFlat(msg, func() { p.pretty_gnf_column_path(msg) }) - if flat1423 != nil { - p.write(*flat1423) + flat1425 := p.tryFlat(msg, func() { p.pretty_gnf_column_path(msg) }) + if flat1425 != nil { + p.write(*flat1425) return nil } else { _dollar_dollar := msg - var _t1717 *string + var _t1721 *string if int64(len(_dollar_dollar)) == 1 { - _t1717 = ptr(_dollar_dollar[0]) + _t1721 = ptr(_dollar_dollar[0]) } - deconstruct_result1421 := _t1717 - if deconstruct_result1421 != nil { - unwrapped1422 := *deconstruct_result1421 - p.write(p.formatStringValue(unwrapped1422)) + deconstruct_result1423 := _t1721 + if deconstruct_result1423 != nil { + unwrapped1424 := *deconstruct_result1423 + p.write(p.formatStringValue(unwrapped1424)) } else { _dollar_dollar := msg - var _t1718 []string + var _t1722 []string if int64(len(_dollar_dollar)) != 1 { - _t1718 = _dollar_dollar + _t1722 = _dollar_dollar } - deconstruct_result1417 := _t1718 - if deconstruct_result1417 != nil { - unwrapped1418 := deconstruct_result1417 + deconstruct_result1419 := _t1722 + if deconstruct_result1419 != nil { + unwrapped1420 := deconstruct_result1419 p.write("[") p.indent() - for i1420, elem1419 := range unwrapped1418 { - if (i1420 > 0) { + for i1422, elem1421 := range unwrapped1420 { + if (i1422 > 0) { p.newline() } - p.write(p.formatStringValue(elem1419)) + p.write(p.formatStringValue(elem1421)) } p.dedent() p.write("]") @@ -3984,17 +3984,17 @@ func (p *PrettyPrinter) pretty_gnf_column_path(msg []string) interface{} { } func (p *PrettyPrinter) pretty_csv_asof(msg string) interface{} { - flat1425 := p.tryFlat(msg, func() { p.pretty_csv_asof(msg) }) - if flat1425 != nil { - p.write(*flat1425) + flat1427 := p.tryFlat(msg, func() { p.pretty_csv_asof(msg) }) + if flat1427 != nil { + p.write(*flat1427) return nil } else { - fields1424 := msg + fields1426 := msg p.write("(") p.write("asof") p.indentSexp() p.newline() - p.write(p.formatStringValue(fields1424)) + p.write(p.formatStringValue(fields1426)) p.dedent() p.write(")") } @@ -4002,43 +4002,43 @@ func (p *PrettyPrinter) pretty_csv_asof(msg string) interface{} { } func (p *PrettyPrinter) pretty_iceberg_data(msg *pb.IcebergData) interface{} { - flat1436 := p.tryFlat(msg, func() { p.pretty_iceberg_data(msg) }) - if flat1436 != nil { - p.write(*flat1436) + flat1438 := p.tryFlat(msg, func() { p.pretty_iceberg_data(msg) }) + if flat1438 != nil { + p.write(*flat1438) return nil } else { _dollar_dollar := msg - _t1719 := p.deconstruct_iceberg_data_from_snapshot_optional(_dollar_dollar) - _t1720 := p.deconstruct_iceberg_data_to_snapshot_optional(_dollar_dollar) - fields1426 := []interface{}{_dollar_dollar.GetLocator(), _dollar_dollar.GetConfig(), _dollar_dollar.GetColumns(), _t1719, _t1720, _dollar_dollar.GetReturnsDelta()} - unwrapped_fields1427 := fields1426 + _t1723 := p.deconstruct_iceberg_data_from_snapshot_optional(_dollar_dollar) + _t1724 := p.deconstruct_iceberg_data_to_snapshot_optional(_dollar_dollar) + fields1428 := []interface{}{_dollar_dollar.GetLocator(), _dollar_dollar.GetConfig(), _dollar_dollar.GetColumns(), _t1723, _t1724, _dollar_dollar.GetReturnsDelta()} + unwrapped_fields1429 := fields1428 p.write("(") p.write("iceberg_data") p.indentSexp() p.newline() - field1428 := unwrapped_fields1427[0].(*pb.IcebergLocator) - p.pretty_iceberg_locator(field1428) + field1430 := unwrapped_fields1429[0].(*pb.IcebergLocator) + p.pretty_iceberg_locator(field1430) p.newline() - field1429 := unwrapped_fields1427[1].(*pb.IcebergCatalogConfig) - p.pretty_iceberg_catalog_config(field1429) + field1431 := unwrapped_fields1429[1].(*pb.IcebergCatalogConfig) + p.pretty_iceberg_catalog_config(field1431) p.newline() - field1430 := unwrapped_fields1427[2].([]*pb.GNFColumn) - p.pretty_gnf_columns(field1430) - field1431 := unwrapped_fields1427[3].(*string) - if field1431 != nil { - p.newline() - opt_val1432 := *field1431 - p.pretty_iceberg_from_snapshot(opt_val1432) - } - field1433 := unwrapped_fields1427[4].(*string) + field1432 := unwrapped_fields1429[2].([]*pb.GNFColumn) + p.pretty_gnf_columns(field1432) + field1433 := unwrapped_fields1429[3].(*string) if field1433 != nil { p.newline() opt_val1434 := *field1433 - p.pretty_iceberg_to_snapshot(opt_val1434) + p.pretty_iceberg_from_snapshot(opt_val1434) + } + field1435 := unwrapped_fields1429[4].(*string) + if field1435 != nil { + p.newline() + opt_val1436 := *field1435 + p.pretty_iceberg_to_snapshot(opt_val1436) } p.newline() - field1435 := unwrapped_fields1427[5].(bool) - p.pretty_boolean_value(field1435) + field1437 := unwrapped_fields1429[5].(bool) + p.pretty_boolean_value(field1437) p.dedent() p.write(")") } @@ -4046,26 +4046,26 @@ func (p *PrettyPrinter) pretty_iceberg_data(msg *pb.IcebergData) interface{} { } func (p *PrettyPrinter) pretty_iceberg_locator(msg *pb.IcebergLocator) interface{} { - flat1442 := p.tryFlat(msg, func() { p.pretty_iceberg_locator(msg) }) - if flat1442 != nil { - p.write(*flat1442) + flat1444 := p.tryFlat(msg, func() { p.pretty_iceberg_locator(msg) }) + if flat1444 != nil { + p.write(*flat1444) return nil } else { _dollar_dollar := msg - fields1437 := []interface{}{_dollar_dollar.GetTableName(), _dollar_dollar.GetNamespace(), _dollar_dollar.GetWarehouse()} - unwrapped_fields1438 := fields1437 + fields1439 := []interface{}{_dollar_dollar.GetTableName(), _dollar_dollar.GetNamespace(), _dollar_dollar.GetWarehouse()} + unwrapped_fields1440 := fields1439 p.write("(") p.write("iceberg_locator") p.indentSexp() p.newline() - field1439 := unwrapped_fields1438[0].(string) - p.pretty_iceberg_locator_table_name(field1439) + field1441 := unwrapped_fields1440[0].(string) + p.pretty_iceberg_locator_table_name(field1441) p.newline() - field1440 := unwrapped_fields1438[1].([]string) - p.pretty_iceberg_locator_namespace(field1440) + field1442 := unwrapped_fields1440[1].([]string) + p.pretty_iceberg_locator_namespace(field1442) p.newline() - field1441 := unwrapped_fields1438[2].(string) - p.pretty_iceberg_locator_warehouse(field1441) + field1443 := unwrapped_fields1440[2].(string) + p.pretty_iceberg_locator_warehouse(field1443) p.dedent() p.write(")") } @@ -4073,17 +4073,17 @@ func (p *PrettyPrinter) pretty_iceberg_locator(msg *pb.IcebergLocator) interface } func (p *PrettyPrinter) pretty_iceberg_locator_table_name(msg string) interface{} { - flat1444 := p.tryFlat(msg, func() { p.pretty_iceberg_locator_table_name(msg) }) - if flat1444 != nil { - p.write(*flat1444) + flat1446 := p.tryFlat(msg, func() { p.pretty_iceberg_locator_table_name(msg) }) + if flat1446 != nil { + p.write(*flat1446) return nil } else { - fields1443 := msg + fields1445 := msg p.write("(") p.write("table_name") p.indentSexp() p.newline() - p.write(p.formatStringValue(fields1443)) + p.write(p.formatStringValue(fields1445)) p.dedent() p.write(")") } @@ -4091,22 +4091,22 @@ func (p *PrettyPrinter) pretty_iceberg_locator_table_name(msg string) interface{ } func (p *PrettyPrinter) pretty_iceberg_locator_namespace(msg []string) interface{} { - flat1448 := p.tryFlat(msg, func() { p.pretty_iceberg_locator_namespace(msg) }) - if flat1448 != nil { - p.write(*flat1448) + flat1450 := p.tryFlat(msg, func() { p.pretty_iceberg_locator_namespace(msg) }) + if flat1450 != nil { + p.write(*flat1450) return nil } else { - fields1445 := msg + fields1447 := msg p.write("(") p.write("namespace") p.indentSexp() - if !(len(fields1445) == 0) { + if !(len(fields1447) == 0) { p.newline() - for i1447, elem1446 := range fields1445 { - if (i1447 > 0) { + for i1449, elem1448 := range fields1447 { + if (i1449 > 0) { p.newline() } - p.write(p.formatStringValue(elem1446)) + p.write(p.formatStringValue(elem1448)) } } p.dedent() @@ -4116,17 +4116,17 @@ func (p *PrettyPrinter) pretty_iceberg_locator_namespace(msg []string) interface } func (p *PrettyPrinter) pretty_iceberg_locator_warehouse(msg string) interface{} { - flat1450 := p.tryFlat(msg, func() { p.pretty_iceberg_locator_warehouse(msg) }) - if flat1450 != nil { - p.write(*flat1450) + flat1452 := p.tryFlat(msg, func() { p.pretty_iceberg_locator_warehouse(msg) }) + if flat1452 != nil { + p.write(*flat1452) return nil } else { - fields1449 := msg + fields1451 := msg p.write("(") p.write("warehouse") p.indentSexp() p.newline() - p.write(p.formatStringValue(fields1449)) + p.write(p.formatStringValue(fields1451)) p.dedent() p.write(")") } @@ -4134,33 +4134,33 @@ func (p *PrettyPrinter) pretty_iceberg_locator_warehouse(msg string) interface{} } func (p *PrettyPrinter) pretty_iceberg_catalog_config(msg *pb.IcebergCatalogConfig) interface{} { - flat1458 := p.tryFlat(msg, func() { p.pretty_iceberg_catalog_config(msg) }) - if flat1458 != nil { - p.write(*flat1458) + flat1460 := p.tryFlat(msg, func() { p.pretty_iceberg_catalog_config(msg) }) + if flat1460 != nil { + p.write(*flat1460) return nil } else { _dollar_dollar := msg - _t1721 := p.deconstruct_iceberg_catalog_config_scope_optional(_dollar_dollar) - fields1451 := []interface{}{_dollar_dollar.GetCatalogUri(), _t1721, dictToPairs(_dollar_dollar.GetProperties()), dictToPairs(_dollar_dollar.GetAuthProperties())} - unwrapped_fields1452 := fields1451 + _t1725 := p.deconstruct_iceberg_catalog_config_scope_optional(_dollar_dollar) + fields1453 := []interface{}{_dollar_dollar.GetCatalogUri(), _t1725, dictToPairs(_dollar_dollar.GetProperties()), dictToPairs(_dollar_dollar.GetAuthProperties())} + unwrapped_fields1454 := fields1453 p.write("(") p.write("iceberg_catalog_config") p.indentSexp() p.newline() - field1453 := unwrapped_fields1452[0].(string) - p.pretty_iceberg_catalog_uri(field1453) - field1454 := unwrapped_fields1452[1].(*string) - if field1454 != nil { + field1455 := unwrapped_fields1454[0].(string) + p.pretty_iceberg_catalog_uri(field1455) + field1456 := unwrapped_fields1454[1].(*string) + if field1456 != nil { p.newline() - opt_val1455 := *field1454 - p.pretty_iceberg_catalog_config_scope(opt_val1455) + opt_val1457 := *field1456 + p.pretty_iceberg_catalog_config_scope(opt_val1457) } p.newline() - field1456 := unwrapped_fields1452[2].([][]interface{}) - p.pretty_iceberg_properties(field1456) + field1458 := unwrapped_fields1454[2].([][]interface{}) + p.pretty_iceberg_properties(field1458) p.newline() - field1457 := unwrapped_fields1452[3].([][]interface{}) - p.pretty_iceberg_auth_properties(field1457) + field1459 := unwrapped_fields1454[3].([][]interface{}) + p.pretty_iceberg_auth_properties(field1459) p.dedent() p.write(")") } @@ -4168,17 +4168,17 @@ func (p *PrettyPrinter) pretty_iceberg_catalog_config(msg *pb.IcebergCatalogConf } func (p *PrettyPrinter) pretty_iceberg_catalog_uri(msg string) interface{} { - flat1460 := p.tryFlat(msg, func() { p.pretty_iceberg_catalog_uri(msg) }) - if flat1460 != nil { - p.write(*flat1460) + flat1462 := p.tryFlat(msg, func() { p.pretty_iceberg_catalog_uri(msg) }) + if flat1462 != nil { + p.write(*flat1462) return nil } else { - fields1459 := msg + fields1461 := msg p.write("(") p.write("catalog_uri") p.indentSexp() p.newline() - p.write(p.formatStringValue(fields1459)) + p.write(p.formatStringValue(fields1461)) p.dedent() p.write(")") } @@ -4186,17 +4186,17 @@ func (p *PrettyPrinter) pretty_iceberg_catalog_uri(msg string) interface{} { } func (p *PrettyPrinter) pretty_iceberg_catalog_config_scope(msg string) interface{} { - flat1462 := p.tryFlat(msg, func() { p.pretty_iceberg_catalog_config_scope(msg) }) - if flat1462 != nil { - p.write(*flat1462) + flat1464 := p.tryFlat(msg, func() { p.pretty_iceberg_catalog_config_scope(msg) }) + if flat1464 != nil { + p.write(*flat1464) return nil } else { - fields1461 := msg + fields1463 := msg p.write("(") p.write("scope") p.indentSexp() p.newline() - p.write(p.formatStringValue(fields1461)) + p.write(p.formatStringValue(fields1463)) p.dedent() p.write(")") } @@ -4204,22 +4204,22 @@ func (p *PrettyPrinter) pretty_iceberg_catalog_config_scope(msg string) interfac } func (p *PrettyPrinter) pretty_iceberg_properties(msg [][]interface{}) interface{} { - flat1466 := p.tryFlat(msg, func() { p.pretty_iceberg_properties(msg) }) - if flat1466 != nil { - p.write(*flat1466) + flat1468 := p.tryFlat(msg, func() { p.pretty_iceberg_properties(msg) }) + if flat1468 != nil { + p.write(*flat1468) return nil } else { - fields1463 := msg + fields1465 := msg p.write("(") p.write("properties") p.indentSexp() - if !(len(fields1463) == 0) { + if !(len(fields1465) == 0) { p.newline() - for i1465, elem1464 := range fields1463 { - if (i1465 > 0) { + for i1467, elem1466 := range fields1465 { + if (i1467 > 0) { p.newline() } - p.pretty_iceberg_property_entry(elem1464) + p.pretty_iceberg_property_entry(elem1466) } } p.dedent() @@ -4229,23 +4229,23 @@ func (p *PrettyPrinter) pretty_iceberg_properties(msg [][]interface{}) interface } func (p *PrettyPrinter) pretty_iceberg_property_entry(msg []interface{}) interface{} { - flat1471 := p.tryFlat(msg, func() { p.pretty_iceberg_property_entry(msg) }) - if flat1471 != nil { - p.write(*flat1471) + flat1473 := p.tryFlat(msg, func() { p.pretty_iceberg_property_entry(msg) }) + if flat1473 != nil { + p.write(*flat1473) return nil } else { _dollar_dollar := msg - fields1467 := []interface{}{_dollar_dollar[0].(string), _dollar_dollar[1].(string)} - unwrapped_fields1468 := fields1467 + fields1469 := []interface{}{_dollar_dollar[0].(string), _dollar_dollar[1].(string)} + unwrapped_fields1470 := fields1469 p.write("(") p.write("prop") p.indentSexp() p.newline() - field1469 := unwrapped_fields1468[0].(string) - p.write(p.formatStringValue(field1469)) + field1471 := unwrapped_fields1470[0].(string) + p.write(p.formatStringValue(field1471)) p.newline() - field1470 := unwrapped_fields1468[1].(string) - p.write(p.formatStringValue(field1470)) + field1472 := unwrapped_fields1470[1].(string) + p.write(p.formatStringValue(field1472)) p.dedent() p.write(")") } @@ -4253,22 +4253,22 @@ func (p *PrettyPrinter) pretty_iceberg_property_entry(msg []interface{}) interfa } func (p *PrettyPrinter) pretty_iceberg_auth_properties(msg [][]interface{}) interface{} { - flat1475 := p.tryFlat(msg, func() { p.pretty_iceberg_auth_properties(msg) }) - if flat1475 != nil { - p.write(*flat1475) + flat1477 := p.tryFlat(msg, func() { p.pretty_iceberg_auth_properties(msg) }) + if flat1477 != nil { + p.write(*flat1477) return nil } else { - fields1472 := msg + fields1474 := msg p.write("(") p.write("auth_properties") p.indentSexp() - if !(len(fields1472) == 0) { + if !(len(fields1474) == 0) { p.newline() - for i1474, elem1473 := range fields1472 { - if (i1474 > 0) { + for i1476, elem1475 := range fields1474 { + if (i1476 > 0) { p.newline() } - p.pretty_iceberg_masked_property_entry(elem1473) + p.pretty_iceberg_masked_property_entry(elem1475) } } p.dedent() @@ -4278,24 +4278,24 @@ func (p *PrettyPrinter) pretty_iceberg_auth_properties(msg [][]interface{}) inte } func (p *PrettyPrinter) pretty_iceberg_masked_property_entry(msg []interface{}) interface{} { - flat1480 := p.tryFlat(msg, func() { p.pretty_iceberg_masked_property_entry(msg) }) - if flat1480 != nil { - p.write(*flat1480) + flat1482 := p.tryFlat(msg, func() { p.pretty_iceberg_masked_property_entry(msg) }) + if flat1482 != nil { + p.write(*flat1482) return nil } else { _dollar_dollar := msg - _t1722 := p.mask_secret_value(_dollar_dollar) - fields1476 := []interface{}{_dollar_dollar[0].(string), _t1722} - unwrapped_fields1477 := fields1476 + _t1726 := p.mask_secret_value(_dollar_dollar) + fields1478 := []interface{}{_dollar_dollar[0].(string), _t1726} + unwrapped_fields1479 := fields1478 p.write("(") p.write("prop") p.indentSexp() p.newline() - field1478 := unwrapped_fields1477[0].(string) - p.write(p.formatStringValue(field1478)) + field1480 := unwrapped_fields1479[0].(string) + p.write(p.formatStringValue(field1480)) p.newline() - field1479 := unwrapped_fields1477[1].(string) - p.write(p.formatStringValue(field1479)) + field1481 := unwrapped_fields1479[1].(string) + p.write(p.formatStringValue(field1481)) p.dedent() p.write(")") } @@ -4303,17 +4303,17 @@ func (p *PrettyPrinter) pretty_iceberg_masked_property_entry(msg []interface{}) } func (p *PrettyPrinter) pretty_iceberg_from_snapshot(msg string) interface{} { - flat1482 := p.tryFlat(msg, func() { p.pretty_iceberg_from_snapshot(msg) }) - if flat1482 != nil { - p.write(*flat1482) + flat1484 := p.tryFlat(msg, func() { p.pretty_iceberg_from_snapshot(msg) }) + if flat1484 != nil { + p.write(*flat1484) return nil } else { - fields1481 := msg + fields1483 := msg p.write("(") p.write("from_snapshot") p.indentSexp() p.newline() - p.write(p.formatStringValue(fields1481)) + p.write(p.formatStringValue(fields1483)) p.dedent() p.write(")") } @@ -4321,17 +4321,17 @@ func (p *PrettyPrinter) pretty_iceberg_from_snapshot(msg string) interface{} { } func (p *PrettyPrinter) pretty_iceberg_to_snapshot(msg string) interface{} { - flat1484 := p.tryFlat(msg, func() { p.pretty_iceberg_to_snapshot(msg) }) - if flat1484 != nil { - p.write(*flat1484) + flat1486 := p.tryFlat(msg, func() { p.pretty_iceberg_to_snapshot(msg) }) + if flat1486 != nil { + p.write(*flat1486) return nil } else { - fields1483 := msg + fields1485 := msg p.write("(") p.write("to_snapshot") p.indentSexp() p.newline() - p.write(p.formatStringValue(fields1483)) + p.write(p.formatStringValue(fields1485)) p.dedent() p.write(")") } @@ -4339,19 +4339,19 @@ func (p *PrettyPrinter) pretty_iceberg_to_snapshot(msg string) interface{} { } func (p *PrettyPrinter) pretty_undefine(msg *pb.Undefine) interface{} { - flat1487 := p.tryFlat(msg, func() { p.pretty_undefine(msg) }) - if flat1487 != nil { - p.write(*flat1487) + flat1489 := p.tryFlat(msg, func() { p.pretty_undefine(msg) }) + if flat1489 != nil { + p.write(*flat1489) return nil } else { _dollar_dollar := msg - fields1485 := _dollar_dollar.GetFragmentId() - unwrapped_fields1486 := fields1485 + fields1487 := _dollar_dollar.GetFragmentId() + unwrapped_fields1488 := fields1487 p.write("(") p.write("undefine") p.indentSexp() p.newline() - p.pretty_fragment_id(unwrapped_fields1486) + p.pretty_fragment_id(unwrapped_fields1488) p.dedent() p.write(")") } @@ -4359,24 +4359,24 @@ func (p *PrettyPrinter) pretty_undefine(msg *pb.Undefine) interface{} { } func (p *PrettyPrinter) pretty_context(msg *pb.Context) interface{} { - flat1492 := p.tryFlat(msg, func() { p.pretty_context(msg) }) - if flat1492 != nil { - p.write(*flat1492) + flat1494 := p.tryFlat(msg, func() { p.pretty_context(msg) }) + if flat1494 != nil { + p.write(*flat1494) return nil } else { _dollar_dollar := msg - fields1488 := _dollar_dollar.GetRelations() - unwrapped_fields1489 := fields1488 + fields1490 := _dollar_dollar.GetRelations() + unwrapped_fields1491 := fields1490 p.write("(") p.write("context") p.indentSexp() - if !(len(unwrapped_fields1489) == 0) { + if !(len(unwrapped_fields1491) == 0) { p.newline() - for i1491, elem1490 := range unwrapped_fields1489 { - if (i1491 > 0) { + for i1493, elem1492 := range unwrapped_fields1491 { + if (i1493 > 0) { p.newline() } - p.pretty_relation_id(elem1490) + p.pretty_relation_id(elem1492) } } p.dedent() @@ -4386,24 +4386,28 @@ func (p *PrettyPrinter) pretty_context(msg *pb.Context) interface{} { } func (p *PrettyPrinter) pretty_snapshot(msg *pb.Snapshot) interface{} { - flat1497 := p.tryFlat(msg, func() { p.pretty_snapshot(msg) }) - if flat1497 != nil { - p.write(*flat1497) + flat1501 := p.tryFlat(msg, func() { p.pretty_snapshot(msg) }) + if flat1501 != nil { + p.write(*flat1501) return nil } else { _dollar_dollar := msg - fields1493 := _dollar_dollar.GetMappings() - unwrapped_fields1494 := fields1493 + fields1495 := []interface{}{_dollar_dollar.GetPrefix(), _dollar_dollar.GetMappings()} + unwrapped_fields1496 := fields1495 p.write("(") p.write("snapshot") p.indentSexp() - if !(len(unwrapped_fields1494) == 0) { + p.newline() + field1497 := unwrapped_fields1496[0].([]string) + p.pretty_edb_path(field1497) + field1498 := unwrapped_fields1496[1].([]*pb.SnapshotMapping) + if !(len(field1498) == 0) { p.newline() - for i1496, elem1495 := range unwrapped_fields1494 { - if (i1496 > 0) { + for i1500, elem1499 := range field1498 { + if (i1500 > 0) { p.newline() } - p.pretty_snapshot_mapping(elem1495) + p.pretty_snapshot_mapping(elem1499) } } p.dedent() @@ -4413,40 +4417,40 @@ func (p *PrettyPrinter) pretty_snapshot(msg *pb.Snapshot) interface{} { } func (p *PrettyPrinter) pretty_snapshot_mapping(msg *pb.SnapshotMapping) interface{} { - flat1502 := p.tryFlat(msg, func() { p.pretty_snapshot_mapping(msg) }) - if flat1502 != nil { - p.write(*flat1502) + flat1506 := p.tryFlat(msg, func() { p.pretty_snapshot_mapping(msg) }) + if flat1506 != nil { + p.write(*flat1506) return nil } else { _dollar_dollar := msg - fields1498 := []interface{}{_dollar_dollar.GetDestinationPath(), _dollar_dollar.GetSourceRelation()} - unwrapped_fields1499 := fields1498 - field1500 := unwrapped_fields1499[0].([]string) - p.pretty_edb_path(field1500) + fields1502 := []interface{}{_dollar_dollar.GetDestinationPath(), _dollar_dollar.GetSourceRelation()} + unwrapped_fields1503 := fields1502 + field1504 := unwrapped_fields1503[0].([]string) + p.pretty_edb_path(field1504) p.write(" ") - field1501 := unwrapped_fields1499[1].(*pb.RelationId) - p.pretty_relation_id(field1501) + field1505 := unwrapped_fields1503[1].(*pb.RelationId) + p.pretty_relation_id(field1505) } return nil } func (p *PrettyPrinter) pretty_epoch_reads(msg []*pb.Read) interface{} { - flat1506 := p.tryFlat(msg, func() { p.pretty_epoch_reads(msg) }) - if flat1506 != nil { - p.write(*flat1506) + flat1510 := p.tryFlat(msg, func() { p.pretty_epoch_reads(msg) }) + if flat1510 != nil { + p.write(*flat1510) return nil } else { - fields1503 := msg + fields1507 := msg p.write("(") p.write("reads") p.indentSexp() - if !(len(fields1503) == 0) { + if !(len(fields1507) == 0) { p.newline() - for i1505, elem1504 := range fields1503 { - if (i1505 > 0) { + for i1509, elem1508 := range fields1507 { + if (i1509 > 0) { p.newline() } - p.pretty_read(elem1504) + p.pretty_read(elem1508) } } p.dedent() @@ -4456,60 +4460,60 @@ func (p *PrettyPrinter) pretty_epoch_reads(msg []*pb.Read) interface{} { } func (p *PrettyPrinter) pretty_read(msg *pb.Read) interface{} { - flat1517 := p.tryFlat(msg, func() { p.pretty_read(msg) }) - if flat1517 != nil { - p.write(*flat1517) + flat1521 := p.tryFlat(msg, func() { p.pretty_read(msg) }) + if flat1521 != nil { + p.write(*flat1521) return nil } else { _dollar_dollar := msg - var _t1723 *pb.Demand + var _t1727 *pb.Demand if hasProtoField(_dollar_dollar, "demand") { - _t1723 = _dollar_dollar.GetDemand() + _t1727 = _dollar_dollar.GetDemand() } - deconstruct_result1515 := _t1723 - if deconstruct_result1515 != nil { - unwrapped1516 := deconstruct_result1515 - p.pretty_demand(unwrapped1516) + deconstruct_result1519 := _t1727 + if deconstruct_result1519 != nil { + unwrapped1520 := deconstruct_result1519 + p.pretty_demand(unwrapped1520) } else { _dollar_dollar := msg - var _t1724 *pb.Output + var _t1728 *pb.Output if hasProtoField(_dollar_dollar, "output") { - _t1724 = _dollar_dollar.GetOutput() + _t1728 = _dollar_dollar.GetOutput() } - deconstruct_result1513 := _t1724 - if deconstruct_result1513 != nil { - unwrapped1514 := deconstruct_result1513 - p.pretty_output(unwrapped1514) + deconstruct_result1517 := _t1728 + if deconstruct_result1517 != nil { + unwrapped1518 := deconstruct_result1517 + p.pretty_output(unwrapped1518) } else { _dollar_dollar := msg - var _t1725 *pb.WhatIf + var _t1729 *pb.WhatIf if hasProtoField(_dollar_dollar, "what_if") { - _t1725 = _dollar_dollar.GetWhatIf() + _t1729 = _dollar_dollar.GetWhatIf() } - deconstruct_result1511 := _t1725 - if deconstruct_result1511 != nil { - unwrapped1512 := deconstruct_result1511 - p.pretty_what_if(unwrapped1512) + deconstruct_result1515 := _t1729 + if deconstruct_result1515 != nil { + unwrapped1516 := deconstruct_result1515 + p.pretty_what_if(unwrapped1516) } else { _dollar_dollar := msg - var _t1726 *pb.Abort + var _t1730 *pb.Abort if hasProtoField(_dollar_dollar, "abort") { - _t1726 = _dollar_dollar.GetAbort() + _t1730 = _dollar_dollar.GetAbort() } - deconstruct_result1509 := _t1726 - if deconstruct_result1509 != nil { - unwrapped1510 := deconstruct_result1509 - p.pretty_abort(unwrapped1510) + deconstruct_result1513 := _t1730 + if deconstruct_result1513 != nil { + unwrapped1514 := deconstruct_result1513 + p.pretty_abort(unwrapped1514) } else { _dollar_dollar := msg - var _t1727 *pb.Export + var _t1731 *pb.Export if hasProtoField(_dollar_dollar, "export") { - _t1727 = _dollar_dollar.GetExport() + _t1731 = _dollar_dollar.GetExport() } - deconstruct_result1507 := _t1727 - if deconstruct_result1507 != nil { - unwrapped1508 := deconstruct_result1507 - p.pretty_export(unwrapped1508) + deconstruct_result1511 := _t1731 + if deconstruct_result1511 != nil { + unwrapped1512 := deconstruct_result1511 + p.pretty_export(unwrapped1512) } else { panic(ParseError{msg: "No matching rule for read"}) } @@ -4522,19 +4526,19 @@ func (p *PrettyPrinter) pretty_read(msg *pb.Read) interface{} { } func (p *PrettyPrinter) pretty_demand(msg *pb.Demand) interface{} { - flat1520 := p.tryFlat(msg, func() { p.pretty_demand(msg) }) - if flat1520 != nil { - p.write(*flat1520) + flat1524 := p.tryFlat(msg, func() { p.pretty_demand(msg) }) + if flat1524 != nil { + p.write(*flat1524) return nil } else { _dollar_dollar := msg - fields1518 := _dollar_dollar.GetRelationId() - unwrapped_fields1519 := fields1518 + fields1522 := _dollar_dollar.GetRelationId() + unwrapped_fields1523 := fields1522 p.write("(") p.write("demand") p.indentSexp() p.newline() - p.pretty_relation_id(unwrapped_fields1519) + p.pretty_relation_id(unwrapped_fields1523) p.dedent() p.write(")") } @@ -4542,23 +4546,23 @@ func (p *PrettyPrinter) pretty_demand(msg *pb.Demand) interface{} { } func (p *PrettyPrinter) pretty_output(msg *pb.Output) interface{} { - flat1525 := p.tryFlat(msg, func() { p.pretty_output(msg) }) - if flat1525 != nil { - p.write(*flat1525) + flat1529 := p.tryFlat(msg, func() { p.pretty_output(msg) }) + if flat1529 != nil { + p.write(*flat1529) return nil } else { _dollar_dollar := msg - fields1521 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetRelationId()} - unwrapped_fields1522 := fields1521 + fields1525 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetRelationId()} + unwrapped_fields1526 := fields1525 p.write("(") p.write("output") p.indentSexp() p.newline() - field1523 := unwrapped_fields1522[0].(string) - p.pretty_name(field1523) + field1527 := unwrapped_fields1526[0].(string) + p.pretty_name(field1527) p.newline() - field1524 := unwrapped_fields1522[1].(*pb.RelationId) - p.pretty_relation_id(field1524) + field1528 := unwrapped_fields1526[1].(*pb.RelationId) + p.pretty_relation_id(field1528) p.dedent() p.write(")") } @@ -4566,23 +4570,23 @@ func (p *PrettyPrinter) pretty_output(msg *pb.Output) interface{} { } func (p *PrettyPrinter) pretty_what_if(msg *pb.WhatIf) interface{} { - flat1530 := p.tryFlat(msg, func() { p.pretty_what_if(msg) }) - if flat1530 != nil { - p.write(*flat1530) + flat1534 := p.tryFlat(msg, func() { p.pretty_what_if(msg) }) + if flat1534 != nil { + p.write(*flat1534) return nil } else { _dollar_dollar := msg - fields1526 := []interface{}{_dollar_dollar.GetBranch(), _dollar_dollar.GetEpoch()} - unwrapped_fields1527 := fields1526 + fields1530 := []interface{}{_dollar_dollar.GetBranch(), _dollar_dollar.GetEpoch()} + unwrapped_fields1531 := fields1530 p.write("(") p.write("what_if") p.indentSexp() p.newline() - field1528 := unwrapped_fields1527[0].(string) - p.pretty_name(field1528) + field1532 := unwrapped_fields1531[0].(string) + p.pretty_name(field1532) p.newline() - field1529 := unwrapped_fields1527[1].(*pb.Epoch) - p.pretty_epoch(field1529) + field1533 := unwrapped_fields1531[1].(*pb.Epoch) + p.pretty_epoch(field1533) p.dedent() p.write(")") } @@ -4590,30 +4594,30 @@ func (p *PrettyPrinter) pretty_what_if(msg *pb.WhatIf) interface{} { } func (p *PrettyPrinter) pretty_abort(msg *pb.Abort) interface{} { - flat1536 := p.tryFlat(msg, func() { p.pretty_abort(msg) }) - if flat1536 != nil { - p.write(*flat1536) + flat1540 := p.tryFlat(msg, func() { p.pretty_abort(msg) }) + if flat1540 != nil { + p.write(*flat1540) return nil } else { _dollar_dollar := msg - var _t1728 *string + var _t1732 *string if _dollar_dollar.GetName() != "abort" { - _t1728 = ptr(_dollar_dollar.GetName()) + _t1732 = ptr(_dollar_dollar.GetName()) } - fields1531 := []interface{}{_t1728, _dollar_dollar.GetRelationId()} - unwrapped_fields1532 := fields1531 + fields1535 := []interface{}{_t1732, _dollar_dollar.GetRelationId()} + unwrapped_fields1536 := fields1535 p.write("(") p.write("abort") p.indentSexp() - field1533 := unwrapped_fields1532[0].(*string) - if field1533 != nil { + field1537 := unwrapped_fields1536[0].(*string) + if field1537 != nil { p.newline() - opt_val1534 := *field1533 - p.pretty_name(opt_val1534) + opt_val1538 := *field1537 + p.pretty_name(opt_val1538) } p.newline() - field1535 := unwrapped_fields1532[1].(*pb.RelationId) - p.pretty_relation_id(field1535) + field1539 := unwrapped_fields1536[1].(*pb.RelationId) + p.pretty_relation_id(field1539) p.dedent() p.write(")") } @@ -4621,40 +4625,40 @@ func (p *PrettyPrinter) pretty_abort(msg *pb.Abort) interface{} { } func (p *PrettyPrinter) pretty_export(msg *pb.Export) interface{} { - flat1541 := p.tryFlat(msg, func() { p.pretty_export(msg) }) - if flat1541 != nil { - p.write(*flat1541) + flat1545 := p.tryFlat(msg, func() { p.pretty_export(msg) }) + if flat1545 != nil { + p.write(*flat1545) return nil } else { _dollar_dollar := msg - var _t1729 *pb.ExportCSVConfig + var _t1733 *pb.ExportCSVConfig if hasProtoField(_dollar_dollar, "csv_config") { - _t1729 = _dollar_dollar.GetCsvConfig() + _t1733 = _dollar_dollar.GetCsvConfig() } - deconstruct_result1539 := _t1729 - if deconstruct_result1539 != nil { - unwrapped1540 := deconstruct_result1539 + deconstruct_result1543 := _t1733 + if deconstruct_result1543 != nil { + unwrapped1544 := deconstruct_result1543 p.write("(") p.write("export") p.indentSexp() p.newline() - p.pretty_export_csv_config(unwrapped1540) + p.pretty_export_csv_config(unwrapped1544) p.dedent() p.write(")") } else { _dollar_dollar := msg - var _t1730 *pb.ExportIcebergConfig + var _t1734 *pb.ExportIcebergConfig if hasProtoField(_dollar_dollar, "iceberg_config") { - _t1730 = _dollar_dollar.GetIcebergConfig() + _t1734 = _dollar_dollar.GetIcebergConfig() } - deconstruct_result1537 := _t1730 - if deconstruct_result1537 != nil { - unwrapped1538 := deconstruct_result1537 + deconstruct_result1541 := _t1734 + if deconstruct_result1541 != nil { + unwrapped1542 := deconstruct_result1541 p.write("(") p.write("export_iceberg") p.indentSexp() p.newline() - p.pretty_export_iceberg_config(unwrapped1538) + p.pretty_export_iceberg_config(unwrapped1542) p.dedent() p.write(")") } else { @@ -4666,55 +4670,55 @@ func (p *PrettyPrinter) pretty_export(msg *pb.Export) interface{} { } func (p *PrettyPrinter) pretty_export_csv_config(msg *pb.ExportCSVConfig) interface{} { - flat1552 := p.tryFlat(msg, func() { p.pretty_export_csv_config(msg) }) - if flat1552 != nil { - p.write(*flat1552) + flat1556 := p.tryFlat(msg, func() { p.pretty_export_csv_config(msg) }) + if flat1556 != nil { + p.write(*flat1556) return nil } else { _dollar_dollar := msg - var _t1731 []interface{} + var _t1735 []interface{} if int64(len(_dollar_dollar.GetDataColumns())) == 0 { - _t1731 = []interface{}{_dollar_dollar.GetPath(), _dollar_dollar.GetCsvSource(), _dollar_dollar.GetCsvConfig()} + _t1735 = []interface{}{_dollar_dollar.GetPath(), _dollar_dollar.GetCsvSource(), _dollar_dollar.GetCsvConfig()} } - deconstruct_result1547 := _t1731 - if deconstruct_result1547 != nil { - unwrapped1548 := deconstruct_result1547 + deconstruct_result1551 := _t1735 + if deconstruct_result1551 != nil { + unwrapped1552 := deconstruct_result1551 p.write("(") p.write("export_csv_config_v2") p.indentSexp() p.newline() - field1549 := unwrapped1548[0].(string) - p.pretty_export_csv_path(field1549) + field1553 := unwrapped1552[0].(string) + p.pretty_export_csv_path(field1553) p.newline() - field1550 := unwrapped1548[1].(*pb.ExportCSVSource) - p.pretty_export_csv_source(field1550) + field1554 := unwrapped1552[1].(*pb.ExportCSVSource) + p.pretty_export_csv_source(field1554) p.newline() - field1551 := unwrapped1548[2].(*pb.CSVConfig) - p.pretty_csv_config(field1551) + field1555 := unwrapped1552[2].(*pb.CSVConfig) + p.pretty_csv_config(field1555) p.dedent() p.write(")") } else { _dollar_dollar := msg - var _t1732 []interface{} + var _t1736 []interface{} if int64(len(_dollar_dollar.GetDataColumns())) != 0 { - _t1733 := p.deconstruct_export_csv_config(_dollar_dollar) - _t1732 = []interface{}{_dollar_dollar.GetPath(), _dollar_dollar.GetDataColumns(), _t1733} + _t1737 := p.deconstruct_export_csv_config(_dollar_dollar) + _t1736 = []interface{}{_dollar_dollar.GetPath(), _dollar_dollar.GetDataColumns(), _t1737} } - deconstruct_result1542 := _t1732 - if deconstruct_result1542 != nil { - unwrapped1543 := deconstruct_result1542 + deconstruct_result1546 := _t1736 + if deconstruct_result1546 != nil { + unwrapped1547 := deconstruct_result1546 p.write("(") p.write("export_csv_config") p.indentSexp() p.newline() - field1544 := unwrapped1543[0].(string) - p.pretty_export_csv_path(field1544) + field1548 := unwrapped1547[0].(string) + p.pretty_export_csv_path(field1548) p.newline() - field1545 := unwrapped1543[1].([]*pb.ExportCSVColumn) - p.pretty_export_csv_columns_list(field1545) + field1549 := unwrapped1547[1].([]*pb.ExportCSVColumn) + p.pretty_export_csv_columns_list(field1549) p.newline() - field1546 := unwrapped1543[2].([][]interface{}) - p.pretty_config_dict(field1546) + field1550 := unwrapped1547[2].([][]interface{}) + p.pretty_config_dict(field1550) p.dedent() p.write(")") } else { @@ -4726,17 +4730,17 @@ func (p *PrettyPrinter) pretty_export_csv_config(msg *pb.ExportCSVConfig) interf } func (p *PrettyPrinter) pretty_export_csv_path(msg string) interface{} { - flat1554 := p.tryFlat(msg, func() { p.pretty_export_csv_path(msg) }) - if flat1554 != nil { - p.write(*flat1554) + flat1558 := p.tryFlat(msg, func() { p.pretty_export_csv_path(msg) }) + if flat1558 != nil { + p.write(*flat1558) return nil } else { - fields1553 := msg + fields1557 := msg p.write("(") p.write("path") p.indentSexp() p.newline() - p.write(p.formatStringValue(fields1553)) + p.write(p.formatStringValue(fields1557)) p.dedent() p.write(")") } @@ -4744,47 +4748,47 @@ func (p *PrettyPrinter) pretty_export_csv_path(msg string) interface{} { } func (p *PrettyPrinter) pretty_export_csv_source(msg *pb.ExportCSVSource) interface{} { - flat1561 := p.tryFlat(msg, func() { p.pretty_export_csv_source(msg) }) - if flat1561 != nil { - p.write(*flat1561) + flat1565 := p.tryFlat(msg, func() { p.pretty_export_csv_source(msg) }) + if flat1565 != nil { + p.write(*flat1565) return nil } else { _dollar_dollar := msg - var _t1734 []*pb.ExportCSVColumn + var _t1738 []*pb.ExportCSVColumn if hasProtoField(_dollar_dollar, "gnf_columns") { - _t1734 = _dollar_dollar.GetGnfColumns().GetColumns() + _t1738 = _dollar_dollar.GetGnfColumns().GetColumns() } - deconstruct_result1557 := _t1734 - if deconstruct_result1557 != nil { - unwrapped1558 := deconstruct_result1557 + deconstruct_result1561 := _t1738 + if deconstruct_result1561 != nil { + unwrapped1562 := deconstruct_result1561 p.write("(") p.write("gnf_columns") p.indentSexp() - if !(len(unwrapped1558) == 0) { + if !(len(unwrapped1562) == 0) { p.newline() - for i1560, elem1559 := range unwrapped1558 { - if (i1560 > 0) { + for i1564, elem1563 := range unwrapped1562 { + if (i1564 > 0) { p.newline() } - p.pretty_export_csv_column(elem1559) + p.pretty_export_csv_column(elem1563) } } p.dedent() p.write(")") } else { _dollar_dollar := msg - var _t1735 *pb.RelationId + var _t1739 *pb.RelationId if hasProtoField(_dollar_dollar, "table_def") { - _t1735 = _dollar_dollar.GetTableDef() + _t1739 = _dollar_dollar.GetTableDef() } - deconstruct_result1555 := _t1735 - if deconstruct_result1555 != nil { - unwrapped1556 := deconstruct_result1555 + deconstruct_result1559 := _t1739 + if deconstruct_result1559 != nil { + unwrapped1560 := deconstruct_result1559 p.write("(") p.write("table_def") p.indentSexp() p.newline() - p.pretty_relation_id(unwrapped1556) + p.pretty_relation_id(unwrapped1560) p.dedent() p.write(")") } else { @@ -4796,23 +4800,23 @@ func (p *PrettyPrinter) pretty_export_csv_source(msg *pb.ExportCSVSource) interf } func (p *PrettyPrinter) pretty_export_csv_column(msg *pb.ExportCSVColumn) interface{} { - flat1566 := p.tryFlat(msg, func() { p.pretty_export_csv_column(msg) }) - if flat1566 != nil { - p.write(*flat1566) + flat1570 := p.tryFlat(msg, func() { p.pretty_export_csv_column(msg) }) + if flat1570 != nil { + p.write(*flat1570) return nil } else { _dollar_dollar := msg - fields1562 := []interface{}{_dollar_dollar.GetColumnName(), _dollar_dollar.GetColumnData()} - unwrapped_fields1563 := fields1562 + fields1566 := []interface{}{_dollar_dollar.GetColumnName(), _dollar_dollar.GetColumnData()} + unwrapped_fields1567 := fields1566 p.write("(") p.write("column") p.indentSexp() p.newline() - field1564 := unwrapped_fields1563[0].(string) - p.write(p.formatStringValue(field1564)) + field1568 := unwrapped_fields1567[0].(string) + p.write(p.formatStringValue(field1568)) p.newline() - field1565 := unwrapped_fields1563[1].(*pb.RelationId) - p.pretty_relation_id(field1565) + field1569 := unwrapped_fields1567[1].(*pb.RelationId) + p.pretty_relation_id(field1569) p.dedent() p.write(")") } @@ -4820,22 +4824,22 @@ func (p *PrettyPrinter) pretty_export_csv_column(msg *pb.ExportCSVColumn) interf } func (p *PrettyPrinter) pretty_export_csv_columns_list(msg []*pb.ExportCSVColumn) interface{} { - flat1570 := p.tryFlat(msg, func() { p.pretty_export_csv_columns_list(msg) }) - if flat1570 != nil { - p.write(*flat1570) + flat1574 := p.tryFlat(msg, func() { p.pretty_export_csv_columns_list(msg) }) + if flat1574 != nil { + p.write(*flat1574) return nil } else { - fields1567 := msg + fields1571 := msg p.write("(") p.write("columns") p.indentSexp() - if !(len(fields1567) == 0) { + if !(len(fields1571) == 0) { p.newline() - for i1569, elem1568 := range fields1567 { - if (i1569 > 0) { + for i1573, elem1572 := range fields1571 { + if (i1573 > 0) { p.newline() } - p.pretty_export_csv_column(elem1568) + p.pretty_export_csv_column(elem1572) } } p.dedent() @@ -4845,38 +4849,38 @@ func (p *PrettyPrinter) pretty_export_csv_columns_list(msg []*pb.ExportCSVColumn } func (p *PrettyPrinter) pretty_export_iceberg_config(msg *pb.ExportIcebergConfig) interface{} { - flat1580 := p.tryFlat(msg, func() { p.pretty_export_iceberg_config(msg) }) - if flat1580 != nil { - p.write(*flat1580) + flat1584 := p.tryFlat(msg, func() { p.pretty_export_iceberg_config(msg) }) + if flat1584 != nil { + p.write(*flat1584) return nil } else { _dollar_dollar := msg - _t1736 := p.deconstruct_export_iceberg_config_optional(_dollar_dollar) - fields1571 := []interface{}{_dollar_dollar.GetLocator(), _dollar_dollar.GetConfig(), _dollar_dollar.GetTableDef(), _dollar_dollar.GetColumns(), dictToPairs(_dollar_dollar.GetTableProperties()), _t1736} - unwrapped_fields1572 := fields1571 + _t1740 := p.deconstruct_export_iceberg_config_optional(_dollar_dollar) + fields1575 := []interface{}{_dollar_dollar.GetLocator(), _dollar_dollar.GetConfig(), _dollar_dollar.GetTableDef(), _dollar_dollar.GetColumns(), dictToPairs(_dollar_dollar.GetTableProperties()), _t1740} + unwrapped_fields1576 := fields1575 p.write("(") p.write("export_iceberg_config") p.indentSexp() p.newline() - field1573 := unwrapped_fields1572[0].(*pb.IcebergLocator) - p.pretty_iceberg_locator(field1573) + field1577 := unwrapped_fields1576[0].(*pb.IcebergLocator) + p.pretty_iceberg_locator(field1577) p.newline() - field1574 := unwrapped_fields1572[1].(*pb.IcebergCatalogConfig) - p.pretty_iceberg_catalog_config(field1574) + field1578 := unwrapped_fields1576[1].(*pb.IcebergCatalogConfig) + p.pretty_iceberg_catalog_config(field1578) p.newline() - field1575 := unwrapped_fields1572[2].(*pb.RelationId) - p.pretty_export_iceberg_table_def(field1575) + field1579 := unwrapped_fields1576[2].(*pb.RelationId) + p.pretty_export_iceberg_table_def(field1579) p.newline() - field1576 := unwrapped_fields1572[3].([]*pb.ExportColumn) - p.pretty_export_iceberg_columns(field1576) + field1580 := unwrapped_fields1576[3].([]*pb.ExportColumn) + p.pretty_export_iceberg_columns(field1580) p.newline() - field1577 := unwrapped_fields1572[4].([][]interface{}) - p.pretty_iceberg_table_properties(field1577) - field1578 := unwrapped_fields1572[5].([][]interface{}) - if field1578 != nil { + field1581 := unwrapped_fields1576[4].([][]interface{}) + p.pretty_iceberg_table_properties(field1581) + field1582 := unwrapped_fields1576[5].([][]interface{}) + if field1582 != nil { p.newline() - opt_val1579 := field1578 - p.pretty_config_dict(opt_val1579) + opt_val1583 := field1582 + p.pretty_config_dict(opt_val1583) } p.dedent() p.write(")") @@ -4885,17 +4889,17 @@ func (p *PrettyPrinter) pretty_export_iceberg_config(msg *pb.ExportIcebergConfig } func (p *PrettyPrinter) pretty_export_iceberg_table_def(msg *pb.RelationId) interface{} { - flat1582 := p.tryFlat(msg, func() { p.pretty_export_iceberg_table_def(msg) }) - if flat1582 != nil { - p.write(*flat1582) + flat1586 := p.tryFlat(msg, func() { p.pretty_export_iceberg_table_def(msg) }) + if flat1586 != nil { + p.write(*flat1586) return nil } else { - fields1581 := msg + fields1585 := msg p.write("(") p.write("table_def") p.indentSexp() p.newline() - p.pretty_relation_id(fields1581) + p.pretty_relation_id(fields1585) p.dedent() p.write(")") } @@ -4903,22 +4907,22 @@ func (p *PrettyPrinter) pretty_export_iceberg_table_def(msg *pb.RelationId) inte } func (p *PrettyPrinter) pretty_export_iceberg_columns(msg []*pb.ExportColumn) interface{} { - flat1586 := p.tryFlat(msg, func() { p.pretty_export_iceberg_columns(msg) }) - if flat1586 != nil { - p.write(*flat1586) + flat1590 := p.tryFlat(msg, func() { p.pretty_export_iceberg_columns(msg) }) + if flat1590 != nil { + p.write(*flat1590) return nil } else { - fields1583 := msg + fields1587 := msg p.write("(") p.write("columns") p.indentSexp() - if !(len(fields1583) == 0) { + if !(len(fields1587) == 0) { p.newline() - for i1585, elem1584 := range fields1583 { - if (i1585 > 0) { + for i1589, elem1588 := range fields1587 { + if (i1589 > 0) { p.newline() } - p.pretty_export_iceberg_column(elem1584) + p.pretty_export_iceberg_column(elem1588) } } p.dedent() @@ -4928,23 +4932,23 @@ func (p *PrettyPrinter) pretty_export_iceberg_columns(msg []*pb.ExportColumn) in } func (p *PrettyPrinter) pretty_export_iceberg_column(msg *pb.ExportColumn) interface{} { - flat1591 := p.tryFlat(msg, func() { p.pretty_export_iceberg_column(msg) }) - if flat1591 != nil { - p.write(*flat1591) + flat1595 := p.tryFlat(msg, func() { p.pretty_export_iceberg_column(msg) }) + if flat1595 != nil { + p.write(*flat1595) return nil } else { _dollar_dollar := msg - fields1587 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetNullable()} - unwrapped_fields1588 := fields1587 + fields1591 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetNullable()} + unwrapped_fields1592 := fields1591 p.write("(") p.write("column") p.indentSexp() p.newline() - field1589 := unwrapped_fields1588[0].(string) - p.write(p.formatStringValue(field1589)) + field1593 := unwrapped_fields1592[0].(string) + p.write(p.formatStringValue(field1593)) p.newline() - field1590 := unwrapped_fields1588[1].(bool) - p.pretty_boolean_value(field1590) + field1594 := unwrapped_fields1592[1].(bool) + p.pretty_boolean_value(field1594) p.dedent() p.write(")") } @@ -4952,22 +4956,22 @@ func (p *PrettyPrinter) pretty_export_iceberg_column(msg *pb.ExportColumn) inter } func (p *PrettyPrinter) pretty_iceberg_table_properties(msg [][]interface{}) interface{} { - flat1595 := p.tryFlat(msg, func() { p.pretty_iceberg_table_properties(msg) }) - if flat1595 != nil { - p.write(*flat1595) + flat1599 := p.tryFlat(msg, func() { p.pretty_iceberg_table_properties(msg) }) + if flat1599 != nil { + p.write(*flat1599) return nil } else { - fields1592 := msg + fields1596 := msg p.write("(") p.write("table_properties") p.indentSexp() - if !(len(fields1592) == 0) { + if !(len(fields1596) == 0) { p.newline() - for i1594, elem1593 := range fields1592 { - if (i1594 > 0) { + for i1598, elem1597 := range fields1596 { + if (i1598 > 0) { p.newline() } - p.pretty_iceberg_property_entry(elem1593) + p.pretty_iceberg_property_entry(elem1597) } } p.dedent() @@ -4985,8 +4989,8 @@ func (p *PrettyPrinter) pretty_debug_info(msg *pb.DebugInfo) interface{} { for _idx, _rid := range msg.GetIds() { p.newline() p.write("(") - _t1782 := &pb.UInt128Value{Low: _rid.GetIdLow(), High: _rid.GetIdHigh()} - p.pprintDispatch(_t1782) + _t1786 := &pb.UInt128Value{Low: _rid.GetIdLow(), High: _rid.GetIdHigh()} + p.pprintDispatch(_t1786) 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 250558e7..527af26b 100644 --- a/sdks/julia/LogicalQueryProtocol.jl/src/equality.jl +++ b/sdks/julia/LogicalQueryProtocol.jl/src/equality.jl @@ -442,9 +442,9 @@ Base.hash(a::SnapshotMapping, h::UInt) = hash(a.source_relation, hash(a.destinat Base.isequal(a::SnapshotMapping, b::SnapshotMapping) = isequal(a.destination_path, b.destination_path) && isequal(a.source_relation, b.source_relation) # Snapshot -Base.:(==)(a::Snapshot, b::Snapshot) = a.mappings == b.mappings -Base.hash(a::Snapshot, h::UInt) = hash(a.mappings, h) -Base.isequal(a::Snapshot, b::Snapshot) = isequal(a.mappings, b.mappings) +Base.:(==)(a::Snapshot, b::Snapshot) = a.prefix == b.prefix && a.mappings == b.mappings +Base.hash(a::Snapshot, h::UInt) = hash(a.mappings, hash(a.prefix, h)) +Base.isequal(a::Snapshot, b::Snapshot) = isequal(a.prefix, b.prefix) && isequal(a.mappings, b.mappings) # Context Base.:(==)(a::Context, b::Context) = a.relations == b.relations 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 a0350aaa..7ba9a68c 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 @@ -494,32 +494,38 @@ end struct Snapshot mappings::Vector{SnapshotMapping} + prefix::Vector{String} end -Snapshot(;mappings = Vector{SnapshotMapping}()) = Snapshot(mappings) -PB.default_values(::Type{Snapshot}) = (;mappings = Vector{SnapshotMapping}()) -PB.field_numbers(::Type{Snapshot}) = (;mappings = 1) +Snapshot(;mappings = Vector{SnapshotMapping}(), prefix = Vector{String}()) = Snapshot(mappings, prefix) +PB.default_values(::Type{Snapshot}) = (;mappings = Vector{SnapshotMapping}(), prefix = Vector{String}()) +PB.field_numbers(::Type{Snapshot}) = (;mappings = 1, prefix = 2) function PB.decode(d::PB.AbstractProtoDecoder, ::Type{<:Snapshot}, _endpos::Int=0, _group::Bool=false) mappings = PB.BufferedVector{SnapshotMapping}() + prefix = PB.BufferedVector{String}() while !PB.message_done(d, _endpos, _group) field_number, wire_type = PB.decode_tag(d) if field_number == 1 PB.decode!(d, mappings) + elseif field_number == 2 + PB.decode!(d, prefix) else Base.skip(d, wire_type) end end - return Snapshot(mappings[]) + return Snapshot(mappings[], prefix[]) end function PB.encode(e::PB.AbstractProtoEncoder, x::Snapshot) initpos = position(e.io) !isempty(x.mappings) && PB.encode(e, 1, x.mappings) + !isempty(x.prefix) && PB.encode(e, 2, x.prefix) return position(e.io) - initpos end function PB._encoded_size(x::Snapshot) encoded_size = 0 !isempty(x.mappings) && (encoded_size += PB._encoded_size(x.mappings, 1)) + !isempty(x.prefix) && (encoded_size += PB._encoded_size(x.prefix, 2)) return encoded_size end diff --git a/sdks/julia/LogicalQueryProtocol.jl/src/parser.jl b/sdks/julia/LogicalQueryProtocol.jl/src/parser.jl index 38a4fa7b..88ac8406 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 - _t2092 = nothing + _t2095 = 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 - _t2093 = nothing + _t2096 = 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 - _t2094 = nothing + _t2097 = 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 - _t2095 = nothing + _t2098 = 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 - _t2096 = nothing + _t2099 = 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 - _t2097 = nothing + _t2100 = 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 - _t2098 = nothing + _t2101 = 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 - _t2099 = nothing + _t2102 = nothing end return nothing end @@ -444,72 +444,72 @@ 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 - _t2100 = nothing + _t2103 = nothing end return nothing end function construct_csv_config(parser::ParserState, config_dict::Vector{Tuple{String, Proto.Value}})::Proto.CSVConfig config = Dict(config_dict) - _t2101 = _extract_value_int32(parser, get(config, "csv_header_row", nothing), 1) - header_row = _t2101 - _t2102 = _extract_value_int64(parser, get(config, "csv_skip", nothing), 0) - skip = _t2102 - _t2103 = _extract_value_string(parser, get(config, "csv_new_line", nothing), "") - new_line = _t2103 - _t2104 = _extract_value_string(parser, get(config, "csv_delimiter", nothing), ",") - delimiter = _t2104 - _t2105 = _extract_value_string(parser, get(config, "csv_quotechar", nothing), "\"") - quotechar = _t2105 - _t2106 = _extract_value_string(parser, get(config, "csv_escapechar", nothing), "\"") - escapechar = _t2106 - _t2107 = _extract_value_string(parser, get(config, "csv_comment", nothing), "") - comment = _t2107 - _t2108 = _extract_value_string_list(parser, get(config, "csv_missing_strings", nothing), String[]) - missing_strings = _t2108 - _t2109 = _extract_value_string(parser, get(config, "csv_decimal_separator", nothing), ".") - decimal_separator = _t2109 - _t2110 = _extract_value_string(parser, get(config, "csv_encoding", nothing), "utf-8") - encoding = _t2110 - _t2111 = _extract_value_string(parser, get(config, "csv_compression", nothing), "auto") - compression = _t2111 - _t2112 = _extract_value_int64(parser, get(config, "csv_partition_size_mb", nothing), 0) - partition_size_mb = _t2112 - _t2113 = 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) - return _t2113 + _t2104 = _extract_value_int32(parser, get(config, "csv_header_row", nothing), 1) + header_row = _t2104 + _t2105 = _extract_value_int64(parser, get(config, "csv_skip", nothing), 0) + skip = _t2105 + _t2106 = _extract_value_string(parser, get(config, "csv_new_line", nothing), "") + new_line = _t2106 + _t2107 = _extract_value_string(parser, get(config, "csv_delimiter", nothing), ",") + delimiter = _t2107 + _t2108 = _extract_value_string(parser, get(config, "csv_quotechar", nothing), "\"") + quotechar = _t2108 + _t2109 = _extract_value_string(parser, get(config, "csv_escapechar", nothing), "\"") + escapechar = _t2109 + _t2110 = _extract_value_string(parser, get(config, "csv_comment", nothing), "") + comment = _t2110 + _t2111 = _extract_value_string_list(parser, get(config, "csv_missing_strings", nothing), String[]) + missing_strings = _t2111 + _t2112 = _extract_value_string(parser, get(config, "csv_decimal_separator", nothing), ".") + decimal_separator = _t2112 + _t2113 = _extract_value_string(parser, get(config, "csv_encoding", nothing), "utf-8") + encoding = _t2113 + _t2114 = _extract_value_string(parser, get(config, "csv_compression", nothing), "auto") + compression = _t2114 + _t2115 = _extract_value_int64(parser, get(config, "csv_partition_size_mb", nothing), 0) + partition_size_mb = _t2115 + _t2116 = 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) + return _t2116 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) - _t2114 = _try_extract_value_float64(parser, get(config, "betree_config_epsilon", nothing)) - epsilon = _t2114 - _t2115 = _try_extract_value_int64(parser, get(config, "betree_config_max_pivots", nothing)) - max_pivots = _t2115 - _t2116 = _try_extract_value_int64(parser, get(config, "betree_config_max_deltas", nothing)) - max_deltas = _t2116 - _t2117 = _try_extract_value_int64(parser, get(config, "betree_config_max_leaf", nothing)) - max_leaf = _t2117 - _t2118 = Proto.BeTreeConfig(epsilon=epsilon, max_pivots=max_pivots, max_deltas=max_deltas, max_leaf=max_leaf) - storage_config = _t2118 - _t2119 = _try_extract_value_uint128(parser, get(config, "betree_locator_root_pageid", nothing)) - root_pageid = _t2119 - _t2120 = _try_extract_value_bytes(parser, get(config, "betree_locator_inline_data", nothing)) - inline_data = _t2120 - _t2121 = _try_extract_value_int64(parser, get(config, "betree_locator_element_count", nothing)) - element_count = _t2121 - _t2122 = _try_extract_value_int64(parser, get(config, "betree_locator_tree_height", nothing)) - tree_height = _t2122 - _t2123 = 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 = _t2123 - _t2124 = Proto.BeTreeInfo(key_types=key_types, value_types=value_types, storage_config=storage_config, relation_locator=relation_locator) - return _t2124 + _t2117 = _try_extract_value_float64(parser, get(config, "betree_config_epsilon", nothing)) + epsilon = _t2117 + _t2118 = _try_extract_value_int64(parser, get(config, "betree_config_max_pivots", nothing)) + max_pivots = _t2118 + _t2119 = _try_extract_value_int64(parser, get(config, "betree_config_max_deltas", nothing)) + max_deltas = _t2119 + _t2120 = _try_extract_value_int64(parser, get(config, "betree_config_max_leaf", nothing)) + max_leaf = _t2120 + _t2121 = Proto.BeTreeConfig(epsilon=epsilon, max_pivots=max_pivots, max_deltas=max_deltas, max_leaf=max_leaf) + storage_config = _t2121 + _t2122 = _try_extract_value_uint128(parser, get(config, "betree_locator_root_pageid", nothing)) + root_pageid = _t2122 + _t2123 = _try_extract_value_bytes(parser, get(config, "betree_locator_inline_data", nothing)) + inline_data = _t2123 + _t2124 = _try_extract_value_int64(parser, get(config, "betree_locator_element_count", nothing)) + element_count = _t2124 + _t2125 = _try_extract_value_int64(parser, get(config, "betree_locator_tree_height", nothing)) + tree_height = _t2125 + _t2126 = 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 = _t2126 + _t2127 = Proto.BeTreeInfo(key_types=key_types, value_types=value_types, storage_config=storage_config, relation_locator=relation_locator) + return _t2127 end function default_configure(parser::ParserState)::Proto.Configure - _t2125 = Proto.IVMConfig(level=Proto.MaintenanceLevel.MAINTENANCE_LEVEL_OFF) - ivm_config = _t2125 - _t2126 = Proto.Configure(semantics_version=0, ivm_config=ivm_config) - return _t2126 + _t2128 = Proto.IVMConfig(level=Proto.MaintenanceLevel.MAINTENANCE_LEVEL_OFF) + ivm_config = _t2128 + _t2129 = Proto.Configure(semantics_version=0, ivm_config=ivm_config) + return _t2129 end function construct_configure(parser::ParserState, config_dict::Vector{Tuple{String, Proto.Value}})::Proto.Configure @@ -531,3856 +531,3858 @@ function construct_configure(parser::ParserState, config_dict::Vector{Tuple{Stri end end end - _t2127 = Proto.IVMConfig(level=maintenance_level) - ivm_config = _t2127 - _t2128 = _extract_value_int64(parser, get(config, "semantics_version", nothing), 0) - semantics_version = _t2128 - _t2129 = Proto.Configure(semantics_version=semantics_version, ivm_config=ivm_config) - return _t2129 + _t2130 = Proto.IVMConfig(level=maintenance_level) + ivm_config = _t2130 + _t2131 = _extract_value_int64(parser, get(config, "semantics_version", nothing), 0) + semantics_version = _t2131 + _t2132 = Proto.Configure(semantics_version=semantics_version, ivm_config=ivm_config) + return _t2132 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) - _t2130 = _extract_value_int64(parser, get(config, "partition_size", nothing), 0) - partition_size = _t2130 - _t2131 = _extract_value_string(parser, get(config, "compression", nothing), "") - compression = _t2131 - _t2132 = _extract_value_boolean(parser, get(config, "syntax_header_row", nothing), true) - syntax_header_row = _t2132 - _t2133 = _extract_value_string(parser, get(config, "syntax_missing_string", nothing), "") - syntax_missing_string = _t2133 - _t2134 = _extract_value_string(parser, get(config, "syntax_delim", nothing), ",") - syntax_delim = _t2134 - _t2135 = _extract_value_string(parser, get(config, "syntax_quotechar", nothing), "\"") - syntax_quotechar = _t2135 - _t2136 = _extract_value_string(parser, get(config, "syntax_escapechar", nothing), "\\") - syntax_escapechar = _t2136 - _t2137 = 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 _t2137 + _t2133 = _extract_value_int64(parser, get(config, "partition_size", nothing), 0) + partition_size = _t2133 + _t2134 = _extract_value_string(parser, get(config, "compression", nothing), "") + compression = _t2134 + _t2135 = _extract_value_boolean(parser, get(config, "syntax_header_row", nothing), true) + syntax_header_row = _t2135 + _t2136 = _extract_value_string(parser, get(config, "syntax_missing_string", nothing), "") + syntax_missing_string = _t2136 + _t2137 = _extract_value_string(parser, get(config, "syntax_delim", nothing), ",") + syntax_delim = _t2137 + _t2138 = _extract_value_string(parser, get(config, "syntax_quotechar", nothing), "\"") + syntax_quotechar = _t2138 + _t2139 = _extract_value_string(parser, get(config, "syntax_escapechar", nothing), "\\") + syntax_escapechar = _t2139 + _t2140 = 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 _t2140 end function construct_export_csv_config_with_source(parser::ParserState, path::String, csv_source::Proto.ExportCSVSource, csv_config::Proto.CSVConfig)::Proto.ExportCSVConfig - _t2138 = Proto.ExportCSVConfig(path=path, csv_source=csv_source, csv_config=csv_config) - return _t2138 + _t2141 = Proto.ExportCSVConfig(path=path, csv_source=csv_source, csv_config=csv_config) + return _t2141 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) - _t2139 = Proto.IcebergCatalogConfig(catalog_uri=catalog_uri, scope=(!isnothing(scope_opt) ? scope_opt : ""), properties=props, auth_properties=auth_props) - return _t2139 + _t2142 = Proto.IcebergCatalogConfig(catalog_uri=catalog_uri, scope=(!isnothing(scope_opt) ? scope_opt : ""), properties=props, auth_properties=auth_props) + return _t2142 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 - _t2140 = 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 _t2140 + _t2143 = 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 _t2143 end function construct_export_iceberg_config_full(parser::ParserState, locator::Proto.IcebergLocator, config::Proto.IcebergCatalogConfig, table_def::Proto.RelationId, columns::Vector{Proto.ExportColumn}, 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}[])) - _t2141 = _extract_value_string(parser, get(cfg, "prefix", nothing), "") - prefix = _t2141 - _t2142 = _extract_value_int64(parser, get(cfg, "target_file_size_bytes", nothing), 0) - target_file_size_bytes = _t2142 - _t2143 = _extract_value_string(parser, get(cfg, "compression", nothing), "") - compression = _t2143 + _t2144 = _extract_value_string(parser, get(cfg, "prefix", nothing), "") + prefix = _t2144 + _t2145 = _extract_value_int64(parser, get(cfg, "target_file_size_bytes", nothing), 0) + target_file_size_bytes = _t2145 + _t2146 = _extract_value_string(parser, get(cfg, "compression", nothing), "") + compression = _t2146 table_props = Dict(table_property_pairs) - _t2144 = Proto.ExportIcebergConfig(locator=locator, config=config, table_def=table_def, columns=columns, prefix=prefix, target_file_size_bytes=target_file_size_bytes, compression=compression, table_properties=table_props) - return _t2144 + _t2147 = Proto.ExportIcebergConfig(locator=locator, config=config, table_def=table_def, columns=columns, prefix=prefix, target_file_size_bytes=target_file_size_bytes, compression=compression, table_properties=table_props) + return _t2147 end # --- Parse functions --- function parse_transaction(parser::ParserState)::Proto.Transaction - span_start677 = span_start(parser) + span_start678 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "transaction") if (match_lookahead_literal(parser, "(", 0) && match_lookahead_literal(parser, "configure", 1)) - _t1343 = parse_configure(parser) - _t1342 = _t1343 + _t1345 = parse_configure(parser) + _t1344 = _t1345 else - _t1342 = nothing + _t1344 = nothing end - configure671 = _t1342 + configure672 = _t1344 if (match_lookahead_literal(parser, "(", 0) && match_lookahead_literal(parser, "sync", 1)) - _t1345 = parse_sync(parser) - _t1344 = _t1345 + _t1347 = parse_sync(parser) + _t1346 = _t1347 else - _t1344 = nothing + _t1346 = nothing end - sync672 = _t1344 - xs673 = Proto.Epoch[] - cond674 = match_lookahead_literal(parser, "(", 0) - while cond674 - _t1346 = parse_epoch(parser) - item675 = _t1346 - push!(xs673, item675) - cond674 = match_lookahead_literal(parser, "(", 0) + sync673 = _t1346 + xs674 = Proto.Epoch[] + cond675 = match_lookahead_literal(parser, "(", 0) + while cond675 + _t1348 = parse_epoch(parser) + item676 = _t1348 + push!(xs674, item676) + cond675 = match_lookahead_literal(parser, "(", 0) end - epochs676 = xs673 + epochs677 = xs674 consume_literal!(parser, ")") - _t1347 = default_configure(parser) - _t1348 = Proto.Transaction(epochs=epochs676, configure=(!isnothing(configure671) ? configure671 : _t1347), sync=sync672) - result678 = _t1348 - record_span!(parser, span_start677, "Transaction") - return result678 + _t1349 = default_configure(parser) + _t1350 = Proto.Transaction(epochs=epochs677, configure=(!isnothing(configure672) ? configure672 : _t1349), sync=sync673) + result679 = _t1350 + record_span!(parser, span_start678, "Transaction") + return result679 end function parse_configure(parser::ParserState)::Proto.Configure - span_start680 = span_start(parser) + span_start681 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "configure") - _t1349 = parse_config_dict(parser) - config_dict679 = _t1349 + _t1351 = parse_config_dict(parser) + config_dict680 = _t1351 consume_literal!(parser, ")") - _t1350 = construct_configure(parser, config_dict679) - result681 = _t1350 - record_span!(parser, span_start680, "Configure") - return result681 + _t1352 = construct_configure(parser, config_dict680) + result682 = _t1352 + record_span!(parser, span_start681, "Configure") + return result682 end function parse_config_dict(parser::ParserState)::Vector{Tuple{String, Proto.Value}} consume_literal!(parser, "{") - xs682 = Tuple{String, Proto.Value}[] - cond683 = match_lookahead_literal(parser, ":", 0) - while cond683 - _t1351 = parse_config_key_value(parser) - item684 = _t1351 - push!(xs682, item684) - cond683 = match_lookahead_literal(parser, ":", 0) + xs683 = Tuple{String, Proto.Value}[] + cond684 = match_lookahead_literal(parser, ":", 0) + while cond684 + _t1353 = parse_config_key_value(parser) + item685 = _t1353 + push!(xs683, item685) + cond684 = match_lookahead_literal(parser, ":", 0) end - config_key_values685 = xs682 + config_key_values686 = xs683 consume_literal!(parser, "}") - return config_key_values685 + return config_key_values686 end function parse_config_key_value(parser::ParserState)::Tuple{String, Proto.Value} consume_literal!(parser, ":") - symbol686 = consume_terminal!(parser, "SYMBOL") - _t1352 = parse_raw_value(parser) - raw_value687 = _t1352 - return (symbol686, raw_value687,) + symbol687 = consume_terminal!(parser, "SYMBOL") + _t1354 = parse_raw_value(parser) + raw_value688 = _t1354 + return (symbol687, raw_value688,) end function parse_raw_value(parser::ParserState)::Proto.Value - span_start701 = span_start(parser) + span_start702 = span_start(parser) if match_lookahead_literal(parser, "true", 0) - _t1353 = 12 + _t1355 = 12 else if match_lookahead_literal(parser, "missing", 0) - _t1354 = 11 + _t1356 = 11 else if match_lookahead_literal(parser, "false", 0) - _t1355 = 12 + _t1357 = 12 else if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "datetime", 1) - _t1357 = 1 + _t1359 = 1 else if match_lookahead_literal(parser, "date", 1) - _t1358 = 0 + _t1360 = 0 else - _t1358 = -1 + _t1360 = -1 end - _t1357 = _t1358 + _t1359 = _t1360 end - _t1356 = _t1357 + _t1358 = _t1359 else if match_lookahead_terminal(parser, "UINT32", 0) - _t1359 = 7 + _t1361 = 7 else if match_lookahead_terminal(parser, "UINT128", 0) - _t1360 = 8 + _t1362 = 8 else if match_lookahead_terminal(parser, "STRING", 0) - _t1361 = 2 + _t1363 = 2 else if match_lookahead_terminal(parser, "INT32", 0) - _t1362 = 3 + _t1364 = 3 else if match_lookahead_terminal(parser, "INT128", 0) - _t1363 = 9 + _t1365 = 9 else if match_lookahead_terminal(parser, "INT", 0) - _t1364 = 4 + _t1366 = 4 else if match_lookahead_terminal(parser, "FLOAT32", 0) - _t1365 = 5 + _t1367 = 5 else if match_lookahead_terminal(parser, "FLOAT", 0) - _t1366 = 6 + _t1368 = 6 else if match_lookahead_terminal(parser, "DECIMAL", 0) - _t1367 = 10 + _t1369 = 10 else - _t1367 = -1 + _t1369 = -1 end - _t1366 = _t1367 + _t1368 = _t1369 end - _t1365 = _t1366 + _t1367 = _t1368 end - _t1364 = _t1365 + _t1366 = _t1367 end - _t1363 = _t1364 + _t1365 = _t1366 end - _t1362 = _t1363 + _t1364 = _t1365 end - _t1361 = _t1362 + _t1363 = _t1364 end - _t1360 = _t1361 + _t1362 = _t1363 end - _t1359 = _t1360 + _t1361 = _t1362 end - _t1356 = _t1359 + _t1358 = _t1361 end - _t1355 = _t1356 + _t1357 = _t1358 end - _t1354 = _t1355 + _t1356 = _t1357 end - _t1353 = _t1354 + _t1355 = _t1356 end - prediction688 = _t1353 - if prediction688 == 12 - _t1369 = parse_boolean_value(parser) - boolean_value700 = _t1369 - _t1370 = Proto.Value(value=OneOf(:boolean_value, boolean_value700)) - _t1368 = _t1370 + prediction689 = _t1355 + if prediction689 == 12 + _t1371 = parse_boolean_value(parser) + boolean_value701 = _t1371 + _t1372 = Proto.Value(value=OneOf(:boolean_value, boolean_value701)) + _t1370 = _t1372 else - if prediction688 == 11 + if prediction689 == 11 consume_literal!(parser, "missing") - _t1372 = Proto.MissingValue() - _t1373 = Proto.Value(value=OneOf(:missing_value, _t1372)) - _t1371 = _t1373 + _t1374 = Proto.MissingValue() + _t1375 = Proto.Value(value=OneOf(:missing_value, _t1374)) + _t1373 = _t1375 else - if prediction688 == 10 - decimal699 = consume_terminal!(parser, "DECIMAL") - _t1375 = Proto.Value(value=OneOf(:decimal_value, decimal699)) - _t1374 = _t1375 + if prediction689 == 10 + decimal700 = consume_terminal!(parser, "DECIMAL") + _t1377 = Proto.Value(value=OneOf(:decimal_value, decimal700)) + _t1376 = _t1377 else - if prediction688 == 9 - int128698 = consume_terminal!(parser, "INT128") - _t1377 = Proto.Value(value=OneOf(:int128_value, int128698)) - _t1376 = _t1377 + if prediction689 == 9 + int128699 = consume_terminal!(parser, "INT128") + _t1379 = Proto.Value(value=OneOf(:int128_value, int128699)) + _t1378 = _t1379 else - if prediction688 == 8 - uint128697 = consume_terminal!(parser, "UINT128") - _t1379 = Proto.Value(value=OneOf(:uint128_value, uint128697)) - _t1378 = _t1379 + if prediction689 == 8 + uint128698 = consume_terminal!(parser, "UINT128") + _t1381 = Proto.Value(value=OneOf(:uint128_value, uint128698)) + _t1380 = _t1381 else - if prediction688 == 7 - uint32696 = consume_terminal!(parser, "UINT32") - _t1381 = Proto.Value(value=OneOf(:uint32_value, uint32696)) - _t1380 = _t1381 + if prediction689 == 7 + uint32697 = consume_terminal!(parser, "UINT32") + _t1383 = Proto.Value(value=OneOf(:uint32_value, uint32697)) + _t1382 = _t1383 else - if prediction688 == 6 - float695 = consume_terminal!(parser, "FLOAT") - _t1383 = Proto.Value(value=OneOf(:float_value, float695)) - _t1382 = _t1383 + if prediction689 == 6 + float696 = consume_terminal!(parser, "FLOAT") + _t1385 = Proto.Value(value=OneOf(:float_value, float696)) + _t1384 = _t1385 else - if prediction688 == 5 - float32694 = consume_terminal!(parser, "FLOAT32") - _t1385 = Proto.Value(value=OneOf(:float32_value, float32694)) - _t1384 = _t1385 + if prediction689 == 5 + float32695 = consume_terminal!(parser, "FLOAT32") + _t1387 = Proto.Value(value=OneOf(:float32_value, float32695)) + _t1386 = _t1387 else - if prediction688 == 4 - int693 = consume_terminal!(parser, "INT") - _t1387 = Proto.Value(value=OneOf(:int_value, int693)) - _t1386 = _t1387 + if prediction689 == 4 + int694 = consume_terminal!(parser, "INT") + _t1389 = Proto.Value(value=OneOf(:int_value, int694)) + _t1388 = _t1389 else - if prediction688 == 3 - int32692 = consume_terminal!(parser, "INT32") - _t1389 = Proto.Value(value=OneOf(:int32_value, int32692)) - _t1388 = _t1389 + if prediction689 == 3 + int32693 = consume_terminal!(parser, "INT32") + _t1391 = Proto.Value(value=OneOf(:int32_value, int32693)) + _t1390 = _t1391 else - if prediction688 == 2 - string691 = consume_terminal!(parser, "STRING") - _t1391 = Proto.Value(value=OneOf(:string_value, string691)) - _t1390 = _t1391 + if prediction689 == 2 + string692 = consume_terminal!(parser, "STRING") + _t1393 = Proto.Value(value=OneOf(:string_value, string692)) + _t1392 = _t1393 else - if prediction688 == 1 - _t1393 = parse_raw_datetime(parser) - raw_datetime690 = _t1393 - _t1394 = Proto.Value(value=OneOf(:datetime_value, raw_datetime690)) - _t1392 = _t1394 + if prediction689 == 1 + _t1395 = parse_raw_datetime(parser) + raw_datetime691 = _t1395 + _t1396 = Proto.Value(value=OneOf(:datetime_value, raw_datetime691)) + _t1394 = _t1396 else - if prediction688 == 0 - _t1396 = parse_raw_date(parser) - raw_date689 = _t1396 - _t1397 = Proto.Value(value=OneOf(:date_value, raw_date689)) - _t1395 = _t1397 + if prediction689 == 0 + _t1398 = parse_raw_date(parser) + raw_date690 = _t1398 + _t1399 = Proto.Value(value=OneOf(:date_value, raw_date690)) + _t1397 = _t1399 else throw(ParseError("Unexpected token in raw_value" * ": " * string(lookahead(parser, 0)))) end - _t1392 = _t1395 + _t1394 = _t1397 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 - _t1380 = _t1382 + _t1382 = _t1384 end - _t1378 = _t1380 + _t1380 = _t1382 end - _t1376 = _t1378 + _t1378 = _t1380 end - _t1374 = _t1376 + _t1376 = _t1378 end - _t1371 = _t1374 + _t1373 = _t1376 end - _t1368 = _t1371 + _t1370 = _t1373 end - result702 = _t1368 - record_span!(parser, span_start701, "Value") - return result702 + result703 = _t1370 + record_span!(parser, span_start702, "Value") + return result703 end function parse_raw_date(parser::ParserState)::Proto.DateValue - span_start706 = span_start(parser) + span_start707 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "date") - int703 = consume_terminal!(parser, "INT") - int_3704 = consume_terminal!(parser, "INT") - int_4705 = consume_terminal!(parser, "INT") + int704 = consume_terminal!(parser, "INT") + int_3705 = consume_terminal!(parser, "INT") + int_4706 = consume_terminal!(parser, "INT") consume_literal!(parser, ")") - _t1398 = Proto.DateValue(year=Int32(int703), month=Int32(int_3704), day=Int32(int_4705)) - result707 = _t1398 - record_span!(parser, span_start706, "DateValue") - return result707 + _t1400 = Proto.DateValue(year=Int32(int704), month=Int32(int_3705), day=Int32(int_4706)) + result708 = _t1400 + record_span!(parser, span_start707, "DateValue") + return result708 end function parse_raw_datetime(parser::ParserState)::Proto.DateTimeValue - span_start715 = span_start(parser) + span_start716 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "datetime") - int708 = consume_terminal!(parser, "INT") - int_3709 = consume_terminal!(parser, "INT") - int_4710 = consume_terminal!(parser, "INT") - int_5711 = consume_terminal!(parser, "INT") - int_6712 = consume_terminal!(parser, "INT") - int_7713 = consume_terminal!(parser, "INT") + int709 = consume_terminal!(parser, "INT") + int_3710 = consume_terminal!(parser, "INT") + int_4711 = consume_terminal!(parser, "INT") + int_5712 = consume_terminal!(parser, "INT") + int_6713 = consume_terminal!(parser, "INT") + int_7714 = consume_terminal!(parser, "INT") if match_lookahead_terminal(parser, "INT", 0) - _t1399 = consume_terminal!(parser, "INT") + _t1401 = consume_terminal!(parser, "INT") else - _t1399 = nothing + _t1401 = nothing end - int_8714 = _t1399 + int_8715 = _t1401 consume_literal!(parser, ")") - _t1400 = Proto.DateTimeValue(year=Int32(int708), month=Int32(int_3709), day=Int32(int_4710), hour=Int32(int_5711), minute=Int32(int_6712), second=Int32(int_7713), microsecond=Int32((!isnothing(int_8714) ? int_8714 : 0))) - result716 = _t1400 - record_span!(parser, span_start715, "DateTimeValue") - return result716 + _t1402 = Proto.DateTimeValue(year=Int32(int709), month=Int32(int_3710), day=Int32(int_4711), hour=Int32(int_5712), minute=Int32(int_6713), second=Int32(int_7714), microsecond=Int32((!isnothing(int_8715) ? int_8715 : 0))) + result717 = _t1402 + record_span!(parser, span_start716, "DateTimeValue") + return result717 end function parse_boolean_value(parser::ParserState)::Bool if match_lookahead_literal(parser, "true", 0) - _t1401 = 0 + _t1403 = 0 else if match_lookahead_literal(parser, "false", 0) - _t1402 = 1 + _t1404 = 1 else - _t1402 = -1 + _t1404 = -1 end - _t1401 = _t1402 + _t1403 = _t1404 end - prediction717 = _t1401 - if prediction717 == 1 + prediction718 = _t1403 + if prediction718 == 1 consume_literal!(parser, "false") - _t1403 = false + _t1405 = false else - if prediction717 == 0 + if prediction718 == 0 consume_literal!(parser, "true") - _t1404 = true + _t1406 = true else throw(ParseError("Unexpected token in boolean_value" * ": " * string(lookahead(parser, 0)))) end - _t1403 = _t1404 + _t1405 = _t1406 end - return _t1403 + return _t1405 end function parse_sync(parser::ParserState)::Proto.Sync - span_start722 = span_start(parser) + span_start723 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "sync") - xs718 = Proto.FragmentId[] - cond719 = match_lookahead_literal(parser, ":", 0) - while cond719 - _t1405 = parse_fragment_id(parser) - item720 = _t1405 - push!(xs718, item720) - cond719 = match_lookahead_literal(parser, ":", 0) + xs719 = Proto.FragmentId[] + cond720 = match_lookahead_literal(parser, ":", 0) + while cond720 + _t1407 = parse_fragment_id(parser) + item721 = _t1407 + push!(xs719, item721) + cond720 = match_lookahead_literal(parser, ":", 0) end - fragment_ids721 = xs718 + fragment_ids722 = xs719 consume_literal!(parser, ")") - _t1406 = Proto.Sync(fragments=fragment_ids721) - result723 = _t1406 - record_span!(parser, span_start722, "Sync") - return result723 + _t1408 = Proto.Sync(fragments=fragment_ids722) + result724 = _t1408 + record_span!(parser, span_start723, "Sync") + return result724 end function parse_fragment_id(parser::ParserState)::Proto.FragmentId - span_start725 = span_start(parser) + span_start726 = span_start(parser) consume_literal!(parser, ":") - symbol724 = consume_terminal!(parser, "SYMBOL") - result726 = Proto.FragmentId(Vector{UInt8}(symbol724)) - record_span!(parser, span_start725, "FragmentId") - return result726 + symbol725 = consume_terminal!(parser, "SYMBOL") + result727 = Proto.FragmentId(Vector{UInt8}(symbol725)) + record_span!(parser, span_start726, "FragmentId") + return result727 end function parse_epoch(parser::ParserState)::Proto.Epoch - span_start729 = span_start(parser) + span_start730 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "epoch") if (match_lookahead_literal(parser, "(", 0) && match_lookahead_literal(parser, "writes", 1)) - _t1408 = parse_epoch_writes(parser) - _t1407 = _t1408 + _t1410 = parse_epoch_writes(parser) + _t1409 = _t1410 else - _t1407 = nothing + _t1409 = nothing end - epoch_writes727 = _t1407 + epoch_writes728 = _t1409 if match_lookahead_literal(parser, "(", 0) - _t1410 = parse_epoch_reads(parser) - _t1409 = _t1410 + _t1412 = parse_epoch_reads(parser) + _t1411 = _t1412 else - _t1409 = nothing + _t1411 = nothing end - epoch_reads728 = _t1409 + epoch_reads729 = _t1411 consume_literal!(parser, ")") - _t1411 = Proto.Epoch(writes=(!isnothing(epoch_writes727) ? epoch_writes727 : Proto.Write[]), reads=(!isnothing(epoch_reads728) ? epoch_reads728 : Proto.Read[])) - result730 = _t1411 - record_span!(parser, span_start729, "Epoch") - return result730 + _t1413 = Proto.Epoch(writes=(!isnothing(epoch_writes728) ? epoch_writes728 : Proto.Write[]), reads=(!isnothing(epoch_reads729) ? epoch_reads729 : Proto.Read[])) + result731 = _t1413 + record_span!(parser, span_start730, "Epoch") + return result731 end function parse_epoch_writes(parser::ParserState)::Vector{Proto.Write} consume_literal!(parser, "(") consume_literal!(parser, "writes") - xs731 = Proto.Write[] - cond732 = match_lookahead_literal(parser, "(", 0) - while cond732 - _t1412 = parse_write(parser) - item733 = _t1412 - push!(xs731, item733) - cond732 = match_lookahead_literal(parser, "(", 0) + xs732 = Proto.Write[] + cond733 = match_lookahead_literal(parser, "(", 0) + while cond733 + _t1414 = parse_write(parser) + item734 = _t1414 + push!(xs732, item734) + cond733 = match_lookahead_literal(parser, "(", 0) end - writes734 = xs731 + writes735 = xs732 consume_literal!(parser, ")") - return writes734 + return writes735 end function parse_write(parser::ParserState)::Proto.Write - span_start740 = span_start(parser) + span_start741 = span_start(parser) if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "undefine", 1) - _t1414 = 1 + _t1416 = 1 else if match_lookahead_literal(parser, "snapshot", 1) - _t1415 = 3 + _t1417 = 3 else if match_lookahead_literal(parser, "define", 1) - _t1416 = 0 + _t1418 = 0 else if match_lookahead_literal(parser, "context", 1) - _t1417 = 2 + _t1419 = 2 else - _t1417 = -1 + _t1419 = -1 end - _t1416 = _t1417 + _t1418 = _t1419 end - _t1415 = _t1416 + _t1417 = _t1418 end - _t1414 = _t1415 + _t1416 = _t1417 end - _t1413 = _t1414 + _t1415 = _t1416 else - _t1413 = -1 + _t1415 = -1 end - prediction735 = _t1413 - if prediction735 == 3 - _t1419 = parse_snapshot(parser) - snapshot739 = _t1419 - _t1420 = Proto.Write(write_type=OneOf(:snapshot, snapshot739)) - _t1418 = _t1420 + prediction736 = _t1415 + if prediction736 == 3 + _t1421 = parse_snapshot(parser) + snapshot740 = _t1421 + _t1422 = Proto.Write(write_type=OneOf(:snapshot, snapshot740)) + _t1420 = _t1422 else - if prediction735 == 2 - _t1422 = parse_context(parser) - context738 = _t1422 - _t1423 = Proto.Write(write_type=OneOf(:context, context738)) - _t1421 = _t1423 + if prediction736 == 2 + _t1424 = parse_context(parser) + context739 = _t1424 + _t1425 = Proto.Write(write_type=OneOf(:context, context739)) + _t1423 = _t1425 else - if prediction735 == 1 - _t1425 = parse_undefine(parser) - undefine737 = _t1425 - _t1426 = Proto.Write(write_type=OneOf(:undefine, undefine737)) - _t1424 = _t1426 + if prediction736 == 1 + _t1427 = parse_undefine(parser) + undefine738 = _t1427 + _t1428 = Proto.Write(write_type=OneOf(:undefine, undefine738)) + _t1426 = _t1428 else - if prediction735 == 0 - _t1428 = parse_define(parser) - define736 = _t1428 - _t1429 = Proto.Write(write_type=OneOf(:define, define736)) - _t1427 = _t1429 + if prediction736 == 0 + _t1430 = parse_define(parser) + define737 = _t1430 + _t1431 = Proto.Write(write_type=OneOf(:define, define737)) + _t1429 = _t1431 else throw(ParseError("Unexpected token in write" * ": " * string(lookahead(parser, 0)))) end - _t1424 = _t1427 + _t1426 = _t1429 end - _t1421 = _t1424 + _t1423 = _t1426 end - _t1418 = _t1421 + _t1420 = _t1423 end - result741 = _t1418 - record_span!(parser, span_start740, "Write") - return result741 + result742 = _t1420 + record_span!(parser, span_start741, "Write") + return result742 end function parse_define(parser::ParserState)::Proto.Define - span_start743 = span_start(parser) + span_start744 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "define") - _t1430 = parse_fragment(parser) - fragment742 = _t1430 + _t1432 = parse_fragment(parser) + fragment743 = _t1432 consume_literal!(parser, ")") - _t1431 = Proto.Define(fragment=fragment742) - result744 = _t1431 - record_span!(parser, span_start743, "Define") - return result744 + _t1433 = Proto.Define(fragment=fragment743) + result745 = _t1433 + record_span!(parser, span_start744, "Define") + return result745 end function parse_fragment(parser::ParserState)::Proto.Fragment - span_start750 = span_start(parser) + span_start751 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "fragment") - _t1432 = parse_new_fragment_id(parser) - new_fragment_id745 = _t1432 - xs746 = Proto.Declaration[] - cond747 = match_lookahead_literal(parser, "(", 0) - while cond747 - _t1433 = parse_declaration(parser) - item748 = _t1433 - push!(xs746, item748) - cond747 = match_lookahead_literal(parser, "(", 0) + _t1434 = parse_new_fragment_id(parser) + new_fragment_id746 = _t1434 + xs747 = Proto.Declaration[] + cond748 = match_lookahead_literal(parser, "(", 0) + while cond748 + _t1435 = parse_declaration(parser) + item749 = _t1435 + push!(xs747, item749) + cond748 = match_lookahead_literal(parser, "(", 0) end - declarations749 = xs746 + declarations750 = xs747 consume_literal!(parser, ")") - result751 = construct_fragment(parser, new_fragment_id745, declarations749) - record_span!(parser, span_start750, "Fragment") - return result751 + result752 = construct_fragment(parser, new_fragment_id746, declarations750) + record_span!(parser, span_start751, "Fragment") + return result752 end function parse_new_fragment_id(parser::ParserState)::Proto.FragmentId - span_start753 = span_start(parser) - _t1434 = parse_fragment_id(parser) - fragment_id752 = _t1434 - start_fragment!(parser, fragment_id752) - result754 = fragment_id752 - record_span!(parser, span_start753, "FragmentId") - return result754 + span_start754 = span_start(parser) + _t1436 = parse_fragment_id(parser) + fragment_id753 = _t1436 + start_fragment!(parser, fragment_id753) + result755 = fragment_id753 + record_span!(parser, span_start754, "FragmentId") + return result755 end function parse_declaration(parser::ParserState)::Proto.Declaration - span_start760 = span_start(parser) + span_start761 = span_start(parser) if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "iceberg_data", 1) - _t1436 = 3 + _t1438 = 3 else if match_lookahead_literal(parser, "functional_dependency", 1) - _t1437 = 2 + _t1439 = 2 else if match_lookahead_literal(parser, "edb", 1) - _t1438 = 3 + _t1440 = 3 else if match_lookahead_literal(parser, "def", 1) - _t1439 = 0 + _t1441 = 0 else if match_lookahead_literal(parser, "csv_data", 1) - _t1440 = 3 + _t1442 = 3 else if match_lookahead_literal(parser, "betree_relation", 1) - _t1441 = 3 + _t1443 = 3 else if match_lookahead_literal(parser, "algorithm", 1) - _t1442 = 1 + _t1444 = 1 else - _t1442 = -1 + _t1444 = -1 end - _t1441 = _t1442 + _t1443 = _t1444 end - _t1440 = _t1441 + _t1442 = _t1443 end - _t1439 = _t1440 + _t1441 = _t1442 end - _t1438 = _t1439 + _t1440 = _t1441 end - _t1437 = _t1438 + _t1439 = _t1440 end - _t1436 = _t1437 + _t1438 = _t1439 end - _t1435 = _t1436 + _t1437 = _t1438 else - _t1435 = -1 + _t1437 = -1 end - prediction755 = _t1435 - if prediction755 == 3 - _t1444 = parse_data(parser) - data759 = _t1444 - _t1445 = Proto.Declaration(declaration_type=OneOf(:data, data759)) - _t1443 = _t1445 + prediction756 = _t1437 + if prediction756 == 3 + _t1446 = parse_data(parser) + data760 = _t1446 + _t1447 = Proto.Declaration(declaration_type=OneOf(:data, data760)) + _t1445 = _t1447 else - if prediction755 == 2 - _t1447 = parse_constraint(parser) - constraint758 = _t1447 - _t1448 = Proto.Declaration(declaration_type=OneOf(:constraint, constraint758)) - _t1446 = _t1448 + if prediction756 == 2 + _t1449 = parse_constraint(parser) + constraint759 = _t1449 + _t1450 = Proto.Declaration(declaration_type=OneOf(:constraint, constraint759)) + _t1448 = _t1450 else - if prediction755 == 1 - _t1450 = parse_algorithm(parser) - algorithm757 = _t1450 - _t1451 = Proto.Declaration(declaration_type=OneOf(:algorithm, algorithm757)) - _t1449 = _t1451 + if prediction756 == 1 + _t1452 = parse_algorithm(parser) + algorithm758 = _t1452 + _t1453 = Proto.Declaration(declaration_type=OneOf(:algorithm, algorithm758)) + _t1451 = _t1453 else - if prediction755 == 0 - _t1453 = parse_def(parser) - def756 = _t1453 - _t1454 = Proto.Declaration(declaration_type=OneOf(:def, def756)) - _t1452 = _t1454 + if prediction756 == 0 + _t1455 = parse_def(parser) + def757 = _t1455 + _t1456 = Proto.Declaration(declaration_type=OneOf(:def, def757)) + _t1454 = _t1456 else throw(ParseError("Unexpected token in declaration" * ": " * string(lookahead(parser, 0)))) end - _t1449 = _t1452 + _t1451 = _t1454 end - _t1446 = _t1449 + _t1448 = _t1451 end - _t1443 = _t1446 + _t1445 = _t1448 end - result761 = _t1443 - record_span!(parser, span_start760, "Declaration") - return result761 + result762 = _t1445 + record_span!(parser, span_start761, "Declaration") + return result762 end function parse_def(parser::ParserState)::Proto.Def - span_start765 = span_start(parser) + span_start766 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "def") - _t1455 = parse_relation_id(parser) - relation_id762 = _t1455 - _t1456 = parse_abstraction(parser) - abstraction763 = _t1456 + _t1457 = parse_relation_id(parser) + relation_id763 = _t1457 + _t1458 = parse_abstraction(parser) + abstraction764 = _t1458 if match_lookahead_literal(parser, "(", 0) - _t1458 = parse_attrs(parser) - _t1457 = _t1458 + _t1460 = parse_attrs(parser) + _t1459 = _t1460 else - _t1457 = nothing + _t1459 = nothing end - attrs764 = _t1457 + attrs765 = _t1459 consume_literal!(parser, ")") - _t1459 = Proto.Def(name=relation_id762, body=abstraction763, attrs=(!isnothing(attrs764) ? attrs764 : Proto.Attribute[])) - result766 = _t1459 - record_span!(parser, span_start765, "Def") - return result766 + _t1461 = Proto.Def(name=relation_id763, body=abstraction764, attrs=(!isnothing(attrs765) ? attrs765 : Proto.Attribute[])) + result767 = _t1461 + record_span!(parser, span_start766, "Def") + return result767 end function parse_relation_id(parser::ParserState)::Proto.RelationId - span_start770 = span_start(parser) + span_start771 = span_start(parser) if match_lookahead_literal(parser, ":", 0) - _t1460 = 0 + _t1462 = 0 else if match_lookahead_terminal(parser, "UINT128", 0) - _t1461 = 1 + _t1463 = 1 else - _t1461 = -1 + _t1463 = -1 end - _t1460 = _t1461 + _t1462 = _t1463 end - prediction767 = _t1460 - if prediction767 == 1 - uint128769 = consume_terminal!(parser, "UINT128") - _t1462 = Proto.RelationId(uint128769.low, uint128769.high) + prediction768 = _t1462 + if prediction768 == 1 + uint128770 = consume_terminal!(parser, "UINT128") + _t1464 = Proto.RelationId(uint128770.low, uint128770.high) else - if prediction767 == 0 + if prediction768 == 0 consume_literal!(parser, ":") - symbol768 = consume_terminal!(parser, "SYMBOL") - _t1463 = relation_id_from_string(parser, symbol768) + symbol769 = consume_terminal!(parser, "SYMBOL") + _t1465 = relation_id_from_string(parser, symbol769) else throw(ParseError("Unexpected token in relation_id" * ": " * string(lookahead(parser, 0)))) end - _t1462 = _t1463 + _t1464 = _t1465 end - result771 = _t1462 - record_span!(parser, span_start770, "RelationId") - return result771 + result772 = _t1464 + record_span!(parser, span_start771, "RelationId") + return result772 end function parse_abstraction(parser::ParserState)::Proto.Abstraction - span_start774 = span_start(parser) + span_start775 = span_start(parser) consume_literal!(parser, "(") - _t1464 = parse_bindings(parser) - bindings772 = _t1464 - _t1465 = parse_formula(parser) - formula773 = _t1465 + _t1466 = parse_bindings(parser) + bindings773 = _t1466 + _t1467 = parse_formula(parser) + formula774 = _t1467 consume_literal!(parser, ")") - _t1466 = Proto.Abstraction(vars=vcat(bindings772[1], !isnothing(bindings772[2]) ? bindings772[2] : []), value=formula773) - result775 = _t1466 - record_span!(parser, span_start774, "Abstraction") - return result775 + _t1468 = Proto.Abstraction(vars=vcat(bindings773[1], !isnothing(bindings773[2]) ? bindings773[2] : []), value=formula774) + result776 = _t1468 + record_span!(parser, span_start775, "Abstraction") + return result776 end function parse_bindings(parser::ParserState)::Tuple{Vector{Proto.Binding}, Vector{Proto.Binding}} consume_literal!(parser, "[") - xs776 = Proto.Binding[] - cond777 = match_lookahead_terminal(parser, "SYMBOL", 0) - while cond777 - _t1467 = parse_binding(parser) - item778 = _t1467 - push!(xs776, item778) - cond777 = match_lookahead_terminal(parser, "SYMBOL", 0) + xs777 = Proto.Binding[] + cond778 = match_lookahead_terminal(parser, "SYMBOL", 0) + while cond778 + _t1469 = parse_binding(parser) + item779 = _t1469 + push!(xs777, item779) + cond778 = match_lookahead_terminal(parser, "SYMBOL", 0) end - bindings779 = xs776 + bindings780 = xs777 if match_lookahead_literal(parser, "|", 0) - _t1469 = parse_value_bindings(parser) - _t1468 = _t1469 + _t1471 = parse_value_bindings(parser) + _t1470 = _t1471 else - _t1468 = nothing + _t1470 = nothing end - value_bindings780 = _t1468 + value_bindings781 = _t1470 consume_literal!(parser, "]") - return (bindings779, (!isnothing(value_bindings780) ? value_bindings780 : Proto.Binding[]),) + return (bindings780, (!isnothing(value_bindings781) ? value_bindings781 : Proto.Binding[]),) end function parse_binding(parser::ParserState)::Proto.Binding - span_start783 = span_start(parser) - symbol781 = consume_terminal!(parser, "SYMBOL") + span_start784 = span_start(parser) + symbol782 = consume_terminal!(parser, "SYMBOL") consume_literal!(parser, "::") - _t1470 = parse_type(parser) - type782 = _t1470 - _t1471 = Proto.Var(name=symbol781) - _t1472 = Proto.Binding(var=_t1471, var"#type"=type782) - result784 = _t1472 - record_span!(parser, span_start783, "Binding") - return result784 + _t1472 = parse_type(parser) + type783 = _t1472 + _t1473 = Proto.Var(name=symbol782) + _t1474 = Proto.Binding(var=_t1473, var"#type"=type783) + result785 = _t1474 + record_span!(parser, span_start784, "Binding") + return result785 end function parse_type(parser::ParserState)::Proto.var"#Type" - span_start800 = span_start(parser) + span_start801 = span_start(parser) if match_lookahead_literal(parser, "UNKNOWN", 0) - _t1473 = 0 + _t1475 = 0 else if match_lookahead_literal(parser, "UINT32", 0) - _t1474 = 13 + _t1476 = 13 else if match_lookahead_literal(parser, "UINT128", 0) - _t1475 = 4 + _t1477 = 4 else if match_lookahead_literal(parser, "STRING", 0) - _t1476 = 1 + _t1478 = 1 else if match_lookahead_literal(parser, "MISSING", 0) - _t1477 = 8 + _t1479 = 8 else if match_lookahead_literal(parser, "INT32", 0) - _t1478 = 11 + _t1480 = 11 else if match_lookahead_literal(parser, "INT128", 0) - _t1479 = 5 + _t1481 = 5 else if match_lookahead_literal(parser, "INT", 0) - _t1480 = 2 + _t1482 = 2 else if match_lookahead_literal(parser, "FLOAT32", 0) - _t1481 = 12 + _t1483 = 12 else if match_lookahead_literal(parser, "FLOAT", 0) - _t1482 = 3 + _t1484 = 3 else if match_lookahead_literal(parser, "DATETIME", 0) - _t1483 = 7 + _t1485 = 7 else if match_lookahead_literal(parser, "DATE", 0) - _t1484 = 6 + _t1486 = 6 else if match_lookahead_literal(parser, "BOOLEAN", 0) - _t1485 = 10 + _t1487 = 10 else if match_lookahead_literal(parser, "(", 0) - _t1486 = 9 + _t1488 = 9 else - _t1486 = -1 + _t1488 = -1 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 - _t1480 = _t1481 + _t1482 = _t1483 end - _t1479 = _t1480 + _t1481 = _t1482 end - _t1478 = _t1479 + _t1480 = _t1481 end - _t1477 = _t1478 + _t1479 = _t1480 end - _t1476 = _t1477 + _t1478 = _t1479 end - _t1475 = _t1476 + _t1477 = _t1478 end - _t1474 = _t1475 + _t1476 = _t1477 end - _t1473 = _t1474 + _t1475 = _t1476 end - prediction785 = _t1473 - if prediction785 == 13 - _t1488 = parse_uint32_type(parser) - uint32_type799 = _t1488 - _t1489 = Proto.var"#Type"(var"#type"=OneOf(:uint32_type, uint32_type799)) - _t1487 = _t1489 + prediction786 = _t1475 + if prediction786 == 13 + _t1490 = parse_uint32_type(parser) + uint32_type800 = _t1490 + _t1491 = Proto.var"#Type"(var"#type"=OneOf(:uint32_type, uint32_type800)) + _t1489 = _t1491 else - if prediction785 == 12 - _t1491 = parse_float32_type(parser) - float32_type798 = _t1491 - _t1492 = Proto.var"#Type"(var"#type"=OneOf(:float32_type, float32_type798)) - _t1490 = _t1492 + if prediction786 == 12 + _t1493 = parse_float32_type(parser) + float32_type799 = _t1493 + _t1494 = Proto.var"#Type"(var"#type"=OneOf(:float32_type, float32_type799)) + _t1492 = _t1494 else - if prediction785 == 11 - _t1494 = parse_int32_type(parser) - int32_type797 = _t1494 - _t1495 = Proto.var"#Type"(var"#type"=OneOf(:int32_type, int32_type797)) - _t1493 = _t1495 + if prediction786 == 11 + _t1496 = parse_int32_type(parser) + int32_type798 = _t1496 + _t1497 = Proto.var"#Type"(var"#type"=OneOf(:int32_type, int32_type798)) + _t1495 = _t1497 else - if prediction785 == 10 - _t1497 = parse_boolean_type(parser) - boolean_type796 = _t1497 - _t1498 = Proto.var"#Type"(var"#type"=OneOf(:boolean_type, boolean_type796)) - _t1496 = _t1498 + if prediction786 == 10 + _t1499 = parse_boolean_type(parser) + boolean_type797 = _t1499 + _t1500 = Proto.var"#Type"(var"#type"=OneOf(:boolean_type, boolean_type797)) + _t1498 = _t1500 else - if prediction785 == 9 - _t1500 = parse_decimal_type(parser) - decimal_type795 = _t1500 - _t1501 = Proto.var"#Type"(var"#type"=OneOf(:decimal_type, decimal_type795)) - _t1499 = _t1501 + if prediction786 == 9 + _t1502 = parse_decimal_type(parser) + decimal_type796 = _t1502 + _t1503 = Proto.var"#Type"(var"#type"=OneOf(:decimal_type, decimal_type796)) + _t1501 = _t1503 else - if prediction785 == 8 - _t1503 = parse_missing_type(parser) - missing_type794 = _t1503 - _t1504 = Proto.var"#Type"(var"#type"=OneOf(:missing_type, missing_type794)) - _t1502 = _t1504 + if prediction786 == 8 + _t1505 = parse_missing_type(parser) + missing_type795 = _t1505 + _t1506 = Proto.var"#Type"(var"#type"=OneOf(:missing_type, missing_type795)) + _t1504 = _t1506 else - if prediction785 == 7 - _t1506 = parse_datetime_type(parser) - datetime_type793 = _t1506 - _t1507 = Proto.var"#Type"(var"#type"=OneOf(:datetime_type, datetime_type793)) - _t1505 = _t1507 + if prediction786 == 7 + _t1508 = parse_datetime_type(parser) + datetime_type794 = _t1508 + _t1509 = Proto.var"#Type"(var"#type"=OneOf(:datetime_type, datetime_type794)) + _t1507 = _t1509 else - if prediction785 == 6 - _t1509 = parse_date_type(parser) - date_type792 = _t1509 - _t1510 = Proto.var"#Type"(var"#type"=OneOf(:date_type, date_type792)) - _t1508 = _t1510 + if prediction786 == 6 + _t1511 = parse_date_type(parser) + date_type793 = _t1511 + _t1512 = Proto.var"#Type"(var"#type"=OneOf(:date_type, date_type793)) + _t1510 = _t1512 else - if prediction785 == 5 - _t1512 = parse_int128_type(parser) - int128_type791 = _t1512 - _t1513 = Proto.var"#Type"(var"#type"=OneOf(:int128_type, int128_type791)) - _t1511 = _t1513 + if prediction786 == 5 + _t1514 = parse_int128_type(parser) + int128_type792 = _t1514 + _t1515 = Proto.var"#Type"(var"#type"=OneOf(:int128_type, int128_type792)) + _t1513 = _t1515 else - if prediction785 == 4 - _t1515 = parse_uint128_type(parser) - uint128_type790 = _t1515 - _t1516 = Proto.var"#Type"(var"#type"=OneOf(:uint128_type, uint128_type790)) - _t1514 = _t1516 + if prediction786 == 4 + _t1517 = parse_uint128_type(parser) + uint128_type791 = _t1517 + _t1518 = Proto.var"#Type"(var"#type"=OneOf(:uint128_type, uint128_type791)) + _t1516 = _t1518 else - if prediction785 == 3 - _t1518 = parse_float_type(parser) - float_type789 = _t1518 - _t1519 = Proto.var"#Type"(var"#type"=OneOf(:float_type, float_type789)) - _t1517 = _t1519 + if prediction786 == 3 + _t1520 = parse_float_type(parser) + float_type790 = _t1520 + _t1521 = Proto.var"#Type"(var"#type"=OneOf(:float_type, float_type790)) + _t1519 = _t1521 else - if prediction785 == 2 - _t1521 = parse_int_type(parser) - int_type788 = _t1521 - _t1522 = Proto.var"#Type"(var"#type"=OneOf(:int_type, int_type788)) - _t1520 = _t1522 + if prediction786 == 2 + _t1523 = parse_int_type(parser) + int_type789 = _t1523 + _t1524 = Proto.var"#Type"(var"#type"=OneOf(:int_type, int_type789)) + _t1522 = _t1524 else - if prediction785 == 1 - _t1524 = parse_string_type(parser) - string_type787 = _t1524 - _t1525 = Proto.var"#Type"(var"#type"=OneOf(:string_type, string_type787)) - _t1523 = _t1525 + if prediction786 == 1 + _t1526 = parse_string_type(parser) + string_type788 = _t1526 + _t1527 = Proto.var"#Type"(var"#type"=OneOf(:string_type, string_type788)) + _t1525 = _t1527 else - if prediction785 == 0 - _t1527 = parse_unspecified_type(parser) - unspecified_type786 = _t1527 - _t1528 = Proto.var"#Type"(var"#type"=OneOf(:unspecified_type, unspecified_type786)) - _t1526 = _t1528 + if prediction786 == 0 + _t1529 = parse_unspecified_type(parser) + unspecified_type787 = _t1529 + _t1530 = Proto.var"#Type"(var"#type"=OneOf(:unspecified_type, unspecified_type787)) + _t1528 = _t1530 else throw(ParseError("Unexpected token in type" * ": " * string(lookahead(parser, 0)))) end - _t1523 = _t1526 + _t1525 = _t1528 end - _t1520 = _t1523 + _t1522 = _t1525 end - _t1517 = _t1520 + _t1519 = _t1522 end - _t1514 = _t1517 + _t1516 = _t1519 end - _t1511 = _t1514 + _t1513 = _t1516 end - _t1508 = _t1511 + _t1510 = _t1513 end - _t1505 = _t1508 + _t1507 = _t1510 end - _t1502 = _t1505 + _t1504 = _t1507 end - _t1499 = _t1502 + _t1501 = _t1504 end - _t1496 = _t1499 + _t1498 = _t1501 end - _t1493 = _t1496 + _t1495 = _t1498 end - _t1490 = _t1493 + _t1492 = _t1495 end - _t1487 = _t1490 + _t1489 = _t1492 end - result801 = _t1487 - record_span!(parser, span_start800, "Type") - return result801 + result802 = _t1489 + record_span!(parser, span_start801, "Type") + return result802 end function parse_unspecified_type(parser::ParserState)::Proto.UnspecifiedType - span_start802 = span_start(parser) + span_start803 = span_start(parser) consume_literal!(parser, "UNKNOWN") - _t1529 = Proto.UnspecifiedType() - result803 = _t1529 - record_span!(parser, span_start802, "UnspecifiedType") - return result803 + _t1531 = Proto.UnspecifiedType() + result804 = _t1531 + record_span!(parser, span_start803, "UnspecifiedType") + return result804 end function parse_string_type(parser::ParserState)::Proto.StringType - span_start804 = span_start(parser) + span_start805 = span_start(parser) consume_literal!(parser, "STRING") - _t1530 = Proto.StringType() - result805 = _t1530 - record_span!(parser, span_start804, "StringType") - return result805 + _t1532 = Proto.StringType() + result806 = _t1532 + record_span!(parser, span_start805, "StringType") + return result806 end function parse_int_type(parser::ParserState)::Proto.IntType - span_start806 = span_start(parser) + span_start807 = span_start(parser) consume_literal!(parser, "INT") - _t1531 = Proto.IntType() - result807 = _t1531 - record_span!(parser, span_start806, "IntType") - return result807 + _t1533 = Proto.IntType() + result808 = _t1533 + record_span!(parser, span_start807, "IntType") + return result808 end function parse_float_type(parser::ParserState)::Proto.FloatType - span_start808 = span_start(parser) + span_start809 = span_start(parser) consume_literal!(parser, "FLOAT") - _t1532 = Proto.FloatType() - result809 = _t1532 - record_span!(parser, span_start808, "FloatType") - return result809 + _t1534 = Proto.FloatType() + result810 = _t1534 + record_span!(parser, span_start809, "FloatType") + return result810 end function parse_uint128_type(parser::ParserState)::Proto.UInt128Type - span_start810 = span_start(parser) + span_start811 = span_start(parser) consume_literal!(parser, "UINT128") - _t1533 = Proto.UInt128Type() - result811 = _t1533 - record_span!(parser, span_start810, "UInt128Type") - return result811 + _t1535 = Proto.UInt128Type() + result812 = _t1535 + record_span!(parser, span_start811, "UInt128Type") + return result812 end function parse_int128_type(parser::ParserState)::Proto.Int128Type - span_start812 = span_start(parser) + span_start813 = span_start(parser) consume_literal!(parser, "INT128") - _t1534 = Proto.Int128Type() - result813 = _t1534 - record_span!(parser, span_start812, "Int128Type") - return result813 + _t1536 = Proto.Int128Type() + result814 = _t1536 + record_span!(parser, span_start813, "Int128Type") + return result814 end function parse_date_type(parser::ParserState)::Proto.DateType - span_start814 = span_start(parser) + span_start815 = span_start(parser) consume_literal!(parser, "DATE") - _t1535 = Proto.DateType() - result815 = _t1535 - record_span!(parser, span_start814, "DateType") - return result815 + _t1537 = Proto.DateType() + result816 = _t1537 + record_span!(parser, span_start815, "DateType") + return result816 end function parse_datetime_type(parser::ParserState)::Proto.DateTimeType - span_start816 = span_start(parser) + span_start817 = span_start(parser) consume_literal!(parser, "DATETIME") - _t1536 = Proto.DateTimeType() - result817 = _t1536 - record_span!(parser, span_start816, "DateTimeType") - return result817 + _t1538 = Proto.DateTimeType() + result818 = _t1538 + record_span!(parser, span_start817, "DateTimeType") + return result818 end function parse_missing_type(parser::ParserState)::Proto.MissingType - span_start818 = span_start(parser) + span_start819 = span_start(parser) consume_literal!(parser, "MISSING") - _t1537 = Proto.MissingType() - result819 = _t1537 - record_span!(parser, span_start818, "MissingType") - return result819 + _t1539 = Proto.MissingType() + result820 = _t1539 + record_span!(parser, span_start819, "MissingType") + return result820 end function parse_decimal_type(parser::ParserState)::Proto.DecimalType - span_start822 = span_start(parser) + span_start823 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "DECIMAL") - int820 = consume_terminal!(parser, "INT") - int_3821 = consume_terminal!(parser, "INT") + int821 = consume_terminal!(parser, "INT") + int_3822 = consume_terminal!(parser, "INT") consume_literal!(parser, ")") - _t1538 = Proto.DecimalType(precision=Int32(int820), scale=Int32(int_3821)) - result823 = _t1538 - record_span!(parser, span_start822, "DecimalType") - return result823 + _t1540 = Proto.DecimalType(precision=Int32(int821), scale=Int32(int_3822)) + result824 = _t1540 + record_span!(parser, span_start823, "DecimalType") + return result824 end function parse_boolean_type(parser::ParserState)::Proto.BooleanType - span_start824 = span_start(parser) + span_start825 = span_start(parser) consume_literal!(parser, "BOOLEAN") - _t1539 = Proto.BooleanType() - result825 = _t1539 - record_span!(parser, span_start824, "BooleanType") - return result825 + _t1541 = Proto.BooleanType() + result826 = _t1541 + record_span!(parser, span_start825, "BooleanType") + return result826 end function parse_int32_type(parser::ParserState)::Proto.Int32Type - span_start826 = span_start(parser) + span_start827 = span_start(parser) consume_literal!(parser, "INT32") - _t1540 = Proto.Int32Type() - result827 = _t1540 - record_span!(parser, span_start826, "Int32Type") - return result827 + _t1542 = Proto.Int32Type() + result828 = _t1542 + record_span!(parser, span_start827, "Int32Type") + return result828 end function parse_float32_type(parser::ParserState)::Proto.Float32Type - span_start828 = span_start(parser) + span_start829 = span_start(parser) consume_literal!(parser, "FLOAT32") - _t1541 = Proto.Float32Type() - result829 = _t1541 - record_span!(parser, span_start828, "Float32Type") - return result829 + _t1543 = Proto.Float32Type() + result830 = _t1543 + record_span!(parser, span_start829, "Float32Type") + return result830 end function parse_uint32_type(parser::ParserState)::Proto.UInt32Type - span_start830 = span_start(parser) + span_start831 = span_start(parser) consume_literal!(parser, "UINT32") - _t1542 = Proto.UInt32Type() - result831 = _t1542 - record_span!(parser, span_start830, "UInt32Type") - return result831 + _t1544 = Proto.UInt32Type() + result832 = _t1544 + record_span!(parser, span_start831, "UInt32Type") + return result832 end function parse_value_bindings(parser::ParserState)::Vector{Proto.Binding} consume_literal!(parser, "|") - xs832 = Proto.Binding[] - cond833 = match_lookahead_terminal(parser, "SYMBOL", 0) - while cond833 - _t1543 = parse_binding(parser) - item834 = _t1543 - push!(xs832, item834) - cond833 = match_lookahead_terminal(parser, "SYMBOL", 0) + xs833 = Proto.Binding[] + cond834 = match_lookahead_terminal(parser, "SYMBOL", 0) + while cond834 + _t1545 = parse_binding(parser) + item835 = _t1545 + push!(xs833, item835) + cond834 = match_lookahead_terminal(parser, "SYMBOL", 0) end - bindings835 = xs832 - return bindings835 + bindings836 = xs833 + return bindings836 end function parse_formula(parser::ParserState)::Proto.Formula - span_start850 = span_start(parser) + span_start851 = span_start(parser) if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "true", 1) - _t1545 = 0 + _t1547 = 0 else if match_lookahead_literal(parser, "relatom", 1) - _t1546 = 11 + _t1548 = 11 else if match_lookahead_literal(parser, "reduce", 1) - _t1547 = 3 + _t1549 = 3 else if match_lookahead_literal(parser, "primitive", 1) - _t1548 = 10 + _t1550 = 10 else if match_lookahead_literal(parser, "pragma", 1) - _t1549 = 9 + _t1551 = 9 else if match_lookahead_literal(parser, "or", 1) - _t1550 = 5 + _t1552 = 5 else if match_lookahead_literal(parser, "not", 1) - _t1551 = 6 + _t1553 = 6 else if match_lookahead_literal(parser, "ffi", 1) - _t1552 = 7 + _t1554 = 7 else if match_lookahead_literal(parser, "false", 1) - _t1553 = 1 + _t1555 = 1 else if match_lookahead_literal(parser, "exists", 1) - _t1554 = 2 + _t1556 = 2 else if match_lookahead_literal(parser, "cast", 1) - _t1555 = 12 + _t1557 = 12 else if match_lookahead_literal(parser, "atom", 1) - _t1556 = 8 + _t1558 = 8 else if match_lookahead_literal(parser, "and", 1) - _t1557 = 4 + _t1559 = 4 else if match_lookahead_literal(parser, ">=", 1) - _t1558 = 10 + _t1560 = 10 else if match_lookahead_literal(parser, ">", 1) - _t1559 = 10 + _t1561 = 10 else if match_lookahead_literal(parser, "=", 1) - _t1560 = 10 + _t1562 = 10 else if match_lookahead_literal(parser, "<=", 1) - _t1561 = 10 + _t1563 = 10 else if match_lookahead_literal(parser, "<", 1) - _t1562 = 10 + _t1564 = 10 else if match_lookahead_literal(parser, "/", 1) - _t1563 = 10 + _t1565 = 10 else if match_lookahead_literal(parser, "-", 1) - _t1564 = 10 + _t1566 = 10 else if match_lookahead_literal(parser, "+", 1) - _t1565 = 10 + _t1567 = 10 else if match_lookahead_literal(parser, "*", 1) - _t1566 = 10 + _t1568 = 10 else - _t1566 = -1 + _t1568 = -1 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 end - _t1551 = _t1552 + _t1553 = _t1554 end - _t1550 = _t1551 + _t1552 = _t1553 end - _t1549 = _t1550 + _t1551 = _t1552 end - _t1548 = _t1549 + _t1550 = _t1551 end - _t1547 = _t1548 + _t1549 = _t1550 end - _t1546 = _t1547 + _t1548 = _t1549 end - _t1545 = _t1546 + _t1547 = _t1548 end - _t1544 = _t1545 + _t1546 = _t1547 else - _t1544 = -1 + _t1546 = -1 end - prediction836 = _t1544 - if prediction836 == 12 - _t1568 = parse_cast(parser) - cast849 = _t1568 - _t1569 = Proto.Formula(formula_type=OneOf(:cast, cast849)) - _t1567 = _t1569 + prediction837 = _t1546 + if prediction837 == 12 + _t1570 = parse_cast(parser) + cast850 = _t1570 + _t1571 = Proto.Formula(formula_type=OneOf(:cast, cast850)) + _t1569 = _t1571 else - if prediction836 == 11 - _t1571 = parse_rel_atom(parser) - rel_atom848 = _t1571 - _t1572 = Proto.Formula(formula_type=OneOf(:rel_atom, rel_atom848)) - _t1570 = _t1572 + if prediction837 == 11 + _t1573 = parse_rel_atom(parser) + rel_atom849 = _t1573 + _t1574 = Proto.Formula(formula_type=OneOf(:rel_atom, rel_atom849)) + _t1572 = _t1574 else - if prediction836 == 10 - _t1574 = parse_primitive(parser) - primitive847 = _t1574 - _t1575 = Proto.Formula(formula_type=OneOf(:primitive, primitive847)) - _t1573 = _t1575 + if prediction837 == 10 + _t1576 = parse_primitive(parser) + primitive848 = _t1576 + _t1577 = Proto.Formula(formula_type=OneOf(:primitive, primitive848)) + _t1575 = _t1577 else - if prediction836 == 9 - _t1577 = parse_pragma(parser) - pragma846 = _t1577 - _t1578 = Proto.Formula(formula_type=OneOf(:pragma, pragma846)) - _t1576 = _t1578 + if prediction837 == 9 + _t1579 = parse_pragma(parser) + pragma847 = _t1579 + _t1580 = Proto.Formula(formula_type=OneOf(:pragma, pragma847)) + _t1578 = _t1580 else - if prediction836 == 8 - _t1580 = parse_atom(parser) - atom845 = _t1580 - _t1581 = Proto.Formula(formula_type=OneOf(:atom, atom845)) - _t1579 = _t1581 + if prediction837 == 8 + _t1582 = parse_atom(parser) + atom846 = _t1582 + _t1583 = Proto.Formula(formula_type=OneOf(:atom, atom846)) + _t1581 = _t1583 else - if prediction836 == 7 - _t1583 = parse_ffi(parser) - ffi844 = _t1583 - _t1584 = Proto.Formula(formula_type=OneOf(:ffi, ffi844)) - _t1582 = _t1584 + if prediction837 == 7 + _t1585 = parse_ffi(parser) + ffi845 = _t1585 + _t1586 = Proto.Formula(formula_type=OneOf(:ffi, ffi845)) + _t1584 = _t1586 else - if prediction836 == 6 - _t1586 = parse_not(parser) - not843 = _t1586 - _t1587 = Proto.Formula(formula_type=OneOf(:not, not843)) - _t1585 = _t1587 + if prediction837 == 6 + _t1588 = parse_not(parser) + not844 = _t1588 + _t1589 = Proto.Formula(formula_type=OneOf(:not, not844)) + _t1587 = _t1589 else - if prediction836 == 5 - _t1589 = parse_disjunction(parser) - disjunction842 = _t1589 - _t1590 = Proto.Formula(formula_type=OneOf(:disjunction, disjunction842)) - _t1588 = _t1590 + if prediction837 == 5 + _t1591 = parse_disjunction(parser) + disjunction843 = _t1591 + _t1592 = Proto.Formula(formula_type=OneOf(:disjunction, disjunction843)) + _t1590 = _t1592 else - if prediction836 == 4 - _t1592 = parse_conjunction(parser) - conjunction841 = _t1592 - _t1593 = Proto.Formula(formula_type=OneOf(:conjunction, conjunction841)) - _t1591 = _t1593 + if prediction837 == 4 + _t1594 = parse_conjunction(parser) + conjunction842 = _t1594 + _t1595 = Proto.Formula(formula_type=OneOf(:conjunction, conjunction842)) + _t1593 = _t1595 else - if prediction836 == 3 - _t1595 = parse_reduce(parser) - reduce840 = _t1595 - _t1596 = Proto.Formula(formula_type=OneOf(:reduce, reduce840)) - _t1594 = _t1596 + if prediction837 == 3 + _t1597 = parse_reduce(parser) + reduce841 = _t1597 + _t1598 = Proto.Formula(formula_type=OneOf(:reduce, reduce841)) + _t1596 = _t1598 else - if prediction836 == 2 - _t1598 = parse_exists(parser) - exists839 = _t1598 - _t1599 = Proto.Formula(formula_type=OneOf(:exists, exists839)) - _t1597 = _t1599 + if prediction837 == 2 + _t1600 = parse_exists(parser) + exists840 = _t1600 + _t1601 = Proto.Formula(formula_type=OneOf(:exists, exists840)) + _t1599 = _t1601 else - if prediction836 == 1 - _t1601 = parse_false(parser) - false838 = _t1601 - _t1602 = Proto.Formula(formula_type=OneOf(:disjunction, false838)) - _t1600 = _t1602 + if prediction837 == 1 + _t1603 = parse_false(parser) + false839 = _t1603 + _t1604 = Proto.Formula(formula_type=OneOf(:disjunction, false839)) + _t1602 = _t1604 else - if prediction836 == 0 - _t1604 = parse_true(parser) - true837 = _t1604 - _t1605 = Proto.Formula(formula_type=OneOf(:conjunction, true837)) - _t1603 = _t1605 + if prediction837 == 0 + _t1606 = parse_true(parser) + true838 = _t1606 + _t1607 = Proto.Formula(formula_type=OneOf(:conjunction, true838)) + _t1605 = _t1607 else throw(ParseError("Unexpected token in formula" * ": " * string(lookahead(parser, 0)))) end - _t1600 = _t1603 + _t1602 = _t1605 end - _t1597 = _t1600 + _t1599 = _t1602 end - _t1594 = _t1597 + _t1596 = _t1599 end - _t1591 = _t1594 + _t1593 = _t1596 end - _t1588 = _t1591 + _t1590 = _t1593 end - _t1585 = _t1588 + _t1587 = _t1590 end - _t1582 = _t1585 + _t1584 = _t1587 end - _t1579 = _t1582 + _t1581 = _t1584 end - _t1576 = _t1579 + _t1578 = _t1581 end - _t1573 = _t1576 + _t1575 = _t1578 end - _t1570 = _t1573 + _t1572 = _t1575 end - _t1567 = _t1570 + _t1569 = _t1572 end - result851 = _t1567 - record_span!(parser, span_start850, "Formula") - return result851 + result852 = _t1569 + record_span!(parser, span_start851, "Formula") + return result852 end function parse_true(parser::ParserState)::Proto.Conjunction - span_start852 = span_start(parser) + span_start853 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "true") consume_literal!(parser, ")") - _t1606 = Proto.Conjunction(args=Proto.Formula[]) - result853 = _t1606 - record_span!(parser, span_start852, "Conjunction") - return result853 + _t1608 = Proto.Conjunction(args=Proto.Formula[]) + result854 = _t1608 + record_span!(parser, span_start853, "Conjunction") + return result854 end function parse_false(parser::ParserState)::Proto.Disjunction - span_start854 = span_start(parser) + span_start855 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "false") consume_literal!(parser, ")") - _t1607 = Proto.Disjunction(args=Proto.Formula[]) - result855 = _t1607 - record_span!(parser, span_start854, "Disjunction") - return result855 + _t1609 = Proto.Disjunction(args=Proto.Formula[]) + result856 = _t1609 + record_span!(parser, span_start855, "Disjunction") + return result856 end function parse_exists(parser::ParserState)::Proto.Exists - span_start858 = span_start(parser) + span_start859 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "exists") - _t1608 = parse_bindings(parser) - bindings856 = _t1608 - _t1609 = parse_formula(parser) - formula857 = _t1609 + _t1610 = parse_bindings(parser) + bindings857 = _t1610 + _t1611 = parse_formula(parser) + formula858 = _t1611 consume_literal!(parser, ")") - _t1610 = Proto.Abstraction(vars=vcat(bindings856[1], !isnothing(bindings856[2]) ? bindings856[2] : []), value=formula857) - _t1611 = Proto.Exists(body=_t1610) - result859 = _t1611 - record_span!(parser, span_start858, "Exists") - return result859 + _t1612 = Proto.Abstraction(vars=vcat(bindings857[1], !isnothing(bindings857[2]) ? bindings857[2] : []), value=formula858) + _t1613 = Proto.Exists(body=_t1612) + result860 = _t1613 + record_span!(parser, span_start859, "Exists") + return result860 end function parse_reduce(parser::ParserState)::Proto.Reduce - span_start863 = span_start(parser) + span_start864 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "reduce") - _t1612 = parse_abstraction(parser) - abstraction860 = _t1612 - _t1613 = parse_abstraction(parser) - abstraction_3861 = _t1613 - _t1614 = parse_terms(parser) - terms862 = _t1614 + _t1614 = parse_abstraction(parser) + abstraction861 = _t1614 + _t1615 = parse_abstraction(parser) + abstraction_3862 = _t1615 + _t1616 = parse_terms(parser) + terms863 = _t1616 consume_literal!(parser, ")") - _t1615 = Proto.Reduce(op=abstraction860, body=abstraction_3861, terms=terms862) - result864 = _t1615 - record_span!(parser, span_start863, "Reduce") - return result864 + _t1617 = Proto.Reduce(op=abstraction861, body=abstraction_3862, terms=terms863) + result865 = _t1617 + record_span!(parser, span_start864, "Reduce") + return result865 end function parse_terms(parser::ParserState)::Vector{Proto.Term} consume_literal!(parser, "(") consume_literal!(parser, "terms") - xs865 = Proto.Term[] - cond866 = (((((((((((((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 cond866 - _t1616 = parse_term(parser) - item867 = _t1616 - push!(xs865, item867) - cond866 = (((((((((((((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)) + xs866 = Proto.Term[] + cond867 = (((((((((((((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 cond867 + _t1618 = parse_term(parser) + item868 = _t1618 + push!(xs866, item868) + cond867 = (((((((((((((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 - terms868 = xs865 + terms869 = xs866 consume_literal!(parser, ")") - return terms868 + return terms869 end function parse_term(parser::ParserState)::Proto.Term - span_start872 = span_start(parser) + span_start873 = span_start(parser) if match_lookahead_literal(parser, "true", 0) - _t1617 = 1 + _t1619 = 1 else if match_lookahead_literal(parser, "missing", 0) - _t1618 = 1 + _t1620 = 1 else if match_lookahead_literal(parser, "false", 0) - _t1619 = 1 + _t1621 = 1 else if match_lookahead_literal(parser, "(", 0) - _t1620 = 1 + _t1622 = 1 else if match_lookahead_terminal(parser, "SYMBOL", 0) - _t1621 = 0 + _t1623 = 0 else if match_lookahead_terminal(parser, "UINT32", 0) - _t1622 = 1 + _t1624 = 1 else if match_lookahead_terminal(parser, "UINT128", 0) - _t1623 = 1 + _t1625 = 1 else if match_lookahead_terminal(parser, "STRING", 0) - _t1624 = 1 + _t1626 = 1 else if match_lookahead_terminal(parser, "INT32", 0) - _t1625 = 1 + _t1627 = 1 else if match_lookahead_terminal(parser, "INT128", 0) - _t1626 = 1 + _t1628 = 1 else if match_lookahead_terminal(parser, "INT", 0) - _t1627 = 1 + _t1629 = 1 else if match_lookahead_terminal(parser, "FLOAT32", 0) - _t1628 = 1 + _t1630 = 1 else if match_lookahead_terminal(parser, "FLOAT", 0) - _t1629 = 1 + _t1631 = 1 else if match_lookahead_terminal(parser, "DECIMAL", 0) - _t1630 = 1 + _t1632 = 1 else - _t1630 = -1 + _t1632 = -1 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 - _t1624 = _t1625 + _t1626 = _t1627 end - _t1623 = _t1624 + _t1625 = _t1626 end - _t1622 = _t1623 + _t1624 = _t1625 end - _t1621 = _t1622 + _t1623 = _t1624 end - _t1620 = _t1621 + _t1622 = _t1623 end - _t1619 = _t1620 + _t1621 = _t1622 end - _t1618 = _t1619 + _t1620 = _t1621 end - _t1617 = _t1618 + _t1619 = _t1620 end - prediction869 = _t1617 - if prediction869 == 1 - _t1632 = parse_value(parser) - value871 = _t1632 - _t1633 = Proto.Term(term_type=OneOf(:constant, value871)) - _t1631 = _t1633 + prediction870 = _t1619 + if prediction870 == 1 + _t1634 = parse_value(parser) + value872 = _t1634 + _t1635 = Proto.Term(term_type=OneOf(:constant, value872)) + _t1633 = _t1635 else - if prediction869 == 0 - _t1635 = parse_var(parser) - var870 = _t1635 - _t1636 = Proto.Term(term_type=OneOf(:var, var870)) - _t1634 = _t1636 + if prediction870 == 0 + _t1637 = parse_var(parser) + var871 = _t1637 + _t1638 = Proto.Term(term_type=OneOf(:var, var871)) + _t1636 = _t1638 else throw(ParseError("Unexpected token in term" * ": " * string(lookahead(parser, 0)))) end - _t1631 = _t1634 + _t1633 = _t1636 end - result873 = _t1631 - record_span!(parser, span_start872, "Term") - return result873 + result874 = _t1633 + record_span!(parser, span_start873, "Term") + return result874 end function parse_var(parser::ParserState)::Proto.Var - span_start875 = span_start(parser) - symbol874 = consume_terminal!(parser, "SYMBOL") - _t1637 = Proto.Var(name=symbol874) - result876 = _t1637 - record_span!(parser, span_start875, "Var") - return result876 + span_start876 = span_start(parser) + symbol875 = consume_terminal!(parser, "SYMBOL") + _t1639 = Proto.Var(name=symbol875) + result877 = _t1639 + record_span!(parser, span_start876, "Var") + return result877 end function parse_value(parser::ParserState)::Proto.Value - span_start890 = span_start(parser) + span_start891 = span_start(parser) if match_lookahead_literal(parser, "true", 0) - _t1638 = 12 + _t1640 = 12 else if match_lookahead_literal(parser, "missing", 0) - _t1639 = 11 + _t1641 = 11 else if match_lookahead_literal(parser, "false", 0) - _t1640 = 12 + _t1642 = 12 else if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "datetime", 1) - _t1642 = 1 + _t1644 = 1 else if match_lookahead_literal(parser, "date", 1) - _t1643 = 0 + _t1645 = 0 else - _t1643 = -1 + _t1645 = -1 end - _t1642 = _t1643 + _t1644 = _t1645 end - _t1641 = _t1642 + _t1643 = _t1644 else if match_lookahead_terminal(parser, "UINT32", 0) - _t1644 = 7 + _t1646 = 7 else if match_lookahead_terminal(parser, "UINT128", 0) - _t1645 = 8 + _t1647 = 8 else if match_lookahead_terminal(parser, "STRING", 0) - _t1646 = 2 + _t1648 = 2 else if match_lookahead_terminal(parser, "INT32", 0) - _t1647 = 3 + _t1649 = 3 else if match_lookahead_terminal(parser, "INT128", 0) - _t1648 = 9 + _t1650 = 9 else if match_lookahead_terminal(parser, "INT", 0) - _t1649 = 4 + _t1651 = 4 else if match_lookahead_terminal(parser, "FLOAT32", 0) - _t1650 = 5 + _t1652 = 5 else if match_lookahead_terminal(parser, "FLOAT", 0) - _t1651 = 6 + _t1653 = 6 else if match_lookahead_terminal(parser, "DECIMAL", 0) - _t1652 = 10 + _t1654 = 10 else - _t1652 = -1 + _t1654 = -1 end - _t1651 = _t1652 + _t1653 = _t1654 end - _t1650 = _t1651 + _t1652 = _t1653 end - _t1649 = _t1650 + _t1651 = _t1652 end - _t1648 = _t1649 + _t1650 = _t1651 end - _t1647 = _t1648 + _t1649 = _t1650 end - _t1646 = _t1647 + _t1648 = _t1649 end - _t1645 = _t1646 + _t1647 = _t1648 end - _t1644 = _t1645 + _t1646 = _t1647 end - _t1641 = _t1644 + _t1643 = _t1646 end - _t1640 = _t1641 + _t1642 = _t1643 end - _t1639 = _t1640 + _t1641 = _t1642 end - _t1638 = _t1639 + _t1640 = _t1641 end - prediction877 = _t1638 - if prediction877 == 12 - _t1654 = parse_boolean_value(parser) - boolean_value889 = _t1654 - _t1655 = Proto.Value(value=OneOf(:boolean_value, boolean_value889)) - _t1653 = _t1655 + prediction878 = _t1640 + if prediction878 == 12 + _t1656 = parse_boolean_value(parser) + boolean_value890 = _t1656 + _t1657 = Proto.Value(value=OneOf(:boolean_value, boolean_value890)) + _t1655 = _t1657 else - if prediction877 == 11 + if prediction878 == 11 consume_literal!(parser, "missing") - _t1657 = Proto.MissingValue() - _t1658 = Proto.Value(value=OneOf(:missing_value, _t1657)) - _t1656 = _t1658 + _t1659 = Proto.MissingValue() + _t1660 = Proto.Value(value=OneOf(:missing_value, _t1659)) + _t1658 = _t1660 else - if prediction877 == 10 - formatted_decimal888 = consume_terminal!(parser, "DECIMAL") - _t1660 = Proto.Value(value=OneOf(:decimal_value, formatted_decimal888)) - _t1659 = _t1660 + if prediction878 == 10 + formatted_decimal889 = consume_terminal!(parser, "DECIMAL") + _t1662 = Proto.Value(value=OneOf(:decimal_value, formatted_decimal889)) + _t1661 = _t1662 else - if prediction877 == 9 - formatted_int128887 = consume_terminal!(parser, "INT128") - _t1662 = Proto.Value(value=OneOf(:int128_value, formatted_int128887)) - _t1661 = _t1662 + if prediction878 == 9 + formatted_int128888 = consume_terminal!(parser, "INT128") + _t1664 = Proto.Value(value=OneOf(:int128_value, formatted_int128888)) + _t1663 = _t1664 else - if prediction877 == 8 - formatted_uint128886 = consume_terminal!(parser, "UINT128") - _t1664 = Proto.Value(value=OneOf(:uint128_value, formatted_uint128886)) - _t1663 = _t1664 + if prediction878 == 8 + formatted_uint128887 = consume_terminal!(parser, "UINT128") + _t1666 = Proto.Value(value=OneOf(:uint128_value, formatted_uint128887)) + _t1665 = _t1666 else - if prediction877 == 7 - formatted_uint32885 = consume_terminal!(parser, "UINT32") - _t1666 = Proto.Value(value=OneOf(:uint32_value, formatted_uint32885)) - _t1665 = _t1666 + if prediction878 == 7 + formatted_uint32886 = consume_terminal!(parser, "UINT32") + _t1668 = Proto.Value(value=OneOf(:uint32_value, formatted_uint32886)) + _t1667 = _t1668 else - if prediction877 == 6 - formatted_float884 = consume_terminal!(parser, "FLOAT") - _t1668 = Proto.Value(value=OneOf(:float_value, formatted_float884)) - _t1667 = _t1668 + if prediction878 == 6 + formatted_float885 = consume_terminal!(parser, "FLOAT") + _t1670 = Proto.Value(value=OneOf(:float_value, formatted_float885)) + _t1669 = _t1670 else - if prediction877 == 5 - formatted_float32883 = consume_terminal!(parser, "FLOAT32") - _t1670 = Proto.Value(value=OneOf(:float32_value, formatted_float32883)) - _t1669 = _t1670 + if prediction878 == 5 + formatted_float32884 = consume_terminal!(parser, "FLOAT32") + _t1672 = Proto.Value(value=OneOf(:float32_value, formatted_float32884)) + _t1671 = _t1672 else - if prediction877 == 4 - formatted_int882 = consume_terminal!(parser, "INT") - _t1672 = Proto.Value(value=OneOf(:int_value, formatted_int882)) - _t1671 = _t1672 + if prediction878 == 4 + formatted_int883 = consume_terminal!(parser, "INT") + _t1674 = Proto.Value(value=OneOf(:int_value, formatted_int883)) + _t1673 = _t1674 else - if prediction877 == 3 - formatted_int32881 = consume_terminal!(parser, "INT32") - _t1674 = Proto.Value(value=OneOf(:int32_value, formatted_int32881)) - _t1673 = _t1674 + if prediction878 == 3 + formatted_int32882 = consume_terminal!(parser, "INT32") + _t1676 = Proto.Value(value=OneOf(:int32_value, formatted_int32882)) + _t1675 = _t1676 else - if prediction877 == 2 - formatted_string880 = consume_terminal!(parser, "STRING") - _t1676 = Proto.Value(value=OneOf(:string_value, formatted_string880)) - _t1675 = _t1676 + if prediction878 == 2 + formatted_string881 = consume_terminal!(parser, "STRING") + _t1678 = Proto.Value(value=OneOf(:string_value, formatted_string881)) + _t1677 = _t1678 else - if prediction877 == 1 - _t1678 = parse_datetime(parser) - datetime879 = _t1678 - _t1679 = Proto.Value(value=OneOf(:datetime_value, datetime879)) - _t1677 = _t1679 + if prediction878 == 1 + _t1680 = parse_datetime(parser) + datetime880 = _t1680 + _t1681 = Proto.Value(value=OneOf(:datetime_value, datetime880)) + _t1679 = _t1681 else - if prediction877 == 0 - _t1681 = parse_date(parser) - date878 = _t1681 - _t1682 = Proto.Value(value=OneOf(:date_value, date878)) - _t1680 = _t1682 + if prediction878 == 0 + _t1683 = parse_date(parser) + date879 = _t1683 + _t1684 = Proto.Value(value=OneOf(:date_value, date879)) + _t1682 = _t1684 else throw(ParseError("Unexpected token in value" * ": " * string(lookahead(parser, 0)))) end - _t1677 = _t1680 + _t1679 = _t1682 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 - _t1665 = _t1667 + _t1667 = _t1669 end - _t1663 = _t1665 + _t1665 = _t1667 end - _t1661 = _t1663 + _t1663 = _t1665 end - _t1659 = _t1661 + _t1661 = _t1663 end - _t1656 = _t1659 + _t1658 = _t1661 end - _t1653 = _t1656 + _t1655 = _t1658 end - result891 = _t1653 - record_span!(parser, span_start890, "Value") - return result891 + result892 = _t1655 + record_span!(parser, span_start891, "Value") + return result892 end function parse_date(parser::ParserState)::Proto.DateValue - span_start895 = span_start(parser) + span_start896 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "date") - formatted_int892 = consume_terminal!(parser, "INT") - formatted_int_3893 = consume_terminal!(parser, "INT") - formatted_int_4894 = consume_terminal!(parser, "INT") + formatted_int893 = consume_terminal!(parser, "INT") + formatted_int_3894 = consume_terminal!(parser, "INT") + formatted_int_4895 = consume_terminal!(parser, "INT") consume_literal!(parser, ")") - _t1683 = Proto.DateValue(year=Int32(formatted_int892), month=Int32(formatted_int_3893), day=Int32(formatted_int_4894)) - result896 = _t1683 - record_span!(parser, span_start895, "DateValue") - return result896 + _t1685 = Proto.DateValue(year=Int32(formatted_int893), month=Int32(formatted_int_3894), day=Int32(formatted_int_4895)) + result897 = _t1685 + record_span!(parser, span_start896, "DateValue") + return result897 end function parse_datetime(parser::ParserState)::Proto.DateTimeValue - span_start904 = span_start(parser) + span_start905 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "datetime") - formatted_int897 = consume_terminal!(parser, "INT") - formatted_int_3898 = consume_terminal!(parser, "INT") - formatted_int_4899 = consume_terminal!(parser, "INT") - formatted_int_5900 = consume_terminal!(parser, "INT") - formatted_int_6901 = consume_terminal!(parser, "INT") - formatted_int_7902 = consume_terminal!(parser, "INT") + formatted_int898 = consume_terminal!(parser, "INT") + formatted_int_3899 = consume_terminal!(parser, "INT") + formatted_int_4900 = consume_terminal!(parser, "INT") + formatted_int_5901 = consume_terminal!(parser, "INT") + formatted_int_6902 = consume_terminal!(parser, "INT") + formatted_int_7903 = consume_terminal!(parser, "INT") if match_lookahead_terminal(parser, "INT", 0) - _t1684 = consume_terminal!(parser, "INT") + _t1686 = consume_terminal!(parser, "INT") else - _t1684 = nothing + _t1686 = nothing end - formatted_int_8903 = _t1684 + formatted_int_8904 = _t1686 consume_literal!(parser, ")") - _t1685 = Proto.DateTimeValue(year=Int32(formatted_int897), month=Int32(formatted_int_3898), day=Int32(formatted_int_4899), hour=Int32(formatted_int_5900), minute=Int32(formatted_int_6901), second=Int32(formatted_int_7902), microsecond=Int32((!isnothing(formatted_int_8903) ? formatted_int_8903 : 0))) - result905 = _t1685 - record_span!(parser, span_start904, "DateTimeValue") - return result905 + _t1687 = Proto.DateTimeValue(year=Int32(formatted_int898), month=Int32(formatted_int_3899), day=Int32(formatted_int_4900), hour=Int32(formatted_int_5901), minute=Int32(formatted_int_6902), second=Int32(formatted_int_7903), microsecond=Int32((!isnothing(formatted_int_8904) ? formatted_int_8904 : 0))) + result906 = _t1687 + record_span!(parser, span_start905, "DateTimeValue") + return result906 end function parse_conjunction(parser::ParserState)::Proto.Conjunction - span_start910 = span_start(parser) + span_start911 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "and") - xs906 = Proto.Formula[] - cond907 = match_lookahead_literal(parser, "(", 0) - while cond907 - _t1686 = parse_formula(parser) - item908 = _t1686 - push!(xs906, item908) - cond907 = match_lookahead_literal(parser, "(", 0) + xs907 = Proto.Formula[] + cond908 = match_lookahead_literal(parser, "(", 0) + while cond908 + _t1688 = parse_formula(parser) + item909 = _t1688 + push!(xs907, item909) + cond908 = match_lookahead_literal(parser, "(", 0) end - formulas909 = xs906 + formulas910 = xs907 consume_literal!(parser, ")") - _t1687 = Proto.Conjunction(args=formulas909) - result911 = _t1687 - record_span!(parser, span_start910, "Conjunction") - return result911 + _t1689 = Proto.Conjunction(args=formulas910) + result912 = _t1689 + record_span!(parser, span_start911, "Conjunction") + return result912 end function parse_disjunction(parser::ParserState)::Proto.Disjunction - span_start916 = span_start(parser) + span_start917 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "or") - xs912 = Proto.Formula[] - cond913 = match_lookahead_literal(parser, "(", 0) - while cond913 - _t1688 = parse_formula(parser) - item914 = _t1688 - push!(xs912, item914) - cond913 = match_lookahead_literal(parser, "(", 0) + xs913 = Proto.Formula[] + cond914 = match_lookahead_literal(parser, "(", 0) + while cond914 + _t1690 = parse_formula(parser) + item915 = _t1690 + push!(xs913, item915) + cond914 = match_lookahead_literal(parser, "(", 0) end - formulas915 = xs912 + formulas916 = xs913 consume_literal!(parser, ")") - _t1689 = Proto.Disjunction(args=formulas915) - result917 = _t1689 - record_span!(parser, span_start916, "Disjunction") - return result917 + _t1691 = Proto.Disjunction(args=formulas916) + result918 = _t1691 + record_span!(parser, span_start917, "Disjunction") + return result918 end function parse_not(parser::ParserState)::Proto.Not - span_start919 = span_start(parser) + span_start920 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "not") - _t1690 = parse_formula(parser) - formula918 = _t1690 + _t1692 = parse_formula(parser) + formula919 = _t1692 consume_literal!(parser, ")") - _t1691 = Proto.Not(arg=formula918) - result920 = _t1691 - record_span!(parser, span_start919, "Not") - return result920 + _t1693 = Proto.Not(arg=formula919) + result921 = _t1693 + record_span!(parser, span_start920, "Not") + return result921 end function parse_ffi(parser::ParserState)::Proto.FFI - span_start924 = span_start(parser) + span_start925 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "ffi") - _t1692 = parse_name(parser) - name921 = _t1692 - _t1693 = parse_ffi_args(parser) - ffi_args922 = _t1693 - _t1694 = parse_terms(parser) - terms923 = _t1694 + _t1694 = parse_name(parser) + name922 = _t1694 + _t1695 = parse_ffi_args(parser) + ffi_args923 = _t1695 + _t1696 = parse_terms(parser) + terms924 = _t1696 consume_literal!(parser, ")") - _t1695 = Proto.FFI(name=name921, args=ffi_args922, terms=terms923) - result925 = _t1695 - record_span!(parser, span_start924, "FFI") - return result925 + _t1697 = Proto.FFI(name=name922, args=ffi_args923, terms=terms924) + result926 = _t1697 + record_span!(parser, span_start925, "FFI") + return result926 end function parse_name(parser::ParserState)::String consume_literal!(parser, ":") - symbol926 = consume_terminal!(parser, "SYMBOL") - return symbol926 + symbol927 = consume_terminal!(parser, "SYMBOL") + return symbol927 end function parse_ffi_args(parser::ParserState)::Vector{Proto.Abstraction} consume_literal!(parser, "(") consume_literal!(parser, "args") - xs927 = Proto.Abstraction[] - cond928 = match_lookahead_literal(parser, "(", 0) - while cond928 - _t1696 = parse_abstraction(parser) - item929 = _t1696 - push!(xs927, item929) - cond928 = match_lookahead_literal(parser, "(", 0) + xs928 = Proto.Abstraction[] + cond929 = match_lookahead_literal(parser, "(", 0) + while cond929 + _t1698 = parse_abstraction(parser) + item930 = _t1698 + push!(xs928, item930) + cond929 = match_lookahead_literal(parser, "(", 0) end - abstractions930 = xs927 + abstractions931 = xs928 consume_literal!(parser, ")") - return abstractions930 + return abstractions931 end function parse_atom(parser::ParserState)::Proto.Atom - span_start936 = span_start(parser) + span_start937 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "atom") - _t1697 = parse_relation_id(parser) - relation_id931 = _t1697 - xs932 = Proto.Term[] - cond933 = (((((((((((((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 cond933 - _t1698 = parse_term(parser) - item934 = _t1698 - push!(xs932, item934) - cond933 = (((((((((((((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)) + _t1699 = parse_relation_id(parser) + relation_id932 = _t1699 + xs933 = Proto.Term[] + cond934 = (((((((((((((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 cond934 + _t1700 = parse_term(parser) + item935 = _t1700 + push!(xs933, item935) + cond934 = (((((((((((((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 - terms935 = xs932 + terms936 = xs933 consume_literal!(parser, ")") - _t1699 = Proto.Atom(name=relation_id931, terms=terms935) - result937 = _t1699 - record_span!(parser, span_start936, "Atom") - return result937 + _t1701 = Proto.Atom(name=relation_id932, terms=terms936) + result938 = _t1701 + record_span!(parser, span_start937, "Atom") + return result938 end function parse_pragma(parser::ParserState)::Proto.Pragma - span_start943 = span_start(parser) + span_start944 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "pragma") - _t1700 = parse_name(parser) - name938 = _t1700 - xs939 = Proto.Term[] - cond940 = (((((((((((((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 cond940 - _t1701 = parse_term(parser) - item941 = _t1701 - push!(xs939, item941) - cond940 = (((((((((((((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)) + _t1702 = parse_name(parser) + name939 = _t1702 + xs940 = Proto.Term[] + cond941 = (((((((((((((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 cond941 + _t1703 = parse_term(parser) + item942 = _t1703 + push!(xs940, item942) + cond941 = (((((((((((((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 - terms942 = xs939 + terms943 = xs940 consume_literal!(parser, ")") - _t1702 = Proto.Pragma(name=name938, terms=terms942) - result944 = _t1702 - record_span!(parser, span_start943, "Pragma") - return result944 + _t1704 = Proto.Pragma(name=name939, terms=terms943) + result945 = _t1704 + record_span!(parser, span_start944, "Pragma") + return result945 end function parse_primitive(parser::ParserState)::Proto.Primitive - span_start960 = span_start(parser) + span_start961 = span_start(parser) if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "primitive", 1) - _t1704 = 9 + _t1706 = 9 else if match_lookahead_literal(parser, ">=", 1) - _t1705 = 4 + _t1707 = 4 else if match_lookahead_literal(parser, ">", 1) - _t1706 = 3 + _t1708 = 3 else if match_lookahead_literal(parser, "=", 1) - _t1707 = 0 + _t1709 = 0 else if match_lookahead_literal(parser, "<=", 1) - _t1708 = 2 + _t1710 = 2 else if match_lookahead_literal(parser, "<", 1) - _t1709 = 1 + _t1711 = 1 else if match_lookahead_literal(parser, "/", 1) - _t1710 = 8 + _t1712 = 8 else if match_lookahead_literal(parser, "-", 1) - _t1711 = 6 + _t1713 = 6 else if match_lookahead_literal(parser, "+", 1) - _t1712 = 5 + _t1714 = 5 else if match_lookahead_literal(parser, "*", 1) - _t1713 = 7 + _t1715 = 7 else - _t1713 = -1 + _t1715 = -1 end - _t1712 = _t1713 + _t1714 = _t1715 end - _t1711 = _t1712 + _t1713 = _t1714 end - _t1710 = _t1711 + _t1712 = _t1713 end - _t1709 = _t1710 + _t1711 = _t1712 end - _t1708 = _t1709 + _t1710 = _t1711 end - _t1707 = _t1708 + _t1709 = _t1710 end - _t1706 = _t1707 + _t1708 = _t1709 end - _t1705 = _t1706 + _t1707 = _t1708 end - _t1704 = _t1705 + _t1706 = _t1707 end - _t1703 = _t1704 + _t1705 = _t1706 else - _t1703 = -1 + _t1705 = -1 end - prediction945 = _t1703 - if prediction945 == 9 + prediction946 = _t1705 + if prediction946 == 9 consume_literal!(parser, "(") consume_literal!(parser, "primitive") - _t1715 = parse_name(parser) - name955 = _t1715 - xs956 = Proto.RelTerm[] - cond957 = ((((((((((((((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 cond957 - _t1716 = parse_rel_term(parser) - item958 = _t1716 - push!(xs956, item958) - cond957 = ((((((((((((((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)) + _t1717 = parse_name(parser) + name956 = _t1717 + xs957 = Proto.RelTerm[] + cond958 = ((((((((((((((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 cond958 + _t1718 = parse_rel_term(parser) + item959 = _t1718 + push!(xs957, item959) + cond958 = ((((((((((((((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_terms959 = xs956 + rel_terms960 = xs957 consume_literal!(parser, ")") - _t1717 = Proto.Primitive(name=name955, terms=rel_terms959) - _t1714 = _t1717 + _t1719 = Proto.Primitive(name=name956, terms=rel_terms960) + _t1716 = _t1719 else - if prediction945 == 8 - _t1719 = parse_divide(parser) - divide954 = _t1719 - _t1718 = divide954 + if prediction946 == 8 + _t1721 = parse_divide(parser) + divide955 = _t1721 + _t1720 = divide955 else - if prediction945 == 7 - _t1721 = parse_multiply(parser) - multiply953 = _t1721 - _t1720 = multiply953 + if prediction946 == 7 + _t1723 = parse_multiply(parser) + multiply954 = _t1723 + _t1722 = multiply954 else - if prediction945 == 6 - _t1723 = parse_minus(parser) - minus952 = _t1723 - _t1722 = minus952 + if prediction946 == 6 + _t1725 = parse_minus(parser) + minus953 = _t1725 + _t1724 = minus953 else - if prediction945 == 5 - _t1725 = parse_add(parser) - add951 = _t1725 - _t1724 = add951 + if prediction946 == 5 + _t1727 = parse_add(parser) + add952 = _t1727 + _t1726 = add952 else - if prediction945 == 4 - _t1727 = parse_gt_eq(parser) - gt_eq950 = _t1727 - _t1726 = gt_eq950 + if prediction946 == 4 + _t1729 = parse_gt_eq(parser) + gt_eq951 = _t1729 + _t1728 = gt_eq951 else - if prediction945 == 3 - _t1729 = parse_gt(parser) - gt949 = _t1729 - _t1728 = gt949 + if prediction946 == 3 + _t1731 = parse_gt(parser) + gt950 = _t1731 + _t1730 = gt950 else - if prediction945 == 2 - _t1731 = parse_lt_eq(parser) - lt_eq948 = _t1731 - _t1730 = lt_eq948 + if prediction946 == 2 + _t1733 = parse_lt_eq(parser) + lt_eq949 = _t1733 + _t1732 = lt_eq949 else - if prediction945 == 1 - _t1733 = parse_lt(parser) - lt947 = _t1733 - _t1732 = lt947 + if prediction946 == 1 + _t1735 = parse_lt(parser) + lt948 = _t1735 + _t1734 = lt948 else - if prediction945 == 0 - _t1735 = parse_eq(parser) - eq946 = _t1735 - _t1734 = eq946 + if prediction946 == 0 + _t1737 = parse_eq(parser) + eq947 = _t1737 + _t1736 = eq947 else throw(ParseError("Unexpected token in primitive" * ": " * string(lookahead(parser, 0)))) end - _t1732 = _t1734 + _t1734 = _t1736 end - _t1730 = _t1732 + _t1732 = _t1734 end - _t1728 = _t1730 + _t1730 = _t1732 end - _t1726 = _t1728 + _t1728 = _t1730 end - _t1724 = _t1726 + _t1726 = _t1728 end - _t1722 = _t1724 + _t1724 = _t1726 end - _t1720 = _t1722 + _t1722 = _t1724 end - _t1718 = _t1720 + _t1720 = _t1722 end - _t1714 = _t1718 + _t1716 = _t1720 end - result961 = _t1714 - record_span!(parser, span_start960, "Primitive") - return result961 + result962 = _t1716 + record_span!(parser, span_start961, "Primitive") + return result962 end function parse_eq(parser::ParserState)::Proto.Primitive - span_start964 = span_start(parser) + span_start965 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "=") - _t1736 = parse_term(parser) - term962 = _t1736 - _t1737 = parse_term(parser) - term_3963 = _t1737 + _t1738 = parse_term(parser) + term963 = _t1738 + _t1739 = parse_term(parser) + term_3964 = _t1739 consume_literal!(parser, ")") - _t1738 = Proto.RelTerm(rel_term_type=OneOf(:term, term962)) - _t1739 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3963)) - _t1740 = Proto.Primitive(name="rel_primitive_eq", terms=Proto.RelTerm[_t1738, _t1739]) - result965 = _t1740 - record_span!(parser, span_start964, "Primitive") - return result965 + _t1740 = Proto.RelTerm(rel_term_type=OneOf(:term, term963)) + _t1741 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3964)) + _t1742 = Proto.Primitive(name="rel_primitive_eq", terms=Proto.RelTerm[_t1740, _t1741]) + result966 = _t1742 + record_span!(parser, span_start965, "Primitive") + return result966 end function parse_lt(parser::ParserState)::Proto.Primitive - span_start968 = span_start(parser) + span_start969 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "<") - _t1741 = parse_term(parser) - term966 = _t1741 - _t1742 = parse_term(parser) - term_3967 = _t1742 + _t1743 = parse_term(parser) + term967 = _t1743 + _t1744 = parse_term(parser) + term_3968 = _t1744 consume_literal!(parser, ")") - _t1743 = Proto.RelTerm(rel_term_type=OneOf(:term, term966)) - _t1744 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3967)) - _t1745 = Proto.Primitive(name="rel_primitive_lt_monotype", terms=Proto.RelTerm[_t1743, _t1744]) - result969 = _t1745 - record_span!(parser, span_start968, "Primitive") - return result969 + _t1745 = Proto.RelTerm(rel_term_type=OneOf(:term, term967)) + _t1746 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3968)) + _t1747 = Proto.Primitive(name="rel_primitive_lt_monotype", terms=Proto.RelTerm[_t1745, _t1746]) + result970 = _t1747 + record_span!(parser, span_start969, "Primitive") + return result970 end function parse_lt_eq(parser::ParserState)::Proto.Primitive - span_start972 = span_start(parser) + span_start973 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "<=") - _t1746 = parse_term(parser) - term970 = _t1746 - _t1747 = parse_term(parser) - term_3971 = _t1747 + _t1748 = parse_term(parser) + term971 = _t1748 + _t1749 = parse_term(parser) + term_3972 = _t1749 consume_literal!(parser, ")") - _t1748 = Proto.RelTerm(rel_term_type=OneOf(:term, term970)) - _t1749 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3971)) - _t1750 = Proto.Primitive(name="rel_primitive_lt_eq_monotype", terms=Proto.RelTerm[_t1748, _t1749]) - result973 = _t1750 - record_span!(parser, span_start972, "Primitive") - return result973 + _t1750 = Proto.RelTerm(rel_term_type=OneOf(:term, term971)) + _t1751 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3972)) + _t1752 = Proto.Primitive(name="rel_primitive_lt_eq_monotype", terms=Proto.RelTerm[_t1750, _t1751]) + result974 = _t1752 + record_span!(parser, span_start973, "Primitive") + return result974 end function parse_gt(parser::ParserState)::Proto.Primitive - span_start976 = span_start(parser) + span_start977 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, ">") - _t1751 = parse_term(parser) - term974 = _t1751 - _t1752 = parse_term(parser) - term_3975 = _t1752 + _t1753 = parse_term(parser) + term975 = _t1753 + _t1754 = parse_term(parser) + term_3976 = _t1754 consume_literal!(parser, ")") - _t1753 = Proto.RelTerm(rel_term_type=OneOf(:term, term974)) - _t1754 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3975)) - _t1755 = Proto.Primitive(name="rel_primitive_gt_monotype", terms=Proto.RelTerm[_t1753, _t1754]) - result977 = _t1755 - record_span!(parser, span_start976, "Primitive") - return result977 + _t1755 = Proto.RelTerm(rel_term_type=OneOf(:term, term975)) + _t1756 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3976)) + _t1757 = Proto.Primitive(name="rel_primitive_gt_monotype", terms=Proto.RelTerm[_t1755, _t1756]) + result978 = _t1757 + record_span!(parser, span_start977, "Primitive") + return result978 end function parse_gt_eq(parser::ParserState)::Proto.Primitive - span_start980 = span_start(parser) + span_start981 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, ">=") - _t1756 = parse_term(parser) - term978 = _t1756 - _t1757 = parse_term(parser) - term_3979 = _t1757 + _t1758 = parse_term(parser) + term979 = _t1758 + _t1759 = parse_term(parser) + term_3980 = _t1759 consume_literal!(parser, ")") - _t1758 = Proto.RelTerm(rel_term_type=OneOf(:term, term978)) - _t1759 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3979)) - _t1760 = Proto.Primitive(name="rel_primitive_gt_eq_monotype", terms=Proto.RelTerm[_t1758, _t1759]) - result981 = _t1760 - record_span!(parser, span_start980, "Primitive") - return result981 + _t1760 = Proto.RelTerm(rel_term_type=OneOf(:term, term979)) + _t1761 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3980)) + _t1762 = Proto.Primitive(name="rel_primitive_gt_eq_monotype", terms=Proto.RelTerm[_t1760, _t1761]) + result982 = _t1762 + record_span!(parser, span_start981, "Primitive") + return result982 end function parse_add(parser::ParserState)::Proto.Primitive - span_start985 = span_start(parser) + span_start986 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "+") - _t1761 = parse_term(parser) - term982 = _t1761 - _t1762 = parse_term(parser) - term_3983 = _t1762 _t1763 = parse_term(parser) - term_4984 = _t1763 + term983 = _t1763 + _t1764 = parse_term(parser) + term_3984 = _t1764 + _t1765 = parse_term(parser) + term_4985 = _t1765 consume_literal!(parser, ")") - _t1764 = Proto.RelTerm(rel_term_type=OneOf(:term, term982)) - _t1765 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3983)) - _t1766 = Proto.RelTerm(rel_term_type=OneOf(:term, term_4984)) - _t1767 = Proto.Primitive(name="rel_primitive_add_monotype", terms=Proto.RelTerm[_t1764, _t1765, _t1766]) - result986 = _t1767 - record_span!(parser, span_start985, "Primitive") - return result986 + _t1766 = Proto.RelTerm(rel_term_type=OneOf(:term, term983)) + _t1767 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3984)) + _t1768 = Proto.RelTerm(rel_term_type=OneOf(:term, term_4985)) + _t1769 = Proto.Primitive(name="rel_primitive_add_monotype", terms=Proto.RelTerm[_t1766, _t1767, _t1768]) + result987 = _t1769 + record_span!(parser, span_start986, "Primitive") + return result987 end function parse_minus(parser::ParserState)::Proto.Primitive - span_start990 = span_start(parser) + span_start991 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "-") - _t1768 = parse_term(parser) - term987 = _t1768 - _t1769 = parse_term(parser) - term_3988 = _t1769 _t1770 = parse_term(parser) - term_4989 = _t1770 + term988 = _t1770 + _t1771 = parse_term(parser) + term_3989 = _t1771 + _t1772 = parse_term(parser) + term_4990 = _t1772 consume_literal!(parser, ")") - _t1771 = Proto.RelTerm(rel_term_type=OneOf(:term, term987)) - _t1772 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3988)) - _t1773 = Proto.RelTerm(rel_term_type=OneOf(:term, term_4989)) - _t1774 = Proto.Primitive(name="rel_primitive_subtract_monotype", terms=Proto.RelTerm[_t1771, _t1772, _t1773]) - result991 = _t1774 - record_span!(parser, span_start990, "Primitive") - return result991 + _t1773 = Proto.RelTerm(rel_term_type=OneOf(:term, term988)) + _t1774 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3989)) + _t1775 = Proto.RelTerm(rel_term_type=OneOf(:term, term_4990)) + _t1776 = Proto.Primitive(name="rel_primitive_subtract_monotype", terms=Proto.RelTerm[_t1773, _t1774, _t1775]) + result992 = _t1776 + record_span!(parser, span_start991, "Primitive") + return result992 end function parse_multiply(parser::ParserState)::Proto.Primitive - span_start995 = span_start(parser) + span_start996 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "*") - _t1775 = parse_term(parser) - term992 = _t1775 - _t1776 = parse_term(parser) - term_3993 = _t1776 _t1777 = parse_term(parser) - term_4994 = _t1777 + term993 = _t1777 + _t1778 = parse_term(parser) + term_3994 = _t1778 + _t1779 = parse_term(parser) + term_4995 = _t1779 consume_literal!(parser, ")") - _t1778 = Proto.RelTerm(rel_term_type=OneOf(:term, term992)) - _t1779 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3993)) - _t1780 = Proto.RelTerm(rel_term_type=OneOf(:term, term_4994)) - _t1781 = Proto.Primitive(name="rel_primitive_multiply_monotype", terms=Proto.RelTerm[_t1778, _t1779, _t1780]) - result996 = _t1781 - record_span!(parser, span_start995, "Primitive") - return result996 + _t1780 = Proto.RelTerm(rel_term_type=OneOf(:term, term993)) + _t1781 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3994)) + _t1782 = Proto.RelTerm(rel_term_type=OneOf(:term, term_4995)) + _t1783 = Proto.Primitive(name="rel_primitive_multiply_monotype", terms=Proto.RelTerm[_t1780, _t1781, _t1782]) + result997 = _t1783 + record_span!(parser, span_start996, "Primitive") + return result997 end function parse_divide(parser::ParserState)::Proto.Primitive - span_start1000 = span_start(parser) + span_start1001 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "/") - _t1782 = parse_term(parser) - term997 = _t1782 - _t1783 = parse_term(parser) - term_3998 = _t1783 _t1784 = parse_term(parser) - term_4999 = _t1784 + term998 = _t1784 + _t1785 = parse_term(parser) + term_3999 = _t1785 + _t1786 = parse_term(parser) + term_41000 = _t1786 consume_literal!(parser, ")") - _t1785 = Proto.RelTerm(rel_term_type=OneOf(:term, term997)) - _t1786 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3998)) - _t1787 = Proto.RelTerm(rel_term_type=OneOf(:term, term_4999)) - _t1788 = Proto.Primitive(name="rel_primitive_divide_monotype", terms=Proto.RelTerm[_t1785, _t1786, _t1787]) - result1001 = _t1788 - record_span!(parser, span_start1000, "Primitive") - return result1001 + _t1787 = Proto.RelTerm(rel_term_type=OneOf(:term, term998)) + _t1788 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3999)) + _t1789 = Proto.RelTerm(rel_term_type=OneOf(:term, term_41000)) + _t1790 = Proto.Primitive(name="rel_primitive_divide_monotype", terms=Proto.RelTerm[_t1787, _t1788, _t1789]) + result1002 = _t1790 + record_span!(parser, span_start1001, "Primitive") + return result1002 end function parse_rel_term(parser::ParserState)::Proto.RelTerm - span_start1005 = span_start(parser) + span_start1006 = span_start(parser) if match_lookahead_literal(parser, "true", 0) - _t1789 = 1 + _t1791 = 1 else if match_lookahead_literal(parser, "missing", 0) - _t1790 = 1 + _t1792 = 1 else if match_lookahead_literal(parser, "false", 0) - _t1791 = 1 + _t1793 = 1 else if match_lookahead_literal(parser, "(", 0) - _t1792 = 1 + _t1794 = 1 else if match_lookahead_literal(parser, "#", 0) - _t1793 = 0 + _t1795 = 0 else if match_lookahead_terminal(parser, "SYMBOL", 0) - _t1794 = 1 + _t1796 = 1 else if match_lookahead_terminal(parser, "UINT32", 0) - _t1795 = 1 + _t1797 = 1 else if match_lookahead_terminal(parser, "UINT128", 0) - _t1796 = 1 + _t1798 = 1 else if match_lookahead_terminal(parser, "STRING", 0) - _t1797 = 1 + _t1799 = 1 else if match_lookahead_terminal(parser, "INT32", 0) - _t1798 = 1 + _t1800 = 1 else if match_lookahead_terminal(parser, "INT128", 0) - _t1799 = 1 + _t1801 = 1 else if match_lookahead_terminal(parser, "INT", 0) - _t1800 = 1 + _t1802 = 1 else if match_lookahead_terminal(parser, "FLOAT32", 0) - _t1801 = 1 + _t1803 = 1 else if match_lookahead_terminal(parser, "FLOAT", 0) - _t1802 = 1 + _t1804 = 1 else if match_lookahead_terminal(parser, "DECIMAL", 0) - _t1803 = 1 + _t1805 = 1 else - _t1803 = -1 + _t1805 = -1 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 - _t1796 = _t1797 + _t1798 = _t1799 end - _t1795 = _t1796 + _t1797 = _t1798 end - _t1794 = _t1795 + _t1796 = _t1797 end - _t1793 = _t1794 + _t1795 = _t1796 end - _t1792 = _t1793 + _t1794 = _t1795 end - _t1791 = _t1792 + _t1793 = _t1794 end - _t1790 = _t1791 + _t1792 = _t1793 end - _t1789 = _t1790 + _t1791 = _t1792 end - prediction1002 = _t1789 - if prediction1002 == 1 - _t1805 = parse_term(parser) - term1004 = _t1805 - _t1806 = Proto.RelTerm(rel_term_type=OneOf(:term, term1004)) - _t1804 = _t1806 + prediction1003 = _t1791 + if prediction1003 == 1 + _t1807 = parse_term(parser) + term1005 = _t1807 + _t1808 = Proto.RelTerm(rel_term_type=OneOf(:term, term1005)) + _t1806 = _t1808 else - if prediction1002 == 0 - _t1808 = parse_specialized_value(parser) - specialized_value1003 = _t1808 - _t1809 = Proto.RelTerm(rel_term_type=OneOf(:specialized_value, specialized_value1003)) - _t1807 = _t1809 + if prediction1003 == 0 + _t1810 = parse_specialized_value(parser) + specialized_value1004 = _t1810 + _t1811 = Proto.RelTerm(rel_term_type=OneOf(:specialized_value, specialized_value1004)) + _t1809 = _t1811 else throw(ParseError("Unexpected token in rel_term" * ": " * string(lookahead(parser, 0)))) end - _t1804 = _t1807 + _t1806 = _t1809 end - result1006 = _t1804 - record_span!(parser, span_start1005, "RelTerm") - return result1006 + result1007 = _t1806 + record_span!(parser, span_start1006, "RelTerm") + return result1007 end function parse_specialized_value(parser::ParserState)::Proto.Value - span_start1008 = span_start(parser) + span_start1009 = span_start(parser) consume_literal!(parser, "#") - _t1810 = parse_raw_value(parser) - raw_value1007 = _t1810 - result1009 = raw_value1007 - record_span!(parser, span_start1008, "Value") - return result1009 + _t1812 = parse_raw_value(parser) + raw_value1008 = _t1812 + result1010 = raw_value1008 + record_span!(parser, span_start1009, "Value") + return result1010 end function parse_rel_atom(parser::ParserState)::Proto.RelAtom - span_start1015 = span_start(parser) + span_start1016 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "relatom") - _t1811 = parse_name(parser) - name1010 = _t1811 - xs1011 = Proto.RelTerm[] - cond1012 = ((((((((((((((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 cond1012 - _t1812 = parse_rel_term(parser) - item1013 = _t1812 - push!(xs1011, item1013) - cond1012 = ((((((((((((((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)) + _t1813 = parse_name(parser) + name1011 = _t1813 + xs1012 = Proto.RelTerm[] + cond1013 = ((((((((((((((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 cond1013 + _t1814 = parse_rel_term(parser) + item1014 = _t1814 + push!(xs1012, item1014) + cond1013 = ((((((((((((((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_terms1014 = xs1011 + rel_terms1015 = xs1012 consume_literal!(parser, ")") - _t1813 = Proto.RelAtom(name=name1010, terms=rel_terms1014) - result1016 = _t1813 - record_span!(parser, span_start1015, "RelAtom") - return result1016 + _t1815 = Proto.RelAtom(name=name1011, terms=rel_terms1015) + result1017 = _t1815 + record_span!(parser, span_start1016, "RelAtom") + return result1017 end function parse_cast(parser::ParserState)::Proto.Cast - span_start1019 = span_start(parser) + span_start1020 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "cast") - _t1814 = parse_term(parser) - term1017 = _t1814 - _t1815 = parse_term(parser) - term_31018 = _t1815 + _t1816 = parse_term(parser) + term1018 = _t1816 + _t1817 = parse_term(parser) + term_31019 = _t1817 consume_literal!(parser, ")") - _t1816 = Proto.Cast(input=term1017, result=term_31018) - result1020 = _t1816 - record_span!(parser, span_start1019, "Cast") - return result1020 + _t1818 = Proto.Cast(input=term1018, result=term_31019) + result1021 = _t1818 + record_span!(parser, span_start1020, "Cast") + return result1021 end function parse_attrs(parser::ParserState)::Vector{Proto.Attribute} consume_literal!(parser, "(") consume_literal!(parser, "attrs") - xs1021 = Proto.Attribute[] - cond1022 = match_lookahead_literal(parser, "(", 0) - while cond1022 - _t1817 = parse_attribute(parser) - item1023 = _t1817 - push!(xs1021, item1023) - cond1022 = match_lookahead_literal(parser, "(", 0) + xs1022 = Proto.Attribute[] + cond1023 = match_lookahead_literal(parser, "(", 0) + while cond1023 + _t1819 = parse_attribute(parser) + item1024 = _t1819 + push!(xs1022, item1024) + cond1023 = match_lookahead_literal(parser, "(", 0) end - attributes1024 = xs1021 + attributes1025 = xs1022 consume_literal!(parser, ")") - return attributes1024 + return attributes1025 end function parse_attribute(parser::ParserState)::Proto.Attribute - span_start1030 = span_start(parser) + span_start1031 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "attribute") - _t1818 = parse_name(parser) - name1025 = _t1818 - xs1026 = Proto.Value[] - cond1027 = ((((((((((((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 cond1027 - _t1819 = parse_raw_value(parser) - item1028 = _t1819 - push!(xs1026, item1028) - cond1027 = ((((((((((((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)) + _t1820 = parse_name(parser) + name1026 = _t1820 + xs1027 = Proto.Value[] + cond1028 = ((((((((((((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 cond1028 + _t1821 = parse_raw_value(parser) + item1029 = _t1821 + push!(xs1027, item1029) + cond1028 = ((((((((((((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_values1029 = xs1026 + raw_values1030 = xs1027 consume_literal!(parser, ")") - _t1820 = Proto.Attribute(name=name1025, args=raw_values1029) - result1031 = _t1820 - record_span!(parser, span_start1030, "Attribute") - return result1031 + _t1822 = Proto.Attribute(name=name1026, args=raw_values1030) + result1032 = _t1822 + record_span!(parser, span_start1031, "Attribute") + return result1032 end function parse_algorithm(parser::ParserState)::Proto.Algorithm - span_start1037 = span_start(parser) + span_start1038 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "algorithm") - xs1032 = Proto.RelationId[] - cond1033 = (match_lookahead_literal(parser, ":", 0) || match_lookahead_terminal(parser, "UINT128", 0)) - while cond1033 - _t1821 = parse_relation_id(parser) - item1034 = _t1821 - push!(xs1032, item1034) - cond1033 = (match_lookahead_literal(parser, ":", 0) || match_lookahead_terminal(parser, "UINT128", 0)) + xs1033 = Proto.RelationId[] + cond1034 = (match_lookahead_literal(parser, ":", 0) || match_lookahead_terminal(parser, "UINT128", 0)) + while cond1034 + _t1823 = parse_relation_id(parser) + item1035 = _t1823 + push!(xs1033, item1035) + cond1034 = (match_lookahead_literal(parser, ":", 0) || match_lookahead_terminal(parser, "UINT128", 0)) end - relation_ids1035 = xs1032 - _t1822 = parse_script(parser) - script1036 = _t1822 + relation_ids1036 = xs1033 + _t1824 = parse_script(parser) + script1037 = _t1824 consume_literal!(parser, ")") - _t1823 = Proto.Algorithm(var"#global"=relation_ids1035, body=script1036) - result1038 = _t1823 - record_span!(parser, span_start1037, "Algorithm") - return result1038 + _t1825 = Proto.Algorithm(var"#global"=relation_ids1036, body=script1037) + result1039 = _t1825 + record_span!(parser, span_start1038, "Algorithm") + return result1039 end function parse_script(parser::ParserState)::Proto.Script - span_start1043 = span_start(parser) + span_start1044 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "script") - xs1039 = Proto.Construct[] - cond1040 = match_lookahead_literal(parser, "(", 0) - while cond1040 - _t1824 = parse_construct(parser) - item1041 = _t1824 - push!(xs1039, item1041) - cond1040 = match_lookahead_literal(parser, "(", 0) + xs1040 = Proto.Construct[] + cond1041 = match_lookahead_literal(parser, "(", 0) + while cond1041 + _t1826 = parse_construct(parser) + item1042 = _t1826 + push!(xs1040, item1042) + cond1041 = match_lookahead_literal(parser, "(", 0) end - constructs1042 = xs1039 + constructs1043 = xs1040 consume_literal!(parser, ")") - _t1825 = Proto.Script(constructs=constructs1042) - result1044 = _t1825 - record_span!(parser, span_start1043, "Script") - return result1044 + _t1827 = Proto.Script(constructs=constructs1043) + result1045 = _t1827 + record_span!(parser, span_start1044, "Script") + return result1045 end function parse_construct(parser::ParserState)::Proto.Construct - span_start1048 = span_start(parser) + span_start1049 = span_start(parser) if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "upsert", 1) - _t1827 = 1 + _t1829 = 1 else if match_lookahead_literal(parser, "monus", 1) - _t1828 = 1 + _t1830 = 1 else if match_lookahead_literal(parser, "monoid", 1) - _t1829 = 1 + _t1831 = 1 else if match_lookahead_literal(parser, "loop", 1) - _t1830 = 0 + _t1832 = 0 else if match_lookahead_literal(parser, "break", 1) - _t1831 = 1 + _t1833 = 1 else if match_lookahead_literal(parser, "assign", 1) - _t1832 = 1 + _t1834 = 1 else - _t1832 = -1 + _t1834 = -1 end - _t1831 = _t1832 + _t1833 = _t1834 end - _t1830 = _t1831 + _t1832 = _t1833 end - _t1829 = _t1830 + _t1831 = _t1832 end - _t1828 = _t1829 + _t1830 = _t1831 end - _t1827 = _t1828 + _t1829 = _t1830 end - _t1826 = _t1827 + _t1828 = _t1829 else - _t1826 = -1 + _t1828 = -1 end - prediction1045 = _t1826 - if prediction1045 == 1 - _t1834 = parse_instruction(parser) - instruction1047 = _t1834 - _t1835 = Proto.Construct(construct_type=OneOf(:instruction, instruction1047)) - _t1833 = _t1835 + prediction1046 = _t1828 + if prediction1046 == 1 + _t1836 = parse_instruction(parser) + instruction1048 = _t1836 + _t1837 = Proto.Construct(construct_type=OneOf(:instruction, instruction1048)) + _t1835 = _t1837 else - if prediction1045 == 0 - _t1837 = parse_loop(parser) - loop1046 = _t1837 - _t1838 = Proto.Construct(construct_type=OneOf(:loop, loop1046)) - _t1836 = _t1838 + if prediction1046 == 0 + _t1839 = parse_loop(parser) + loop1047 = _t1839 + _t1840 = Proto.Construct(construct_type=OneOf(:loop, loop1047)) + _t1838 = _t1840 else throw(ParseError("Unexpected token in construct" * ": " * string(lookahead(parser, 0)))) end - _t1833 = _t1836 + _t1835 = _t1838 end - result1049 = _t1833 - record_span!(parser, span_start1048, "Construct") - return result1049 + result1050 = _t1835 + record_span!(parser, span_start1049, "Construct") + return result1050 end function parse_loop(parser::ParserState)::Proto.Loop - span_start1052 = span_start(parser) + span_start1053 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "loop") - _t1839 = parse_init(parser) - init1050 = _t1839 - _t1840 = parse_script(parser) - script1051 = _t1840 + _t1841 = parse_init(parser) + init1051 = _t1841 + _t1842 = parse_script(parser) + script1052 = _t1842 consume_literal!(parser, ")") - _t1841 = Proto.Loop(init=init1050, body=script1051) - result1053 = _t1841 - record_span!(parser, span_start1052, "Loop") - return result1053 + _t1843 = Proto.Loop(init=init1051, body=script1052) + result1054 = _t1843 + record_span!(parser, span_start1053, "Loop") + return result1054 end function parse_init(parser::ParserState)::Vector{Proto.Instruction} consume_literal!(parser, "(") consume_literal!(parser, "init") - xs1054 = Proto.Instruction[] - cond1055 = match_lookahead_literal(parser, "(", 0) - while cond1055 - _t1842 = parse_instruction(parser) - item1056 = _t1842 - push!(xs1054, item1056) - cond1055 = match_lookahead_literal(parser, "(", 0) + xs1055 = Proto.Instruction[] + cond1056 = match_lookahead_literal(parser, "(", 0) + while cond1056 + _t1844 = parse_instruction(parser) + item1057 = _t1844 + push!(xs1055, item1057) + cond1056 = match_lookahead_literal(parser, "(", 0) end - instructions1057 = xs1054 + instructions1058 = xs1055 consume_literal!(parser, ")") - return instructions1057 + return instructions1058 end function parse_instruction(parser::ParserState)::Proto.Instruction - span_start1064 = span_start(parser) + span_start1065 = span_start(parser) if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "upsert", 1) - _t1844 = 1 + _t1846 = 1 else if match_lookahead_literal(parser, "monus", 1) - _t1845 = 4 + _t1847 = 4 else if match_lookahead_literal(parser, "monoid", 1) - _t1846 = 3 + _t1848 = 3 else if match_lookahead_literal(parser, "break", 1) - _t1847 = 2 + _t1849 = 2 else if match_lookahead_literal(parser, "assign", 1) - _t1848 = 0 + _t1850 = 0 else - _t1848 = -1 + _t1850 = -1 end - _t1847 = _t1848 + _t1849 = _t1850 end - _t1846 = _t1847 + _t1848 = _t1849 end - _t1845 = _t1846 + _t1847 = _t1848 end - _t1844 = _t1845 + _t1846 = _t1847 end - _t1843 = _t1844 + _t1845 = _t1846 else - _t1843 = -1 + _t1845 = -1 end - prediction1058 = _t1843 - if prediction1058 == 4 - _t1850 = parse_monus_def(parser) - monus_def1063 = _t1850 - _t1851 = Proto.Instruction(instr_type=OneOf(:monus_def, monus_def1063)) - _t1849 = _t1851 + prediction1059 = _t1845 + if prediction1059 == 4 + _t1852 = parse_monus_def(parser) + monus_def1064 = _t1852 + _t1853 = Proto.Instruction(instr_type=OneOf(:monus_def, monus_def1064)) + _t1851 = _t1853 else - if prediction1058 == 3 - _t1853 = parse_monoid_def(parser) - monoid_def1062 = _t1853 - _t1854 = Proto.Instruction(instr_type=OneOf(:monoid_def, monoid_def1062)) - _t1852 = _t1854 + if prediction1059 == 3 + _t1855 = parse_monoid_def(parser) + monoid_def1063 = _t1855 + _t1856 = Proto.Instruction(instr_type=OneOf(:monoid_def, monoid_def1063)) + _t1854 = _t1856 else - if prediction1058 == 2 - _t1856 = parse_break(parser) - break1061 = _t1856 - _t1857 = Proto.Instruction(instr_type=OneOf(:var"#break", break1061)) - _t1855 = _t1857 + if prediction1059 == 2 + _t1858 = parse_break(parser) + break1062 = _t1858 + _t1859 = Proto.Instruction(instr_type=OneOf(:var"#break", break1062)) + _t1857 = _t1859 else - if prediction1058 == 1 - _t1859 = parse_upsert(parser) - upsert1060 = _t1859 - _t1860 = Proto.Instruction(instr_type=OneOf(:upsert, upsert1060)) - _t1858 = _t1860 + if prediction1059 == 1 + _t1861 = parse_upsert(parser) + upsert1061 = _t1861 + _t1862 = Proto.Instruction(instr_type=OneOf(:upsert, upsert1061)) + _t1860 = _t1862 else - if prediction1058 == 0 - _t1862 = parse_assign(parser) - assign1059 = _t1862 - _t1863 = Proto.Instruction(instr_type=OneOf(:assign, assign1059)) - _t1861 = _t1863 + if prediction1059 == 0 + _t1864 = parse_assign(parser) + assign1060 = _t1864 + _t1865 = Proto.Instruction(instr_type=OneOf(:assign, assign1060)) + _t1863 = _t1865 else throw(ParseError("Unexpected token in instruction" * ": " * string(lookahead(parser, 0)))) end - _t1858 = _t1861 + _t1860 = _t1863 end - _t1855 = _t1858 + _t1857 = _t1860 end - _t1852 = _t1855 + _t1854 = _t1857 end - _t1849 = _t1852 + _t1851 = _t1854 end - result1065 = _t1849 - record_span!(parser, span_start1064, "Instruction") - return result1065 + result1066 = _t1851 + record_span!(parser, span_start1065, "Instruction") + return result1066 end function parse_assign(parser::ParserState)::Proto.Assign - span_start1069 = span_start(parser) + span_start1070 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "assign") - _t1864 = parse_relation_id(parser) - relation_id1066 = _t1864 - _t1865 = parse_abstraction(parser) - abstraction1067 = _t1865 + _t1866 = parse_relation_id(parser) + relation_id1067 = _t1866 + _t1867 = parse_abstraction(parser) + abstraction1068 = _t1867 if match_lookahead_literal(parser, "(", 0) - _t1867 = parse_attrs(parser) - _t1866 = _t1867 + _t1869 = parse_attrs(parser) + _t1868 = _t1869 else - _t1866 = nothing + _t1868 = nothing end - attrs1068 = _t1866 + attrs1069 = _t1868 consume_literal!(parser, ")") - _t1868 = Proto.Assign(name=relation_id1066, body=abstraction1067, attrs=(!isnothing(attrs1068) ? attrs1068 : Proto.Attribute[])) - result1070 = _t1868 - record_span!(parser, span_start1069, "Assign") - return result1070 + _t1870 = Proto.Assign(name=relation_id1067, body=abstraction1068, attrs=(!isnothing(attrs1069) ? attrs1069 : Proto.Attribute[])) + result1071 = _t1870 + record_span!(parser, span_start1070, "Assign") + return result1071 end function parse_upsert(parser::ParserState)::Proto.Upsert - span_start1074 = span_start(parser) + span_start1075 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "upsert") - _t1869 = parse_relation_id(parser) - relation_id1071 = _t1869 - _t1870 = parse_abstraction_with_arity(parser) - abstraction_with_arity1072 = _t1870 + _t1871 = parse_relation_id(parser) + relation_id1072 = _t1871 + _t1872 = parse_abstraction_with_arity(parser) + abstraction_with_arity1073 = _t1872 if match_lookahead_literal(parser, "(", 0) - _t1872 = parse_attrs(parser) - _t1871 = _t1872 + _t1874 = parse_attrs(parser) + _t1873 = _t1874 else - _t1871 = nothing + _t1873 = nothing end - attrs1073 = _t1871 + attrs1074 = _t1873 consume_literal!(parser, ")") - _t1873 = Proto.Upsert(name=relation_id1071, body=abstraction_with_arity1072[1], attrs=(!isnothing(attrs1073) ? attrs1073 : Proto.Attribute[]), value_arity=abstraction_with_arity1072[2]) - result1075 = _t1873 - record_span!(parser, span_start1074, "Upsert") - return result1075 + _t1875 = Proto.Upsert(name=relation_id1072, body=abstraction_with_arity1073[1], attrs=(!isnothing(attrs1074) ? attrs1074 : Proto.Attribute[]), value_arity=abstraction_with_arity1073[2]) + result1076 = _t1875 + record_span!(parser, span_start1075, "Upsert") + return result1076 end function parse_abstraction_with_arity(parser::ParserState)::Tuple{Proto.Abstraction, Int64} consume_literal!(parser, "(") - _t1874 = parse_bindings(parser) - bindings1076 = _t1874 - _t1875 = parse_formula(parser) - formula1077 = _t1875 + _t1876 = parse_bindings(parser) + bindings1077 = _t1876 + _t1877 = parse_formula(parser) + formula1078 = _t1877 consume_literal!(parser, ")") - _t1876 = Proto.Abstraction(vars=vcat(bindings1076[1], !isnothing(bindings1076[2]) ? bindings1076[2] : []), value=formula1077) - return (_t1876, length(bindings1076[2]),) + _t1878 = Proto.Abstraction(vars=vcat(bindings1077[1], !isnothing(bindings1077[2]) ? bindings1077[2] : []), value=formula1078) + return (_t1878, length(bindings1077[2]),) end function parse_break(parser::ParserState)::Proto.Break - span_start1081 = span_start(parser) + span_start1082 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "break") - _t1877 = parse_relation_id(parser) - relation_id1078 = _t1877 - _t1878 = parse_abstraction(parser) - abstraction1079 = _t1878 + _t1879 = parse_relation_id(parser) + relation_id1079 = _t1879 + _t1880 = parse_abstraction(parser) + abstraction1080 = _t1880 if match_lookahead_literal(parser, "(", 0) - _t1880 = parse_attrs(parser) - _t1879 = _t1880 + _t1882 = parse_attrs(parser) + _t1881 = _t1882 else - _t1879 = nothing + _t1881 = nothing end - attrs1080 = _t1879 + attrs1081 = _t1881 consume_literal!(parser, ")") - _t1881 = Proto.Break(name=relation_id1078, body=abstraction1079, attrs=(!isnothing(attrs1080) ? attrs1080 : Proto.Attribute[])) - result1082 = _t1881 - record_span!(parser, span_start1081, "Break") - return result1082 + _t1883 = Proto.Break(name=relation_id1079, body=abstraction1080, attrs=(!isnothing(attrs1081) ? attrs1081 : Proto.Attribute[])) + result1083 = _t1883 + record_span!(parser, span_start1082, "Break") + return result1083 end function parse_monoid_def(parser::ParserState)::Proto.MonoidDef - span_start1087 = span_start(parser) + span_start1088 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "monoid") - _t1882 = parse_monoid(parser) - monoid1083 = _t1882 - _t1883 = parse_relation_id(parser) - relation_id1084 = _t1883 - _t1884 = parse_abstraction_with_arity(parser) - abstraction_with_arity1085 = _t1884 + _t1884 = parse_monoid(parser) + monoid1084 = _t1884 + _t1885 = parse_relation_id(parser) + relation_id1085 = _t1885 + _t1886 = parse_abstraction_with_arity(parser) + abstraction_with_arity1086 = _t1886 if match_lookahead_literal(parser, "(", 0) - _t1886 = parse_attrs(parser) - _t1885 = _t1886 + _t1888 = parse_attrs(parser) + _t1887 = _t1888 else - _t1885 = nothing + _t1887 = nothing end - attrs1086 = _t1885 + attrs1087 = _t1887 consume_literal!(parser, ")") - _t1887 = Proto.MonoidDef(monoid=monoid1083, name=relation_id1084, body=abstraction_with_arity1085[1], attrs=(!isnothing(attrs1086) ? attrs1086 : Proto.Attribute[]), value_arity=abstraction_with_arity1085[2]) - result1088 = _t1887 - record_span!(parser, span_start1087, "MonoidDef") - return result1088 + _t1889 = Proto.MonoidDef(monoid=monoid1084, name=relation_id1085, body=abstraction_with_arity1086[1], attrs=(!isnothing(attrs1087) ? attrs1087 : Proto.Attribute[]), value_arity=abstraction_with_arity1086[2]) + result1089 = _t1889 + record_span!(parser, span_start1088, "MonoidDef") + return result1089 end function parse_monoid(parser::ParserState)::Proto.Monoid - span_start1094 = span_start(parser) + span_start1095 = span_start(parser) if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "sum", 1) - _t1889 = 3 + _t1891 = 3 else if match_lookahead_literal(parser, "or", 1) - _t1890 = 0 + _t1892 = 0 else if match_lookahead_literal(parser, "min", 1) - _t1891 = 1 + _t1893 = 1 else if match_lookahead_literal(parser, "max", 1) - _t1892 = 2 + _t1894 = 2 else - _t1892 = -1 + _t1894 = -1 end - _t1891 = _t1892 + _t1893 = _t1894 end - _t1890 = _t1891 + _t1892 = _t1893 end - _t1889 = _t1890 + _t1891 = _t1892 end - _t1888 = _t1889 + _t1890 = _t1891 else - _t1888 = -1 + _t1890 = -1 end - prediction1089 = _t1888 - if prediction1089 == 3 - _t1894 = parse_sum_monoid(parser) - sum_monoid1093 = _t1894 - _t1895 = Proto.Monoid(value=OneOf(:sum_monoid, sum_monoid1093)) - _t1893 = _t1895 + prediction1090 = _t1890 + if prediction1090 == 3 + _t1896 = parse_sum_monoid(parser) + sum_monoid1094 = _t1896 + _t1897 = Proto.Monoid(value=OneOf(:sum_monoid, sum_monoid1094)) + _t1895 = _t1897 else - if prediction1089 == 2 - _t1897 = parse_max_monoid(parser) - max_monoid1092 = _t1897 - _t1898 = Proto.Monoid(value=OneOf(:max_monoid, max_monoid1092)) - _t1896 = _t1898 + if prediction1090 == 2 + _t1899 = parse_max_monoid(parser) + max_monoid1093 = _t1899 + _t1900 = Proto.Monoid(value=OneOf(:max_monoid, max_monoid1093)) + _t1898 = _t1900 else - if prediction1089 == 1 - _t1900 = parse_min_monoid(parser) - min_monoid1091 = _t1900 - _t1901 = Proto.Monoid(value=OneOf(:min_monoid, min_monoid1091)) - _t1899 = _t1901 + if prediction1090 == 1 + _t1902 = parse_min_monoid(parser) + min_monoid1092 = _t1902 + _t1903 = Proto.Monoid(value=OneOf(:min_monoid, min_monoid1092)) + _t1901 = _t1903 else - if prediction1089 == 0 - _t1903 = parse_or_monoid(parser) - or_monoid1090 = _t1903 - _t1904 = Proto.Monoid(value=OneOf(:or_monoid, or_monoid1090)) - _t1902 = _t1904 + if prediction1090 == 0 + _t1905 = parse_or_monoid(parser) + or_monoid1091 = _t1905 + _t1906 = Proto.Monoid(value=OneOf(:or_monoid, or_monoid1091)) + _t1904 = _t1906 else throw(ParseError("Unexpected token in monoid" * ": " * string(lookahead(parser, 0)))) end - _t1899 = _t1902 + _t1901 = _t1904 end - _t1896 = _t1899 + _t1898 = _t1901 end - _t1893 = _t1896 + _t1895 = _t1898 end - result1095 = _t1893 - record_span!(parser, span_start1094, "Monoid") - return result1095 + result1096 = _t1895 + record_span!(parser, span_start1095, "Monoid") + return result1096 end function parse_or_monoid(parser::ParserState)::Proto.OrMonoid - span_start1096 = span_start(parser) + span_start1097 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "or") consume_literal!(parser, ")") - _t1905 = Proto.OrMonoid() - result1097 = _t1905 - record_span!(parser, span_start1096, "OrMonoid") - return result1097 + _t1907 = Proto.OrMonoid() + result1098 = _t1907 + record_span!(parser, span_start1097, "OrMonoid") + return result1098 end function parse_min_monoid(parser::ParserState)::Proto.MinMonoid - span_start1099 = span_start(parser) + span_start1100 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "min") - _t1906 = parse_type(parser) - type1098 = _t1906 + _t1908 = parse_type(parser) + type1099 = _t1908 consume_literal!(parser, ")") - _t1907 = Proto.MinMonoid(var"#type"=type1098) - result1100 = _t1907 - record_span!(parser, span_start1099, "MinMonoid") - return result1100 + _t1909 = Proto.MinMonoid(var"#type"=type1099) + result1101 = _t1909 + record_span!(parser, span_start1100, "MinMonoid") + return result1101 end function parse_max_monoid(parser::ParserState)::Proto.MaxMonoid - span_start1102 = span_start(parser) + span_start1103 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "max") - _t1908 = parse_type(parser) - type1101 = _t1908 + _t1910 = parse_type(parser) + type1102 = _t1910 consume_literal!(parser, ")") - _t1909 = Proto.MaxMonoid(var"#type"=type1101) - result1103 = _t1909 - record_span!(parser, span_start1102, "MaxMonoid") - return result1103 + _t1911 = Proto.MaxMonoid(var"#type"=type1102) + result1104 = _t1911 + record_span!(parser, span_start1103, "MaxMonoid") + return result1104 end function parse_sum_monoid(parser::ParserState)::Proto.SumMonoid - span_start1105 = span_start(parser) + span_start1106 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "sum") - _t1910 = parse_type(parser) - type1104 = _t1910 + _t1912 = parse_type(parser) + type1105 = _t1912 consume_literal!(parser, ")") - _t1911 = Proto.SumMonoid(var"#type"=type1104) - result1106 = _t1911 - record_span!(parser, span_start1105, "SumMonoid") - return result1106 + _t1913 = Proto.SumMonoid(var"#type"=type1105) + result1107 = _t1913 + record_span!(parser, span_start1106, "SumMonoid") + return result1107 end function parse_monus_def(parser::ParserState)::Proto.MonusDef - span_start1111 = span_start(parser) + span_start1112 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "monus") - _t1912 = parse_monoid(parser) - monoid1107 = _t1912 - _t1913 = parse_relation_id(parser) - relation_id1108 = _t1913 - _t1914 = parse_abstraction_with_arity(parser) - abstraction_with_arity1109 = _t1914 + _t1914 = parse_monoid(parser) + monoid1108 = _t1914 + _t1915 = parse_relation_id(parser) + relation_id1109 = _t1915 + _t1916 = parse_abstraction_with_arity(parser) + abstraction_with_arity1110 = _t1916 if match_lookahead_literal(parser, "(", 0) - _t1916 = parse_attrs(parser) - _t1915 = _t1916 + _t1918 = parse_attrs(parser) + _t1917 = _t1918 else - _t1915 = nothing + _t1917 = nothing end - attrs1110 = _t1915 + attrs1111 = _t1917 consume_literal!(parser, ")") - _t1917 = Proto.MonusDef(monoid=monoid1107, name=relation_id1108, body=abstraction_with_arity1109[1], attrs=(!isnothing(attrs1110) ? attrs1110 : Proto.Attribute[]), value_arity=abstraction_with_arity1109[2]) - result1112 = _t1917 - record_span!(parser, span_start1111, "MonusDef") - return result1112 + _t1919 = Proto.MonusDef(monoid=monoid1108, name=relation_id1109, body=abstraction_with_arity1110[1], attrs=(!isnothing(attrs1111) ? attrs1111 : Proto.Attribute[]), value_arity=abstraction_with_arity1110[2]) + result1113 = _t1919 + record_span!(parser, span_start1112, "MonusDef") + return result1113 end function parse_constraint(parser::ParserState)::Proto.Constraint - span_start1117 = span_start(parser) + span_start1118 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "functional_dependency") - _t1918 = parse_relation_id(parser) - relation_id1113 = _t1918 - _t1919 = parse_abstraction(parser) - abstraction1114 = _t1919 - _t1920 = parse_functional_dependency_keys(parser) - functional_dependency_keys1115 = _t1920 - _t1921 = parse_functional_dependency_values(parser) - functional_dependency_values1116 = _t1921 + _t1920 = parse_relation_id(parser) + relation_id1114 = _t1920 + _t1921 = parse_abstraction(parser) + abstraction1115 = _t1921 + _t1922 = parse_functional_dependency_keys(parser) + functional_dependency_keys1116 = _t1922 + _t1923 = parse_functional_dependency_values(parser) + functional_dependency_values1117 = _t1923 consume_literal!(parser, ")") - _t1922 = Proto.FunctionalDependency(guard=abstraction1114, keys=functional_dependency_keys1115, values=functional_dependency_values1116) - _t1923 = Proto.Constraint(constraint_type=OneOf(:functional_dependency, _t1922), name=relation_id1113) - result1118 = _t1923 - record_span!(parser, span_start1117, "Constraint") - return result1118 + _t1924 = Proto.FunctionalDependency(guard=abstraction1115, keys=functional_dependency_keys1116, values=functional_dependency_values1117) + _t1925 = Proto.Constraint(constraint_type=OneOf(:functional_dependency, _t1924), name=relation_id1114) + result1119 = _t1925 + record_span!(parser, span_start1118, "Constraint") + return result1119 end function parse_functional_dependency_keys(parser::ParserState)::Vector{Proto.Var} consume_literal!(parser, "(") consume_literal!(parser, "keys") - xs1119 = Proto.Var[] - cond1120 = match_lookahead_terminal(parser, "SYMBOL", 0) - while cond1120 - _t1924 = parse_var(parser) - item1121 = _t1924 - push!(xs1119, item1121) - cond1120 = match_lookahead_terminal(parser, "SYMBOL", 0) + xs1120 = Proto.Var[] + cond1121 = match_lookahead_terminal(parser, "SYMBOL", 0) + while cond1121 + _t1926 = parse_var(parser) + item1122 = _t1926 + push!(xs1120, item1122) + cond1121 = match_lookahead_terminal(parser, "SYMBOL", 0) end - vars1122 = xs1119 + vars1123 = xs1120 consume_literal!(parser, ")") - return vars1122 + return vars1123 end function parse_functional_dependency_values(parser::ParserState)::Vector{Proto.Var} consume_literal!(parser, "(") consume_literal!(parser, "values") - xs1123 = Proto.Var[] - cond1124 = match_lookahead_terminal(parser, "SYMBOL", 0) - while cond1124 - _t1925 = parse_var(parser) - item1125 = _t1925 - push!(xs1123, item1125) - cond1124 = match_lookahead_terminal(parser, "SYMBOL", 0) + xs1124 = Proto.Var[] + cond1125 = match_lookahead_terminal(parser, "SYMBOL", 0) + while cond1125 + _t1927 = parse_var(parser) + item1126 = _t1927 + push!(xs1124, item1126) + cond1125 = match_lookahead_terminal(parser, "SYMBOL", 0) end - vars1126 = xs1123 + vars1127 = xs1124 consume_literal!(parser, ")") - return vars1126 + return vars1127 end function parse_data(parser::ParserState)::Proto.Data - span_start1132 = span_start(parser) + span_start1133 = span_start(parser) if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "iceberg_data", 1) - _t1927 = 3 + _t1929 = 3 else if match_lookahead_literal(parser, "edb", 1) - _t1928 = 0 + _t1930 = 0 else if match_lookahead_literal(parser, "csv_data", 1) - _t1929 = 2 + _t1931 = 2 else if match_lookahead_literal(parser, "betree_relation", 1) - _t1930 = 1 + _t1932 = 1 else - _t1930 = -1 + _t1932 = -1 end - _t1929 = _t1930 + _t1931 = _t1932 end - _t1928 = _t1929 + _t1930 = _t1931 end - _t1927 = _t1928 + _t1929 = _t1930 end - _t1926 = _t1927 + _t1928 = _t1929 else - _t1926 = -1 + _t1928 = -1 end - prediction1127 = _t1926 - if prediction1127 == 3 - _t1932 = parse_iceberg_data(parser) - iceberg_data1131 = _t1932 - _t1933 = Proto.Data(data_type=OneOf(:iceberg_data, iceberg_data1131)) - _t1931 = _t1933 + prediction1128 = _t1928 + if prediction1128 == 3 + _t1934 = parse_iceberg_data(parser) + iceberg_data1132 = _t1934 + _t1935 = Proto.Data(data_type=OneOf(:iceberg_data, iceberg_data1132)) + _t1933 = _t1935 else - if prediction1127 == 2 - _t1935 = parse_csv_data(parser) - csv_data1130 = _t1935 - _t1936 = Proto.Data(data_type=OneOf(:csv_data, csv_data1130)) - _t1934 = _t1936 + if prediction1128 == 2 + _t1937 = parse_csv_data(parser) + csv_data1131 = _t1937 + _t1938 = Proto.Data(data_type=OneOf(:csv_data, csv_data1131)) + _t1936 = _t1938 else - if prediction1127 == 1 - _t1938 = parse_betree_relation(parser) - betree_relation1129 = _t1938 - _t1939 = Proto.Data(data_type=OneOf(:betree_relation, betree_relation1129)) - _t1937 = _t1939 + if prediction1128 == 1 + _t1940 = parse_betree_relation(parser) + betree_relation1130 = _t1940 + _t1941 = Proto.Data(data_type=OneOf(:betree_relation, betree_relation1130)) + _t1939 = _t1941 else - if prediction1127 == 0 - _t1941 = parse_edb(parser) - edb1128 = _t1941 - _t1942 = Proto.Data(data_type=OneOf(:edb, edb1128)) - _t1940 = _t1942 + if prediction1128 == 0 + _t1943 = parse_edb(parser) + edb1129 = _t1943 + _t1944 = Proto.Data(data_type=OneOf(:edb, edb1129)) + _t1942 = _t1944 else throw(ParseError("Unexpected token in data" * ": " * string(lookahead(parser, 0)))) end - _t1937 = _t1940 + _t1939 = _t1942 end - _t1934 = _t1937 + _t1936 = _t1939 end - _t1931 = _t1934 + _t1933 = _t1936 end - result1133 = _t1931 - record_span!(parser, span_start1132, "Data") - return result1133 + result1134 = _t1933 + record_span!(parser, span_start1133, "Data") + return result1134 end function parse_edb(parser::ParserState)::Proto.EDB - span_start1137 = span_start(parser) + span_start1138 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "edb") - _t1943 = parse_relation_id(parser) - relation_id1134 = _t1943 - _t1944 = parse_edb_path(parser) - edb_path1135 = _t1944 - _t1945 = parse_edb_types(parser) - edb_types1136 = _t1945 + _t1945 = parse_relation_id(parser) + relation_id1135 = _t1945 + _t1946 = parse_edb_path(parser) + edb_path1136 = _t1946 + _t1947 = parse_edb_types(parser) + edb_types1137 = _t1947 consume_literal!(parser, ")") - _t1946 = Proto.EDB(target_id=relation_id1134, path=edb_path1135, types=edb_types1136) - result1138 = _t1946 - record_span!(parser, span_start1137, "EDB") - return result1138 + _t1948 = Proto.EDB(target_id=relation_id1135, path=edb_path1136, types=edb_types1137) + result1139 = _t1948 + record_span!(parser, span_start1138, "EDB") + return result1139 end function parse_edb_path(parser::ParserState)::Vector{String} consume_literal!(parser, "[") - xs1139 = String[] - cond1140 = match_lookahead_terminal(parser, "STRING", 0) - while cond1140 - item1141 = consume_terminal!(parser, "STRING") - push!(xs1139, item1141) - cond1140 = match_lookahead_terminal(parser, "STRING", 0) + xs1140 = String[] + cond1141 = match_lookahead_terminal(parser, "STRING", 0) + while cond1141 + item1142 = consume_terminal!(parser, "STRING") + push!(xs1140, item1142) + cond1141 = match_lookahead_terminal(parser, "STRING", 0) end - strings1142 = xs1139 + strings1143 = xs1140 consume_literal!(parser, "]") - return strings1142 + return strings1143 end function parse_edb_types(parser::ParserState)::Vector{Proto.var"#Type"} consume_literal!(parser, "[") - xs1143 = Proto.var"#Type"[] - cond1144 = (((((((((((((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 cond1144 - _t1947 = parse_type(parser) - item1145 = _t1947 - push!(xs1143, item1145) - cond1144 = (((((((((((((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)) + xs1144 = Proto.var"#Type"[] + cond1145 = (((((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "BOOLEAN", 0)) || match_lookahead_literal(parser, "DATE", 0)) || match_lookahead_literal(parser, "DATETIME", 0)) || match_lookahead_literal(parser, "FLOAT", 0)) || match_lookahead_literal(parser, "FLOAT32", 0)) || match_lookahead_literal(parser, "INT", 0)) || match_lookahead_literal(parser, "INT128", 0)) || match_lookahead_literal(parser, "INT32", 0)) || match_lookahead_literal(parser, "MISSING", 0)) || match_lookahead_literal(parser, "STRING", 0)) || match_lookahead_literal(parser, "UINT128", 0)) || match_lookahead_literal(parser, "UINT32", 0)) || match_lookahead_literal(parser, "UNKNOWN", 0)) + while cond1145 + _t1949 = parse_type(parser) + item1146 = _t1949 + push!(xs1144, item1146) + cond1145 = (((((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "BOOLEAN", 0)) || match_lookahead_literal(parser, "DATE", 0)) || match_lookahead_literal(parser, "DATETIME", 0)) || match_lookahead_literal(parser, "FLOAT", 0)) || match_lookahead_literal(parser, "FLOAT32", 0)) || match_lookahead_literal(parser, "INT", 0)) || match_lookahead_literal(parser, "INT128", 0)) || match_lookahead_literal(parser, "INT32", 0)) || match_lookahead_literal(parser, "MISSING", 0)) || match_lookahead_literal(parser, "STRING", 0)) || match_lookahead_literal(parser, "UINT128", 0)) || match_lookahead_literal(parser, "UINT32", 0)) || match_lookahead_literal(parser, "UNKNOWN", 0)) end - types1146 = xs1143 + types1147 = xs1144 consume_literal!(parser, "]") - return types1146 + return types1147 end function parse_betree_relation(parser::ParserState)::Proto.BeTreeRelation - span_start1149 = span_start(parser) + span_start1150 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "betree_relation") - _t1948 = parse_relation_id(parser) - relation_id1147 = _t1948 - _t1949 = parse_betree_info(parser) - betree_info1148 = _t1949 + _t1950 = parse_relation_id(parser) + relation_id1148 = _t1950 + _t1951 = parse_betree_info(parser) + betree_info1149 = _t1951 consume_literal!(parser, ")") - _t1950 = Proto.BeTreeRelation(name=relation_id1147, relation_info=betree_info1148) - result1150 = _t1950 - record_span!(parser, span_start1149, "BeTreeRelation") - return result1150 + _t1952 = Proto.BeTreeRelation(name=relation_id1148, relation_info=betree_info1149) + result1151 = _t1952 + record_span!(parser, span_start1150, "BeTreeRelation") + return result1151 end function parse_betree_info(parser::ParserState)::Proto.BeTreeInfo - span_start1154 = span_start(parser) + span_start1155 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "betree_info") - _t1951 = parse_betree_info_key_types(parser) - betree_info_key_types1151 = _t1951 - _t1952 = parse_betree_info_value_types(parser) - betree_info_value_types1152 = _t1952 - _t1953 = parse_config_dict(parser) - config_dict1153 = _t1953 + _t1953 = parse_betree_info_key_types(parser) + betree_info_key_types1152 = _t1953 + _t1954 = parse_betree_info_value_types(parser) + betree_info_value_types1153 = _t1954 + _t1955 = parse_config_dict(parser) + config_dict1154 = _t1955 consume_literal!(parser, ")") - _t1954 = construct_betree_info(parser, betree_info_key_types1151, betree_info_value_types1152, config_dict1153) - result1155 = _t1954 - record_span!(parser, span_start1154, "BeTreeInfo") - return result1155 + _t1956 = construct_betree_info(parser, betree_info_key_types1152, betree_info_value_types1153, config_dict1154) + result1156 = _t1956 + record_span!(parser, span_start1155, "BeTreeInfo") + return result1156 end function parse_betree_info_key_types(parser::ParserState)::Vector{Proto.var"#Type"} consume_literal!(parser, "(") consume_literal!(parser, "key_types") - xs1156 = Proto.var"#Type"[] - cond1157 = (((((((((((((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 cond1157 - _t1955 = parse_type(parser) - item1158 = _t1955 - push!(xs1156, item1158) - cond1157 = (((((((((((((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)) + xs1157 = Proto.var"#Type"[] + cond1158 = (((((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "BOOLEAN", 0)) || match_lookahead_literal(parser, "DATE", 0)) || match_lookahead_literal(parser, "DATETIME", 0)) || match_lookahead_literal(parser, "FLOAT", 0)) || match_lookahead_literal(parser, "FLOAT32", 0)) || match_lookahead_literal(parser, "INT", 0)) || match_lookahead_literal(parser, "INT128", 0)) || match_lookahead_literal(parser, "INT32", 0)) || match_lookahead_literal(parser, "MISSING", 0)) || match_lookahead_literal(parser, "STRING", 0)) || match_lookahead_literal(parser, "UINT128", 0)) || match_lookahead_literal(parser, "UINT32", 0)) || match_lookahead_literal(parser, "UNKNOWN", 0)) + while cond1158 + _t1957 = parse_type(parser) + item1159 = _t1957 + push!(xs1157, item1159) + cond1158 = (((((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "BOOLEAN", 0)) || match_lookahead_literal(parser, "DATE", 0)) || match_lookahead_literal(parser, "DATETIME", 0)) || match_lookahead_literal(parser, "FLOAT", 0)) || match_lookahead_literal(parser, "FLOAT32", 0)) || match_lookahead_literal(parser, "INT", 0)) || match_lookahead_literal(parser, "INT128", 0)) || match_lookahead_literal(parser, "INT32", 0)) || match_lookahead_literal(parser, "MISSING", 0)) || match_lookahead_literal(parser, "STRING", 0)) || match_lookahead_literal(parser, "UINT128", 0)) || match_lookahead_literal(parser, "UINT32", 0)) || match_lookahead_literal(parser, "UNKNOWN", 0)) end - types1159 = xs1156 + types1160 = xs1157 consume_literal!(parser, ")") - return types1159 + return types1160 end function parse_betree_info_value_types(parser::ParserState)::Vector{Proto.var"#Type"} consume_literal!(parser, "(") consume_literal!(parser, "value_types") - xs1160 = Proto.var"#Type"[] - cond1161 = (((((((((((((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 cond1161 - _t1956 = parse_type(parser) - item1162 = _t1956 - push!(xs1160, item1162) - cond1161 = (((((((((((((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)) + xs1161 = Proto.var"#Type"[] + cond1162 = (((((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "BOOLEAN", 0)) || match_lookahead_literal(parser, "DATE", 0)) || match_lookahead_literal(parser, "DATETIME", 0)) || match_lookahead_literal(parser, "FLOAT", 0)) || match_lookahead_literal(parser, "FLOAT32", 0)) || match_lookahead_literal(parser, "INT", 0)) || match_lookahead_literal(parser, "INT128", 0)) || match_lookahead_literal(parser, "INT32", 0)) || match_lookahead_literal(parser, "MISSING", 0)) || match_lookahead_literal(parser, "STRING", 0)) || match_lookahead_literal(parser, "UINT128", 0)) || match_lookahead_literal(parser, "UINT32", 0)) || match_lookahead_literal(parser, "UNKNOWN", 0)) + while cond1162 + _t1958 = parse_type(parser) + item1163 = _t1958 + push!(xs1161, item1163) + cond1162 = (((((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "BOOLEAN", 0)) || match_lookahead_literal(parser, "DATE", 0)) || match_lookahead_literal(parser, "DATETIME", 0)) || match_lookahead_literal(parser, "FLOAT", 0)) || match_lookahead_literal(parser, "FLOAT32", 0)) || match_lookahead_literal(parser, "INT", 0)) || match_lookahead_literal(parser, "INT128", 0)) || match_lookahead_literal(parser, "INT32", 0)) || match_lookahead_literal(parser, "MISSING", 0)) || match_lookahead_literal(parser, "STRING", 0)) || match_lookahead_literal(parser, "UINT128", 0)) || match_lookahead_literal(parser, "UINT32", 0)) || match_lookahead_literal(parser, "UNKNOWN", 0)) end - types1163 = xs1160 + types1164 = xs1161 consume_literal!(parser, ")") - return types1163 + return types1164 end function parse_csv_data(parser::ParserState)::Proto.CSVData - span_start1168 = span_start(parser) + span_start1169 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "csv_data") - _t1957 = parse_csvlocator(parser) - csvlocator1164 = _t1957 - _t1958 = parse_csv_config(parser) - csv_config1165 = _t1958 - _t1959 = parse_gnf_columns(parser) - gnf_columns1166 = _t1959 - _t1960 = parse_csv_asof(parser) - csv_asof1167 = _t1960 + _t1959 = parse_csvlocator(parser) + csvlocator1165 = _t1959 + _t1960 = parse_csv_config(parser) + csv_config1166 = _t1960 + _t1961 = parse_gnf_columns(parser) + gnf_columns1167 = _t1961 + _t1962 = parse_csv_asof(parser) + csv_asof1168 = _t1962 consume_literal!(parser, ")") - _t1961 = Proto.CSVData(locator=csvlocator1164, config=csv_config1165, columns=gnf_columns1166, asof=csv_asof1167) - result1169 = _t1961 - record_span!(parser, span_start1168, "CSVData") - return result1169 + _t1963 = Proto.CSVData(locator=csvlocator1165, config=csv_config1166, columns=gnf_columns1167, asof=csv_asof1168) + result1170 = _t1963 + record_span!(parser, span_start1169, "CSVData") + return result1170 end function parse_csvlocator(parser::ParserState)::Proto.CSVLocator - span_start1172 = span_start(parser) + span_start1173 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "csv_locator") if (match_lookahead_literal(parser, "(", 0) && match_lookahead_literal(parser, "paths", 1)) - _t1963 = parse_csv_locator_paths(parser) - _t1962 = _t1963 + _t1965 = parse_csv_locator_paths(parser) + _t1964 = _t1965 else - _t1962 = nothing + _t1964 = nothing end - csv_locator_paths1170 = _t1962 + csv_locator_paths1171 = _t1964 if match_lookahead_literal(parser, "(", 0) - _t1965 = parse_csv_locator_inline_data(parser) - _t1964 = _t1965 + _t1967 = parse_csv_locator_inline_data(parser) + _t1966 = _t1967 else - _t1964 = nothing + _t1966 = nothing end - csv_locator_inline_data1171 = _t1964 + csv_locator_inline_data1172 = _t1966 consume_literal!(parser, ")") - _t1966 = Proto.CSVLocator(paths=(!isnothing(csv_locator_paths1170) ? csv_locator_paths1170 : String[]), inline_data=Vector{UInt8}((!isnothing(csv_locator_inline_data1171) ? csv_locator_inline_data1171 : ""))) - result1173 = _t1966 - record_span!(parser, span_start1172, "CSVLocator") - return result1173 + _t1968 = Proto.CSVLocator(paths=(!isnothing(csv_locator_paths1171) ? csv_locator_paths1171 : String[]), inline_data=Vector{UInt8}((!isnothing(csv_locator_inline_data1172) ? csv_locator_inline_data1172 : ""))) + result1174 = _t1968 + record_span!(parser, span_start1173, "CSVLocator") + return result1174 end function parse_csv_locator_paths(parser::ParserState)::Vector{String} consume_literal!(parser, "(") consume_literal!(parser, "paths") - xs1174 = String[] - cond1175 = match_lookahead_terminal(parser, "STRING", 0) - while cond1175 - item1176 = consume_terminal!(parser, "STRING") - push!(xs1174, item1176) - cond1175 = match_lookahead_terminal(parser, "STRING", 0) + xs1175 = String[] + cond1176 = match_lookahead_terminal(parser, "STRING", 0) + while cond1176 + item1177 = consume_terminal!(parser, "STRING") + push!(xs1175, item1177) + cond1176 = match_lookahead_terminal(parser, "STRING", 0) end - strings1177 = xs1174 + strings1178 = xs1175 consume_literal!(parser, ")") - return strings1177 + return strings1178 end function parse_csv_locator_inline_data(parser::ParserState)::String consume_literal!(parser, "(") consume_literal!(parser, "inline_data") - string1178 = consume_terminal!(parser, "STRING") + string1179 = consume_terminal!(parser, "STRING") consume_literal!(parser, ")") - return string1178 + return string1179 end function parse_csv_config(parser::ParserState)::Proto.CSVConfig - span_start1180 = span_start(parser) + span_start1181 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "csv_config") - _t1967 = parse_config_dict(parser) - config_dict1179 = _t1967 + _t1969 = parse_config_dict(parser) + config_dict1180 = _t1969 consume_literal!(parser, ")") - _t1968 = construct_csv_config(parser, config_dict1179) - result1181 = _t1968 - record_span!(parser, span_start1180, "CSVConfig") - return result1181 + _t1970 = construct_csv_config(parser, config_dict1180) + result1182 = _t1970 + record_span!(parser, span_start1181, "CSVConfig") + return result1182 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 - _t1969 = parse_gnf_column(parser) - item1184 = _t1969 - push!(xs1182, item1184) - cond1183 = match_lookahead_literal(parser, "(", 0) + xs1183 = Proto.GNFColumn[] + cond1184 = match_lookahead_literal(parser, "(", 0) + while cond1184 + _t1971 = parse_gnf_column(parser) + item1185 = _t1971 + push!(xs1183, item1185) + cond1184 = match_lookahead_literal(parser, "(", 0) end - gnf_columns1185 = xs1182 + gnf_columns1186 = xs1183 consume_literal!(parser, ")") - return gnf_columns1185 + return gnf_columns1186 end function parse_gnf_column(parser::ParserState)::Proto.GNFColumn - span_start1192 = span_start(parser) + span_start1193 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "column") - _t1970 = parse_gnf_column_path(parser) - gnf_column_path1186 = _t1970 + _t1972 = parse_gnf_column_path(parser) + gnf_column_path1187 = _t1972 if (match_lookahead_literal(parser, ":", 0) || match_lookahead_terminal(parser, "UINT128", 0)) - _t1972 = parse_relation_id(parser) - _t1971 = _t1972 + _t1974 = parse_relation_id(parser) + _t1973 = _t1974 else - _t1971 = nothing + _t1973 = nothing end - relation_id1187 = _t1971 + relation_id1188 = _t1973 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 - _t1973 = parse_type(parser) - item1190 = _t1973 - 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)) + xs1189 = Proto.var"#Type"[] + cond1190 = (((((((((((((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 cond1190 + _t1975 = parse_type(parser) + item1191 = _t1975 + push!(xs1189, item1191) + cond1190 = (((((((((((((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 + types1192 = xs1189 consume_literal!(parser, "]") consume_literal!(parser, ")") - _t1974 = Proto.GNFColumn(column_path=gnf_column_path1186, target_id=relation_id1187, types=types1191) - result1193 = _t1974 - record_span!(parser, span_start1192, "GNFColumn") - return result1193 + _t1976 = Proto.GNFColumn(column_path=gnf_column_path1187, target_id=relation_id1188, types=types1192) + result1194 = _t1976 + record_span!(parser, span_start1193, "GNFColumn") + return result1194 end function parse_gnf_column_path(parser::ParserState)::Vector{String} if match_lookahead_literal(parser, "[", 0) - _t1975 = 1 + _t1977 = 1 else if match_lookahead_terminal(parser, "STRING", 0) - _t1976 = 0 + _t1978 = 0 else - _t1976 = -1 + _t1978 = -1 end - _t1975 = _t1976 + _t1977 = _t1978 end - prediction1194 = _t1975 - if prediction1194 == 1 + prediction1195 = _t1977 + if prediction1195 == 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) + xs1197 = String[] + cond1198 = match_lookahead_terminal(parser, "STRING", 0) + while cond1198 + item1199 = consume_terminal!(parser, "STRING") + push!(xs1197, item1199) + cond1198 = match_lookahead_terminal(parser, "STRING", 0) end - strings1199 = xs1196 + strings1200 = xs1197 consume_literal!(parser, "]") - _t1977 = strings1199 + _t1979 = strings1200 else - if prediction1194 == 0 - string1195 = consume_terminal!(parser, "STRING") - _t1978 = String[string1195] + if prediction1195 == 0 + string1196 = consume_terminal!(parser, "STRING") + _t1980 = String[string1196] else throw(ParseError("Unexpected token in gnf_column_path" * ": " * string(lookahead(parser, 0)))) end - _t1977 = _t1978 + _t1979 = _t1980 end - return _t1977 + return _t1979 end function parse_csv_asof(parser::ParserState)::String consume_literal!(parser, "(") consume_literal!(parser, "asof") - string1200 = consume_terminal!(parser, "STRING") + string1201 = consume_terminal!(parser, "STRING") consume_literal!(parser, ")") - return string1200 + return string1201 end function parse_iceberg_data(parser::ParserState)::Proto.IcebergData - span_start1207 = span_start(parser) + span_start1208 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "iceberg_data") - _t1979 = parse_iceberg_locator(parser) - iceberg_locator1201 = _t1979 - _t1980 = parse_iceberg_catalog_config(parser) - iceberg_catalog_config1202 = _t1980 - _t1981 = parse_gnf_columns(parser) - gnf_columns1203 = _t1981 + _t1981 = parse_iceberg_locator(parser) + iceberg_locator1202 = _t1981 + _t1982 = parse_iceberg_catalog_config(parser) + iceberg_catalog_config1203 = _t1982 + _t1983 = parse_gnf_columns(parser) + gnf_columns1204 = _t1983 if (match_lookahead_literal(parser, "(", 0) && match_lookahead_literal(parser, "from_snapshot", 1)) - _t1983 = parse_iceberg_from_snapshot(parser) - _t1982 = _t1983 + _t1985 = parse_iceberg_from_snapshot(parser) + _t1984 = _t1985 else - _t1982 = nothing + _t1984 = nothing end - iceberg_from_snapshot1204 = _t1982 + iceberg_from_snapshot1205 = _t1984 if match_lookahead_literal(parser, "(", 0) - _t1985 = parse_iceberg_to_snapshot(parser) - _t1984 = _t1985 + _t1987 = parse_iceberg_to_snapshot(parser) + _t1986 = _t1987 else - _t1984 = nothing + _t1986 = nothing end - iceberg_to_snapshot1205 = _t1984 - _t1986 = parse_boolean_value(parser) - boolean_value1206 = _t1986 + iceberg_to_snapshot1206 = _t1986 + _t1988 = parse_boolean_value(parser) + boolean_value1207 = _t1988 consume_literal!(parser, ")") - _t1987 = construct_iceberg_data(parser, iceberg_locator1201, iceberg_catalog_config1202, gnf_columns1203, iceberg_from_snapshot1204, iceberg_to_snapshot1205, boolean_value1206) - result1208 = _t1987 - record_span!(parser, span_start1207, "IcebergData") - return result1208 + _t1989 = construct_iceberg_data(parser, iceberg_locator1202, iceberg_catalog_config1203, gnf_columns1204, iceberg_from_snapshot1205, iceberg_to_snapshot1206, boolean_value1207) + result1209 = _t1989 + record_span!(parser, span_start1208, "IcebergData") + return result1209 end function parse_iceberg_locator(parser::ParserState)::Proto.IcebergLocator - span_start1212 = span_start(parser) + span_start1213 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "iceberg_locator") - _t1988 = parse_iceberg_locator_table_name(parser) - iceberg_locator_table_name1209 = _t1988 - _t1989 = parse_iceberg_locator_namespace(parser) - iceberg_locator_namespace1210 = _t1989 - _t1990 = parse_iceberg_locator_warehouse(parser) - iceberg_locator_warehouse1211 = _t1990 + _t1990 = parse_iceberg_locator_table_name(parser) + iceberg_locator_table_name1210 = _t1990 + _t1991 = parse_iceberg_locator_namespace(parser) + iceberg_locator_namespace1211 = _t1991 + _t1992 = parse_iceberg_locator_warehouse(parser) + iceberg_locator_warehouse1212 = _t1992 consume_literal!(parser, ")") - _t1991 = Proto.IcebergLocator(table_name=iceberg_locator_table_name1209, namespace=iceberg_locator_namespace1210, warehouse=iceberg_locator_warehouse1211) - result1213 = _t1991 - record_span!(parser, span_start1212, "IcebergLocator") - return result1213 + _t1993 = Proto.IcebergLocator(table_name=iceberg_locator_table_name1210, namespace=iceberg_locator_namespace1211, warehouse=iceberg_locator_warehouse1212) + result1214 = _t1993 + record_span!(parser, span_start1213, "IcebergLocator") + return result1214 end function parse_iceberg_locator_table_name(parser::ParserState)::String consume_literal!(parser, "(") consume_literal!(parser, "table_name") - string1214 = consume_terminal!(parser, "STRING") + string1215 = consume_terminal!(parser, "STRING") consume_literal!(parser, ")") - return string1214 + return string1215 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) + xs1216 = String[] + cond1217 = match_lookahead_terminal(parser, "STRING", 0) + while cond1217 + item1218 = consume_terminal!(parser, "STRING") + push!(xs1216, item1218) + cond1217 = match_lookahead_terminal(parser, "STRING", 0) end - strings1218 = xs1215 + strings1219 = xs1216 consume_literal!(parser, ")") - return strings1218 + return strings1219 end function parse_iceberg_locator_warehouse(parser::ParserState)::String consume_literal!(parser, "(") consume_literal!(parser, "warehouse") - string1219 = consume_terminal!(parser, "STRING") + string1220 = consume_terminal!(parser, "STRING") consume_literal!(parser, ")") - return string1219 + return string1220 end function parse_iceberg_catalog_config(parser::ParserState)::Proto.IcebergCatalogConfig - span_start1224 = span_start(parser) + span_start1225 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "iceberg_catalog_config") - _t1992 = parse_iceberg_catalog_uri(parser) - iceberg_catalog_uri1220 = _t1992 + _t1994 = parse_iceberg_catalog_uri(parser) + iceberg_catalog_uri1221 = _t1994 if (match_lookahead_literal(parser, "(", 0) && match_lookahead_literal(parser, "scope", 1)) - _t1994 = parse_iceberg_catalog_config_scope(parser) - _t1993 = _t1994 + _t1996 = parse_iceberg_catalog_config_scope(parser) + _t1995 = _t1996 else - _t1993 = nothing + _t1995 = nothing end - iceberg_catalog_config_scope1221 = _t1993 - _t1995 = parse_iceberg_properties(parser) - iceberg_properties1222 = _t1995 - _t1996 = parse_iceberg_auth_properties(parser) - iceberg_auth_properties1223 = _t1996 + iceberg_catalog_config_scope1222 = _t1995 + _t1997 = parse_iceberg_properties(parser) + iceberg_properties1223 = _t1997 + _t1998 = parse_iceberg_auth_properties(parser) + iceberg_auth_properties1224 = _t1998 consume_literal!(parser, ")") - _t1997 = construct_iceberg_catalog_config(parser, iceberg_catalog_uri1220, iceberg_catalog_config_scope1221, iceberg_properties1222, iceberg_auth_properties1223) - result1225 = _t1997 - record_span!(parser, span_start1224, "IcebergCatalogConfig") - return result1225 + _t1999 = construct_iceberg_catalog_config(parser, iceberg_catalog_uri1221, iceberg_catalog_config_scope1222, iceberg_properties1223, iceberg_auth_properties1224) + result1226 = _t1999 + record_span!(parser, span_start1225, "IcebergCatalogConfig") + return result1226 end function parse_iceberg_catalog_uri(parser::ParserState)::String consume_literal!(parser, "(") consume_literal!(parser, "catalog_uri") - string1226 = consume_terminal!(parser, "STRING") + string1227 = consume_terminal!(parser, "STRING") consume_literal!(parser, ")") - return string1226 + return string1227 end function parse_iceberg_catalog_config_scope(parser::ParserState)::String consume_literal!(parser, "(") consume_literal!(parser, "scope") - string1227 = consume_terminal!(parser, "STRING") + string1228 = consume_terminal!(parser, "STRING") consume_literal!(parser, ")") - return string1227 + return string1228 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 - _t1998 = parse_iceberg_property_entry(parser) - item1230 = _t1998 - push!(xs1228, item1230) - cond1229 = match_lookahead_literal(parser, "(", 0) + xs1229 = Tuple{String, String}[] + cond1230 = match_lookahead_literal(parser, "(", 0) + while cond1230 + _t2000 = parse_iceberg_property_entry(parser) + item1231 = _t2000 + push!(xs1229, item1231) + cond1230 = match_lookahead_literal(parser, "(", 0) end - iceberg_property_entrys1231 = xs1228 + iceberg_property_entrys1232 = xs1229 consume_literal!(parser, ")") - return iceberg_property_entrys1231 + return iceberg_property_entrys1232 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") + string1233 = consume_terminal!(parser, "STRING") + string_31234 = consume_terminal!(parser, "STRING") consume_literal!(parser, ")") - return (string1232, string_31233,) + return (string1233, string_31234,) 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 - _t1999 = parse_iceberg_masked_property_entry(parser) - item1236 = _t1999 - push!(xs1234, item1236) - cond1235 = match_lookahead_literal(parser, "(", 0) + xs1235 = Tuple{String, String}[] + cond1236 = match_lookahead_literal(parser, "(", 0) + while cond1236 + _t2001 = parse_iceberg_masked_property_entry(parser) + item1237 = _t2001 + push!(xs1235, item1237) + cond1236 = match_lookahead_literal(parser, "(", 0) end - iceberg_masked_property_entrys1237 = xs1234 + iceberg_masked_property_entrys1238 = xs1235 consume_literal!(parser, ")") - return iceberg_masked_property_entrys1237 + return iceberg_masked_property_entrys1238 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") + string1239 = consume_terminal!(parser, "STRING") + string_31240 = consume_terminal!(parser, "STRING") consume_literal!(parser, ")") - return (string1238, string_31239,) + return (string1239, string_31240,) end function parse_iceberg_from_snapshot(parser::ParserState)::String consume_literal!(parser, "(") consume_literal!(parser, "from_snapshot") - string1240 = consume_terminal!(parser, "STRING") + string1241 = consume_terminal!(parser, "STRING") consume_literal!(parser, ")") - return string1240 + return string1241 end function parse_iceberg_to_snapshot(parser::ParserState)::String consume_literal!(parser, "(") consume_literal!(parser, "to_snapshot") - string1241 = consume_terminal!(parser, "STRING") + string1242 = consume_terminal!(parser, "STRING") consume_literal!(parser, ")") - return string1241 + return string1242 end function parse_undefine(parser::ParserState)::Proto.Undefine - span_start1243 = span_start(parser) + span_start1244 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "undefine") - _t2000 = parse_fragment_id(parser) - fragment_id1242 = _t2000 + _t2002 = parse_fragment_id(parser) + fragment_id1243 = _t2002 consume_literal!(parser, ")") - _t2001 = Proto.Undefine(fragment_id=fragment_id1242) - result1244 = _t2001 - record_span!(parser, span_start1243, "Undefine") - return result1244 + _t2003 = Proto.Undefine(fragment_id=fragment_id1243) + result1245 = _t2003 + record_span!(parser, span_start1244, "Undefine") + return result1245 end function parse_context(parser::ParserState)::Proto.Context - span_start1249 = span_start(parser) + span_start1250 = 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 - _t2002 = parse_relation_id(parser) - item1247 = _t2002 - push!(xs1245, item1247) - cond1246 = (match_lookahead_literal(parser, ":", 0) || match_lookahead_terminal(parser, "UINT128", 0)) + xs1246 = Proto.RelationId[] + cond1247 = (match_lookahead_literal(parser, ":", 0) || match_lookahead_terminal(parser, "UINT128", 0)) + while cond1247 + _t2004 = parse_relation_id(parser) + item1248 = _t2004 + push!(xs1246, item1248) + cond1247 = (match_lookahead_literal(parser, ":", 0) || match_lookahead_terminal(parser, "UINT128", 0)) end - relation_ids1248 = xs1245 + relation_ids1249 = xs1246 consume_literal!(parser, ")") - _t2003 = Proto.Context(relations=relation_ids1248) - result1250 = _t2003 - record_span!(parser, span_start1249, "Context") - return result1250 + _t2005 = Proto.Context(relations=relation_ids1249) + result1251 = _t2005 + record_span!(parser, span_start1250, "Context") + return result1251 end function parse_snapshot(parser::ParserState)::Proto.Snapshot - span_start1255 = span_start(parser) + span_start1257 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "snapshot") - xs1251 = Proto.SnapshotMapping[] - cond1252 = match_lookahead_literal(parser, "[", 0) - while cond1252 - _t2004 = parse_snapshot_mapping(parser) - item1253 = _t2004 - push!(xs1251, item1253) - cond1252 = match_lookahead_literal(parser, "[", 0) + _t2006 = parse_edb_path(parser) + edb_path1252 = _t2006 + xs1253 = Proto.SnapshotMapping[] + cond1254 = match_lookahead_literal(parser, "[", 0) + while cond1254 + _t2007 = parse_snapshot_mapping(parser) + item1255 = _t2007 + push!(xs1253, item1255) + cond1254 = match_lookahead_literal(parser, "[", 0) end - snapshot_mappings1254 = xs1251 + snapshot_mappings1256 = xs1253 consume_literal!(parser, ")") - _t2005 = Proto.Snapshot(mappings=snapshot_mappings1254) - result1256 = _t2005 - record_span!(parser, span_start1255, "Snapshot") - return result1256 + _t2008 = Proto.Snapshot(mappings=snapshot_mappings1256, prefix=edb_path1252) + result1258 = _t2008 + record_span!(parser, span_start1257, "Snapshot") + return result1258 end function parse_snapshot_mapping(parser::ParserState)::Proto.SnapshotMapping - span_start1259 = span_start(parser) - _t2006 = parse_edb_path(parser) - edb_path1257 = _t2006 - _t2007 = parse_relation_id(parser) - relation_id1258 = _t2007 - _t2008 = Proto.SnapshotMapping(destination_path=edb_path1257, source_relation=relation_id1258) - result1260 = _t2008 - record_span!(parser, span_start1259, "SnapshotMapping") - return result1260 + span_start1261 = span_start(parser) + _t2009 = parse_edb_path(parser) + edb_path1259 = _t2009 + _t2010 = parse_relation_id(parser) + relation_id1260 = _t2010 + _t2011 = Proto.SnapshotMapping(destination_path=edb_path1259, source_relation=relation_id1260) + result1262 = _t2011 + record_span!(parser, span_start1261, "SnapshotMapping") + return result1262 end function parse_epoch_reads(parser::ParserState)::Vector{Proto.Read} consume_literal!(parser, "(") consume_literal!(parser, "reads") - xs1261 = Proto.Read[] - cond1262 = match_lookahead_literal(parser, "(", 0) - while cond1262 - _t2009 = parse_read(parser) - item1263 = _t2009 - push!(xs1261, item1263) - cond1262 = match_lookahead_literal(parser, "(", 0) + xs1263 = Proto.Read[] + cond1264 = match_lookahead_literal(parser, "(", 0) + while cond1264 + _t2012 = parse_read(parser) + item1265 = _t2012 + push!(xs1263, item1265) + cond1264 = match_lookahead_literal(parser, "(", 0) end - reads1264 = xs1261 + reads1266 = xs1263 consume_literal!(parser, ")") - return reads1264 + return reads1266 end function parse_read(parser::ParserState)::Proto.Read - span_start1271 = span_start(parser) + span_start1273 = span_start(parser) if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "what_if", 1) - _t2011 = 2 + _t2014 = 2 else if match_lookahead_literal(parser, "output", 1) - _t2012 = 1 + _t2015 = 1 else if match_lookahead_literal(parser, "export_iceberg", 1) - _t2013 = 4 + _t2016 = 4 else if match_lookahead_literal(parser, "export", 1) - _t2014 = 4 + _t2017 = 4 else if match_lookahead_literal(parser, "demand", 1) - _t2015 = 0 + _t2018 = 0 else if match_lookahead_literal(parser, "abort", 1) - _t2016 = 3 + _t2019 = 3 else - _t2016 = -1 + _t2019 = -1 end - _t2015 = _t2016 + _t2018 = _t2019 end - _t2014 = _t2015 + _t2017 = _t2018 end - _t2013 = _t2014 + _t2016 = _t2017 end - _t2012 = _t2013 + _t2015 = _t2016 end - _t2011 = _t2012 + _t2014 = _t2015 end - _t2010 = _t2011 + _t2013 = _t2014 else - _t2010 = -1 + _t2013 = -1 end - prediction1265 = _t2010 - if prediction1265 == 4 - _t2018 = parse_export(parser) - export1270 = _t2018 - _t2019 = Proto.Read(read_type=OneOf(:var"#export", export1270)) - _t2017 = _t2019 + prediction1267 = _t2013 + if prediction1267 == 4 + _t2021 = parse_export(parser) + export1272 = _t2021 + _t2022 = Proto.Read(read_type=OneOf(:var"#export", export1272)) + _t2020 = _t2022 else - if prediction1265 == 3 - _t2021 = parse_abort(parser) - abort1269 = _t2021 - _t2022 = Proto.Read(read_type=OneOf(:abort, abort1269)) - _t2020 = _t2022 + if prediction1267 == 3 + _t2024 = parse_abort(parser) + abort1271 = _t2024 + _t2025 = Proto.Read(read_type=OneOf(:abort, abort1271)) + _t2023 = _t2025 else - if prediction1265 == 2 - _t2024 = parse_what_if(parser) - what_if1268 = _t2024 - _t2025 = Proto.Read(read_type=OneOf(:what_if, what_if1268)) - _t2023 = _t2025 + if prediction1267 == 2 + _t2027 = parse_what_if(parser) + what_if1270 = _t2027 + _t2028 = Proto.Read(read_type=OneOf(:what_if, what_if1270)) + _t2026 = _t2028 else - if prediction1265 == 1 - _t2027 = parse_output(parser) - output1267 = _t2027 - _t2028 = Proto.Read(read_type=OneOf(:output, output1267)) - _t2026 = _t2028 + if prediction1267 == 1 + _t2030 = parse_output(parser) + output1269 = _t2030 + _t2031 = Proto.Read(read_type=OneOf(:output, output1269)) + _t2029 = _t2031 else - if prediction1265 == 0 - _t2030 = parse_demand(parser) - demand1266 = _t2030 - _t2031 = Proto.Read(read_type=OneOf(:demand, demand1266)) - _t2029 = _t2031 + if prediction1267 == 0 + _t2033 = parse_demand(parser) + demand1268 = _t2033 + _t2034 = Proto.Read(read_type=OneOf(:demand, demand1268)) + _t2032 = _t2034 else throw(ParseError("Unexpected token in read" * ": " * string(lookahead(parser, 0)))) end - _t2026 = _t2029 + _t2029 = _t2032 end - _t2023 = _t2026 + _t2026 = _t2029 end - _t2020 = _t2023 + _t2023 = _t2026 end - _t2017 = _t2020 + _t2020 = _t2023 end - result1272 = _t2017 - record_span!(parser, span_start1271, "Read") - return result1272 + result1274 = _t2020 + record_span!(parser, span_start1273, "Read") + return result1274 end function parse_demand(parser::ParserState)::Proto.Demand - span_start1274 = span_start(parser) + span_start1276 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "demand") - _t2032 = parse_relation_id(parser) - relation_id1273 = _t2032 + _t2035 = parse_relation_id(parser) + relation_id1275 = _t2035 consume_literal!(parser, ")") - _t2033 = Proto.Demand(relation_id=relation_id1273) - result1275 = _t2033 - record_span!(parser, span_start1274, "Demand") - return result1275 + _t2036 = Proto.Demand(relation_id=relation_id1275) + result1277 = _t2036 + record_span!(parser, span_start1276, "Demand") + return result1277 end function parse_output(parser::ParserState)::Proto.Output - span_start1278 = span_start(parser) + span_start1280 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "output") - _t2034 = parse_name(parser) - name1276 = _t2034 - _t2035 = parse_relation_id(parser) - relation_id1277 = _t2035 + _t2037 = parse_name(parser) + name1278 = _t2037 + _t2038 = parse_relation_id(parser) + relation_id1279 = _t2038 consume_literal!(parser, ")") - _t2036 = Proto.Output(name=name1276, relation_id=relation_id1277) - result1279 = _t2036 - record_span!(parser, span_start1278, "Output") - return result1279 + _t2039 = Proto.Output(name=name1278, relation_id=relation_id1279) + result1281 = _t2039 + record_span!(parser, span_start1280, "Output") + return result1281 end function parse_what_if(parser::ParserState)::Proto.WhatIf - span_start1282 = span_start(parser) + span_start1284 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "what_if") - _t2037 = parse_name(parser) - name1280 = _t2037 - _t2038 = parse_epoch(parser) - epoch1281 = _t2038 + _t2040 = parse_name(parser) + name1282 = _t2040 + _t2041 = parse_epoch(parser) + epoch1283 = _t2041 consume_literal!(parser, ")") - _t2039 = Proto.WhatIf(branch=name1280, epoch=epoch1281) - result1283 = _t2039 - record_span!(parser, span_start1282, "WhatIf") - return result1283 + _t2042 = Proto.WhatIf(branch=name1282, epoch=epoch1283) + result1285 = _t2042 + record_span!(parser, span_start1284, "WhatIf") + return result1285 end function parse_abort(parser::ParserState)::Proto.Abort - span_start1286 = span_start(parser) + span_start1288 = 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 + _t2044 = parse_name(parser) + _t2043 = _t2044 else - _t2040 = nothing + _t2043 = nothing end - name1284 = _t2040 - _t2042 = parse_relation_id(parser) - relation_id1285 = _t2042 + name1286 = _t2043 + _t2045 = parse_relation_id(parser) + relation_id1287 = _t2045 consume_literal!(parser, ")") - _t2043 = Proto.Abort(name=(!isnothing(name1284) ? name1284 : "abort"), relation_id=relation_id1285) - result1287 = _t2043 - record_span!(parser, span_start1286, "Abort") - return result1287 + _t2046 = Proto.Abort(name=(!isnothing(name1286) ? name1286 : "abort"), relation_id=relation_id1287) + result1289 = _t2046 + record_span!(parser, span_start1288, "Abort") + return result1289 end function parse_export(parser::ParserState)::Proto.Export - span_start1291 = span_start(parser) + span_start1293 = span_start(parser) if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "export_iceberg", 1) - _t2045 = 1 + _t2048 = 1 else if match_lookahead_literal(parser, "export", 1) - _t2046 = 0 + _t2049 = 0 else - _t2046 = -1 + _t2049 = -1 end - _t2045 = _t2046 + _t2048 = _t2049 end - _t2044 = _t2045 + _t2047 = _t2048 else - _t2044 = -1 + _t2047 = -1 end - prediction1288 = _t2044 - if prediction1288 == 1 + prediction1290 = _t2047 + if prediction1290 == 1 consume_literal!(parser, "(") consume_literal!(parser, "export_iceberg") - _t2048 = parse_export_iceberg_config(parser) - export_iceberg_config1290 = _t2048 + _t2051 = parse_export_iceberg_config(parser) + export_iceberg_config1292 = _t2051 consume_literal!(parser, ")") - _t2049 = Proto.Export(export_config=OneOf(:iceberg_config, export_iceberg_config1290)) - _t2047 = _t2049 + _t2052 = Proto.Export(export_config=OneOf(:iceberg_config, export_iceberg_config1292)) + _t2050 = _t2052 else - if prediction1288 == 0 + if prediction1290 == 0 consume_literal!(parser, "(") consume_literal!(parser, "export") - _t2051 = parse_export_csv_config(parser) - export_csv_config1289 = _t2051 + _t2054 = parse_export_csv_config(parser) + export_csv_config1291 = _t2054 consume_literal!(parser, ")") - _t2052 = Proto.Export(export_config=OneOf(:csv_config, export_csv_config1289)) - _t2050 = _t2052 + _t2055 = Proto.Export(export_config=OneOf(:csv_config, export_csv_config1291)) + _t2053 = _t2055 else throw(ParseError("Unexpected token in export" * ": " * string(lookahead(parser, 0)))) end - _t2047 = _t2050 + _t2050 = _t2053 end - result1292 = _t2047 - record_span!(parser, span_start1291, "Export") - return result1292 + result1294 = _t2050 + record_span!(parser, span_start1293, "Export") + return result1294 end function parse_export_csv_config(parser::ParserState)::Proto.ExportCSVConfig - span_start1300 = span_start(parser) + span_start1302 = span_start(parser) if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "export_csv_config_v2", 1) - _t2054 = 0 + _t2057 = 0 else if match_lookahead_literal(parser, "export_csv_config", 1) - _t2055 = 1 + _t2058 = 1 else - _t2055 = -1 + _t2058 = -1 end - _t2054 = _t2055 + _t2057 = _t2058 end - _t2053 = _t2054 + _t2056 = _t2057 else - _t2053 = -1 + _t2056 = -1 end - prediction1293 = _t2053 - if prediction1293 == 1 + prediction1295 = _t2056 + if prediction1295 == 1 consume_literal!(parser, "(") consume_literal!(parser, "export_csv_config") - _t2057 = parse_export_csv_path(parser) - export_csv_path1297 = _t2057 - _t2058 = parse_export_csv_columns_list(parser) - export_csv_columns_list1298 = _t2058 - _t2059 = parse_config_dict(parser) - config_dict1299 = _t2059 + _t2060 = parse_export_csv_path(parser) + export_csv_path1299 = _t2060 + _t2061 = parse_export_csv_columns_list(parser) + export_csv_columns_list1300 = _t2061 + _t2062 = parse_config_dict(parser) + config_dict1301 = _t2062 consume_literal!(parser, ")") - _t2060 = construct_export_csv_config(parser, export_csv_path1297, export_csv_columns_list1298, config_dict1299) - _t2056 = _t2060 + _t2063 = construct_export_csv_config(parser, export_csv_path1299, export_csv_columns_list1300, config_dict1301) + _t2059 = _t2063 else - if prediction1293 == 0 + if prediction1295 == 0 consume_literal!(parser, "(") consume_literal!(parser, "export_csv_config_v2") - _t2062 = parse_export_csv_path(parser) - export_csv_path1294 = _t2062 - _t2063 = parse_export_csv_source(parser) - export_csv_source1295 = _t2063 - _t2064 = parse_csv_config(parser) - csv_config1296 = _t2064 + _t2065 = parse_export_csv_path(parser) + export_csv_path1296 = _t2065 + _t2066 = parse_export_csv_source(parser) + export_csv_source1297 = _t2066 + _t2067 = parse_csv_config(parser) + csv_config1298 = _t2067 consume_literal!(parser, ")") - _t2065 = construct_export_csv_config_with_source(parser, export_csv_path1294, export_csv_source1295, csv_config1296) - _t2061 = _t2065 + _t2068 = construct_export_csv_config_with_source(parser, export_csv_path1296, export_csv_source1297, csv_config1298) + _t2064 = _t2068 else throw(ParseError("Unexpected token in export_csv_config" * ": " * string(lookahead(parser, 0)))) end - _t2056 = _t2061 + _t2059 = _t2064 end - result1301 = _t2056 - record_span!(parser, span_start1300, "ExportCSVConfig") - return result1301 + result1303 = _t2059 + record_span!(parser, span_start1302, "ExportCSVConfig") + return result1303 end function parse_export_csv_path(parser::ParserState)::String consume_literal!(parser, "(") consume_literal!(parser, "path") - string1302 = consume_terminal!(parser, "STRING") + string1304 = consume_terminal!(parser, "STRING") consume_literal!(parser, ")") - return string1302 + return string1304 end function parse_export_csv_source(parser::ParserState)::Proto.ExportCSVSource - span_start1309 = span_start(parser) + span_start1311 = span_start(parser) if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "table_def", 1) - _t2067 = 1 + _t2070 = 1 else if match_lookahead_literal(parser, "gnf_columns", 1) - _t2068 = 0 + _t2071 = 0 else - _t2068 = -1 + _t2071 = -1 end - _t2067 = _t2068 + _t2070 = _t2071 end - _t2066 = _t2067 + _t2069 = _t2070 else - _t2066 = -1 + _t2069 = -1 end - prediction1303 = _t2066 - if prediction1303 == 1 + prediction1305 = _t2069 + if prediction1305 == 1 consume_literal!(parser, "(") consume_literal!(parser, "table_def") - _t2070 = parse_relation_id(parser) - relation_id1308 = _t2070 + _t2073 = parse_relation_id(parser) + relation_id1310 = _t2073 consume_literal!(parser, ")") - _t2071 = Proto.ExportCSVSource(csv_source=OneOf(:table_def, relation_id1308)) - _t2069 = _t2071 + _t2074 = Proto.ExportCSVSource(csv_source=OneOf(:table_def, relation_id1310)) + _t2072 = _t2074 else - if prediction1303 == 0 + if prediction1305 == 0 consume_literal!(parser, "(") consume_literal!(parser, "gnf_columns") - xs1304 = Proto.ExportCSVColumn[] - cond1305 = match_lookahead_literal(parser, "(", 0) - while cond1305 - _t2073 = parse_export_csv_column(parser) - item1306 = _t2073 - push!(xs1304, item1306) - cond1305 = match_lookahead_literal(parser, "(", 0) + xs1306 = Proto.ExportCSVColumn[] + cond1307 = match_lookahead_literal(parser, "(", 0) + while cond1307 + _t2076 = parse_export_csv_column(parser) + item1308 = _t2076 + push!(xs1306, item1308) + cond1307 = match_lookahead_literal(parser, "(", 0) end - export_csv_columns1307 = xs1304 + export_csv_columns1309 = xs1306 consume_literal!(parser, ")") - _t2074 = Proto.ExportCSVColumns(columns=export_csv_columns1307) - _t2075 = Proto.ExportCSVSource(csv_source=OneOf(:gnf_columns, _t2074)) - _t2072 = _t2075 + _t2077 = Proto.ExportCSVColumns(columns=export_csv_columns1309) + _t2078 = Proto.ExportCSVSource(csv_source=OneOf(:gnf_columns, _t2077)) + _t2075 = _t2078 else throw(ParseError("Unexpected token in export_csv_source" * ": " * string(lookahead(parser, 0)))) end - _t2069 = _t2072 + _t2072 = _t2075 end - result1310 = _t2069 - record_span!(parser, span_start1309, "ExportCSVSource") - return result1310 + result1312 = _t2072 + record_span!(parser, span_start1311, "ExportCSVSource") + return result1312 end function parse_export_csv_column(parser::ParserState)::Proto.ExportCSVColumn - span_start1313 = span_start(parser) + span_start1315 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "column") - string1311 = consume_terminal!(parser, "STRING") - _t2076 = parse_relation_id(parser) - relation_id1312 = _t2076 + string1313 = consume_terminal!(parser, "STRING") + _t2079 = parse_relation_id(parser) + relation_id1314 = _t2079 consume_literal!(parser, ")") - _t2077 = Proto.ExportCSVColumn(column_name=string1311, column_data=relation_id1312) - result1314 = _t2077 - record_span!(parser, span_start1313, "ExportCSVColumn") - return result1314 + _t2080 = Proto.ExportCSVColumn(column_name=string1313, column_data=relation_id1314) + result1316 = _t2080 + record_span!(parser, span_start1315, "ExportCSVColumn") + return result1316 end function parse_export_csv_columns_list(parser::ParserState)::Vector{Proto.ExportCSVColumn} consume_literal!(parser, "(") consume_literal!(parser, "columns") - xs1315 = Proto.ExportCSVColumn[] - cond1316 = match_lookahead_literal(parser, "(", 0) - while cond1316 - _t2078 = parse_export_csv_column(parser) - item1317 = _t2078 - push!(xs1315, item1317) - cond1316 = match_lookahead_literal(parser, "(", 0) + xs1317 = Proto.ExportCSVColumn[] + cond1318 = match_lookahead_literal(parser, "(", 0) + while cond1318 + _t2081 = parse_export_csv_column(parser) + item1319 = _t2081 + push!(xs1317, item1319) + cond1318 = match_lookahead_literal(parser, "(", 0) end - export_csv_columns1318 = xs1315 + export_csv_columns1320 = xs1317 consume_literal!(parser, ")") - return export_csv_columns1318 + return export_csv_columns1320 end function parse_export_iceberg_config(parser::ParserState)::Proto.ExportIcebergConfig - span_start1325 = span_start(parser) + span_start1327 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "export_iceberg_config") - _t2079 = parse_iceberg_locator(parser) - iceberg_locator1319 = _t2079 - _t2080 = parse_iceberg_catalog_config(parser) - iceberg_catalog_config1320 = _t2080 - _t2081 = parse_export_iceberg_table_def(parser) - export_iceberg_table_def1321 = _t2081 - _t2082 = parse_export_iceberg_columns(parser) - export_iceberg_columns1322 = _t2082 - _t2083 = parse_iceberg_table_properties(parser) - iceberg_table_properties1323 = _t2083 + _t2082 = parse_iceberg_locator(parser) + iceberg_locator1321 = _t2082 + _t2083 = parse_iceberg_catalog_config(parser) + iceberg_catalog_config1322 = _t2083 + _t2084 = parse_export_iceberg_table_def(parser) + export_iceberg_table_def1323 = _t2084 + _t2085 = parse_export_iceberg_columns(parser) + export_iceberg_columns1324 = _t2085 + _t2086 = parse_iceberg_table_properties(parser) + iceberg_table_properties1325 = _t2086 if match_lookahead_literal(parser, "{", 0) - _t2085 = parse_config_dict(parser) - _t2084 = _t2085 + _t2088 = parse_config_dict(parser) + _t2087 = _t2088 else - _t2084 = nothing + _t2087 = nothing end - config_dict1324 = _t2084 + config_dict1326 = _t2087 consume_literal!(parser, ")") - _t2086 = construct_export_iceberg_config_full(parser, iceberg_locator1319, iceberg_catalog_config1320, export_iceberg_table_def1321, export_iceberg_columns1322, iceberg_table_properties1323, config_dict1324) - result1326 = _t2086 - record_span!(parser, span_start1325, "ExportIcebergConfig") - return result1326 + _t2089 = construct_export_iceberg_config_full(parser, iceberg_locator1321, iceberg_catalog_config1322, export_iceberg_table_def1323, export_iceberg_columns1324, iceberg_table_properties1325, config_dict1326) + result1328 = _t2089 + record_span!(parser, span_start1327, "ExportIcebergConfig") + return result1328 end function parse_export_iceberg_table_def(parser::ParserState)::Proto.RelationId - span_start1328 = span_start(parser) + span_start1330 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "table_def") - _t2087 = parse_relation_id(parser) - relation_id1327 = _t2087 + _t2090 = parse_relation_id(parser) + relation_id1329 = _t2090 consume_literal!(parser, ")") - result1329 = relation_id1327 - record_span!(parser, span_start1328, "RelationId") - return result1329 + result1331 = relation_id1329 + record_span!(parser, span_start1330, "RelationId") + return result1331 end function parse_export_iceberg_columns(parser::ParserState)::Vector{Proto.ExportColumn} consume_literal!(parser, "(") consume_literal!(parser, "columns") - xs1330 = Proto.ExportColumn[] - cond1331 = match_lookahead_literal(parser, "(", 0) - while cond1331 - _t2088 = parse_export_iceberg_column(parser) - item1332 = _t2088 - push!(xs1330, item1332) - cond1331 = match_lookahead_literal(parser, "(", 0) + xs1332 = Proto.ExportColumn[] + cond1333 = match_lookahead_literal(parser, "(", 0) + while cond1333 + _t2091 = parse_export_iceberg_column(parser) + item1334 = _t2091 + push!(xs1332, item1334) + cond1333 = match_lookahead_literal(parser, "(", 0) end - export_iceberg_columns1333 = xs1330 + export_iceberg_columns1335 = xs1332 consume_literal!(parser, ")") - return export_iceberg_columns1333 + return export_iceberg_columns1335 end function parse_export_iceberg_column(parser::ParserState)::Proto.ExportColumn - span_start1336 = span_start(parser) + span_start1338 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "column") - string1334 = consume_terminal!(parser, "STRING") - _t2089 = parse_boolean_value(parser) - boolean_value1335 = _t2089 + string1336 = consume_terminal!(parser, "STRING") + _t2092 = parse_boolean_value(parser) + boolean_value1337 = _t2092 consume_literal!(parser, ")") - _t2090 = Proto.ExportColumn(name=string1334, nullable=boolean_value1335) - result1337 = _t2090 - record_span!(parser, span_start1336, "ExportColumn") - return result1337 + _t2093 = Proto.ExportColumn(name=string1336, nullable=boolean_value1337) + result1339 = _t2093 + record_span!(parser, span_start1338, "ExportColumn") + return result1339 end function parse_iceberg_table_properties(parser::ParserState)::Vector{Tuple{String, String}} consume_literal!(parser, "(") consume_literal!(parser, "table_properties") - xs1338 = Tuple{String, String}[] - cond1339 = match_lookahead_literal(parser, "(", 0) - while cond1339 - _t2091 = parse_iceberg_property_entry(parser) - item1340 = _t2091 - push!(xs1338, item1340) - cond1339 = match_lookahead_literal(parser, "(", 0) + xs1340 = Tuple{String, String}[] + cond1341 = match_lookahead_literal(parser, "(", 0) + while cond1341 + _t2094 = parse_iceberg_property_entry(parser) + item1342 = _t2094 + push!(xs1340, item1342) + cond1341 = match_lookahead_literal(parser, "(", 0) end - iceberg_property_entrys1341 = xs1338 + iceberg_property_entrys1343 = xs1340 consume_literal!(parser, ")") - return iceberg_property_entrys1341 + return iceberg_property_entrys1343 end diff --git a/sdks/julia/LogicalQueryProtocol.jl/src/pretty.jl b/sdks/julia/LogicalQueryProtocol.jl/src/pretty.jl index 73da8645..7bfca498 100644 --- a/sdks/julia/LogicalQueryProtocol.jl/src/pretty.jl +++ b/sdks/julia/LogicalQueryProtocol.jl/src/pretty.jl @@ -377,151 +377,151 @@ end # --- Helper functions --- function _make_value_int32(pp::PrettyPrinter, v::Int32)::Proto.Value - _t1777 = Proto.Value(value=OneOf(:int32_value, v)) - return _t1777 + _t1781 = Proto.Value(value=OneOf(:int32_value, v)) + return _t1781 end function _make_value_int64(pp::PrettyPrinter, v::Int64)::Proto.Value - _t1778 = Proto.Value(value=OneOf(:int_value, v)) - return _t1778 + _t1782 = Proto.Value(value=OneOf(:int_value, v)) + return _t1782 end function _make_value_float64(pp::PrettyPrinter, v::Float64)::Proto.Value - _t1779 = Proto.Value(value=OneOf(:float_value, v)) - return _t1779 + _t1783 = Proto.Value(value=OneOf(:float_value, v)) + return _t1783 end function _make_value_string(pp::PrettyPrinter, v::String)::Proto.Value - _t1780 = Proto.Value(value=OneOf(:string_value, v)) - return _t1780 + _t1784 = Proto.Value(value=OneOf(:string_value, v)) + return _t1784 end function _make_value_boolean(pp::PrettyPrinter, v::Bool)::Proto.Value - _t1781 = Proto.Value(value=OneOf(:boolean_value, v)) - return _t1781 + _t1785 = Proto.Value(value=OneOf(:boolean_value, v)) + return _t1785 end function _make_value_uint128(pp::PrettyPrinter, v::Proto.UInt128Value)::Proto.Value - _t1782 = Proto.Value(value=OneOf(:uint128_value, v)) - return _t1782 + _t1786 = Proto.Value(value=OneOf(:uint128_value, v)) + return _t1786 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 - _t1783 = _make_value_string(pp, "auto") - push!(result, ("ivm.maintenance_level", _t1783,)) + _t1787 = _make_value_string(pp, "auto") + push!(result, ("ivm.maintenance_level", _t1787,)) else if msg.ivm_config.level == Proto.MaintenanceLevel.MAINTENANCE_LEVEL_ALL - _t1784 = _make_value_string(pp, "all") - push!(result, ("ivm.maintenance_level", _t1784,)) + _t1788 = _make_value_string(pp, "all") + push!(result, ("ivm.maintenance_level", _t1788,)) else if msg.ivm_config.level == Proto.MaintenanceLevel.MAINTENANCE_LEVEL_OFF - _t1785 = _make_value_string(pp, "off") - push!(result, ("ivm.maintenance_level", _t1785,)) + _t1789 = _make_value_string(pp, "off") + push!(result, ("ivm.maintenance_level", _t1789,)) end end end - _t1786 = _make_value_int64(pp, msg.semantics_version) - push!(result, ("semantics_version", _t1786,)) + _t1790 = _make_value_int64(pp, msg.semantics_version) + push!(result, ("semantics_version", _t1790,)) return sort(result) end function deconstruct_csv_config(pp::PrettyPrinter, msg::Proto.CSVConfig)::Vector{Tuple{String, Proto.Value}} result = Tuple{String, Proto.Value}[] - _t1787 = _make_value_int32(pp, msg.header_row) - push!(result, ("csv_header_row", _t1787,)) - _t1788 = _make_value_int64(pp, msg.skip) - push!(result, ("csv_skip", _t1788,)) + _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,)) if msg.new_line != "" - _t1789 = _make_value_string(pp, msg.new_line) - push!(result, ("csv_new_line", _t1789,)) - end - _t1790 = _make_value_string(pp, msg.delimiter) - push!(result, ("csv_delimiter", _t1790,)) - _t1791 = _make_value_string(pp, msg.quotechar) - push!(result, ("csv_quotechar", _t1791,)) - _t1792 = _make_value_string(pp, msg.escapechar) - push!(result, ("csv_escapechar", _t1792,)) + _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,)) if msg.comment != "" - _t1793 = _make_value_string(pp, msg.comment) - push!(result, ("csv_comment", _t1793,)) + _t1797 = _make_value_string(pp, msg.comment) + push!(result, ("csv_comment", _t1797,)) end for missing_string in msg.missing_strings - _t1794 = _make_value_string(pp, missing_string) - push!(result, ("csv_missing_strings", _t1794,)) - end - _t1795 = _make_value_string(pp, msg.decimal_separator) - push!(result, ("csv_decimal_separator", _t1795,)) - _t1796 = _make_value_string(pp, msg.encoding) - push!(result, ("csv_encoding", _t1796,)) - _t1797 = _make_value_string(pp, msg.compression) - push!(result, ("csv_compression", _t1797,)) + _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,)) if msg.partition_size_mb != 0 - _t1798 = _make_value_int64(pp, msg.partition_size_mb) - push!(result, ("csv_partition_size_mb", _t1798,)) + _t1802 = _make_value_int64(pp, msg.partition_size_mb) + push!(result, ("csv_partition_size_mb", _t1802,)) 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}[] - _t1799 = _make_value_float64(pp, msg.storage_config.epsilon) - push!(result, ("betree_config_epsilon", _t1799,)) - _t1800 = _make_value_int64(pp, msg.storage_config.max_pivots) - push!(result, ("betree_config_max_pivots", _t1800,)) - _t1801 = _make_value_int64(pp, msg.storage_config.max_deltas) - push!(result, ("betree_config_max_deltas", _t1801,)) - _t1802 = _make_value_int64(pp, msg.storage_config.max_leaf) - push!(result, ("betree_config_max_leaf", _t1802,)) + _t1803 = _make_value_float64(pp, msg.storage_config.epsilon) + push!(result, ("betree_config_epsilon", _t1803,)) + _t1804 = _make_value_int64(pp, msg.storage_config.max_pivots) + push!(result, ("betree_config_max_pivots", _t1804,)) + _t1805 = _make_value_int64(pp, msg.storage_config.max_deltas) + push!(result, ("betree_config_max_deltas", _t1805,)) + _t1806 = _make_value_int64(pp, msg.storage_config.max_leaf) + push!(result, ("betree_config_max_leaf", _t1806,)) if _has_proto_field(msg.relation_locator, Symbol("root_pageid")) if !isnothing(_get_oneof_field(msg.relation_locator, :root_pageid)) - _t1803 = _make_value_uint128(pp, _get_oneof_field(msg.relation_locator, :root_pageid)) - push!(result, ("betree_locator_root_pageid", _t1803,)) + _t1807 = _make_value_uint128(pp, _get_oneof_field(msg.relation_locator, :root_pageid)) + push!(result, ("betree_locator_root_pageid", _t1807,)) end end if _has_proto_field(msg.relation_locator, Symbol("inline_data")) if !isnothing(_get_oneof_field(msg.relation_locator, :inline_data)) - _t1804 = _make_value_string(pp, String(copy(_get_oneof_field(msg.relation_locator, :inline_data)))) - push!(result, ("betree_locator_inline_data", _t1804,)) + _t1808 = _make_value_string(pp, String(copy(_get_oneof_field(msg.relation_locator, :inline_data)))) + push!(result, ("betree_locator_inline_data", _t1808,)) end end - _t1805 = _make_value_int64(pp, msg.relation_locator.element_count) - push!(result, ("betree_locator_element_count", _t1805,)) - _t1806 = _make_value_int64(pp, msg.relation_locator.tree_height) - push!(result, ("betree_locator_tree_height", _t1806,)) + _t1809 = _make_value_int64(pp, msg.relation_locator.element_count) + push!(result, ("betree_locator_element_count", _t1809,)) + _t1810 = _make_value_int64(pp, msg.relation_locator.tree_height) + push!(result, ("betree_locator_tree_height", _t1810,)) 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) - _t1807 = _make_value_int64(pp, msg.partition_size) - push!(result, ("partition_size", _t1807,)) + _t1811 = _make_value_int64(pp, msg.partition_size) + push!(result, ("partition_size", _t1811,)) end if !isnothing(msg.compression) - _t1808 = _make_value_string(pp, msg.compression) - push!(result, ("compression", _t1808,)) + _t1812 = _make_value_string(pp, msg.compression) + push!(result, ("compression", _t1812,)) end if !isnothing(msg.syntax_header_row) - _t1809 = _make_value_boolean(pp, msg.syntax_header_row) - push!(result, ("syntax_header_row", _t1809,)) + _t1813 = _make_value_boolean(pp, msg.syntax_header_row) + push!(result, ("syntax_header_row", _t1813,)) end if !isnothing(msg.syntax_missing_string) - _t1810 = _make_value_string(pp, msg.syntax_missing_string) - push!(result, ("syntax_missing_string", _t1810,)) + _t1814 = _make_value_string(pp, msg.syntax_missing_string) + push!(result, ("syntax_missing_string", _t1814,)) end if !isnothing(msg.syntax_delim) - _t1811 = _make_value_string(pp, msg.syntax_delim) - push!(result, ("syntax_delim", _t1811,)) + _t1815 = _make_value_string(pp, msg.syntax_delim) + push!(result, ("syntax_delim", _t1815,)) end if !isnothing(msg.syntax_quotechar) - _t1812 = _make_value_string(pp, msg.syntax_quotechar) - push!(result, ("syntax_quotechar", _t1812,)) + _t1816 = _make_value_string(pp, msg.syntax_quotechar) + push!(result, ("syntax_quotechar", _t1816,)) end if !isnothing(msg.syntax_escapechar) - _t1813 = _make_value_string(pp, msg.syntax_escapechar) - push!(result, ("syntax_escapechar", _t1813,)) + _t1817 = _make_value_string(pp, msg.syntax_escapechar) + push!(result, ("syntax_escapechar", _t1817,)) end return sort(result) end @@ -534,7 +534,7 @@ function deconstruct_iceberg_catalog_config_scope_optional(pp::PrettyPrinter, ms if msg.scope != "" return msg.scope else - _t1814 = nothing + _t1818 = nothing end return nothing end @@ -543,7 +543,7 @@ function deconstruct_iceberg_data_from_snapshot_optional(pp::PrettyPrinter, msg: if msg.from_snapshot != "" return msg.from_snapshot else - _t1815 = nothing + _t1819 = nothing end return nothing end @@ -552,7 +552,7 @@ function deconstruct_iceberg_data_to_snapshot_optional(pp::PrettyPrinter, msg::P if msg.to_snapshot != "" return msg.to_snapshot else - _t1816 = nothing + _t1820 = nothing end return nothing end @@ -560,21 +560,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 != "" - _t1817 = _make_value_string(pp, msg.prefix) - push!(result, ("prefix", _t1817,)) + _t1821 = _make_value_string(pp, msg.prefix) + push!(result, ("prefix", _t1821,)) end if msg.target_file_size_bytes != 0 - _t1818 = _make_value_int64(pp, msg.target_file_size_bytes) - push!(result, ("target_file_size_bytes", _t1818,)) + _t1822 = _make_value_int64(pp, msg.target_file_size_bytes) + push!(result, ("target_file_size_bytes", _t1822,)) end if msg.compression != "" - _t1819 = _make_value_string(pp, msg.compression) - push!(result, ("compression", _t1819,)) + _t1823 = _make_value_string(pp, msg.compression) + push!(result, ("compression", _t1823,)) end if length(result) == 0 return nothing else - _t1820 = nothing + _t1824 = nothing end return sort(result) end @@ -589,7 +589,7 @@ function deconstruct_relation_id_uint128(pp::PrettyPrinter, msg::Proto.RelationI if isnothing(name) return relation_id_to_uint128(pp, msg) else - _t1821 = nothing + _t1825 = nothing end return nothing end @@ -608,47 +608,47 @@ end # --- Pretty-print functions --- function pretty_transaction(pp::PrettyPrinter, msg::Proto.Transaction) - flat807 = try_flat(pp, msg, pretty_transaction) - if !isnothing(flat807) - write(pp, flat807) + flat809 = try_flat(pp, msg, pretty_transaction) + if !isnothing(flat809) + write(pp, flat809) return nothing else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("configure")) - _t1596 = _dollar_dollar.configure + _t1600 = _dollar_dollar.configure else - _t1596 = nothing + _t1600 = nothing end if _has_proto_field(_dollar_dollar, Symbol("sync")) - _t1597 = _dollar_dollar.sync + _t1601 = _dollar_dollar.sync else - _t1597 = nothing + _t1601 = nothing end - fields798 = (_t1596, _t1597, _dollar_dollar.epochs,) - unwrapped_fields799 = fields798 + fields800 = (_t1600, _t1601, _dollar_dollar.epochs,) + unwrapped_fields801 = fields800 write(pp, "(transaction") indent_sexp!(pp) - field800 = unwrapped_fields799[1] - if !isnothing(field800) - newline(pp) - opt_val801 = field800 - pretty_configure(pp, opt_val801) - end - field802 = unwrapped_fields799[2] + field802 = unwrapped_fields801[1] if !isnothing(field802) newline(pp) opt_val803 = field802 - pretty_sync(pp, opt_val803) + pretty_configure(pp, opt_val803) + end + field804 = unwrapped_fields801[2] + if !isnothing(field804) + newline(pp) + opt_val805 = field804 + pretty_sync(pp, opt_val805) end - field804 = unwrapped_fields799[3] - if !isempty(field804) + field806 = unwrapped_fields801[3] + if !isempty(field806) newline(pp) - for (i1598, elem805) in enumerate(field804) - i806 = i1598 - 1 - if (i806 > 0) + for (i1602, elem807) in enumerate(field806) + i808 = i1602 - 1 + if (i808 > 0) newline(pp) end - pretty_epoch(pp, elem805) + pretty_epoch(pp, elem807) end end dedent!(pp) @@ -658,19 +658,19 @@ function pretty_transaction(pp::PrettyPrinter, msg::Proto.Transaction) end function pretty_configure(pp::PrettyPrinter, msg::Proto.Configure) - flat810 = try_flat(pp, msg, pretty_configure) - if !isnothing(flat810) - write(pp, flat810) + flat812 = try_flat(pp, msg, pretty_configure) + if !isnothing(flat812) + write(pp, flat812) return nothing else _dollar_dollar = msg - _t1599 = deconstruct_configure(pp, _dollar_dollar) - fields808 = _t1599 - unwrapped_fields809 = fields808 + _t1603 = deconstruct_configure(pp, _dollar_dollar) + fields810 = _t1603 + unwrapped_fields811 = fields810 write(pp, "(configure") indent_sexp!(pp) newline(pp) - pretty_config_dict(pp, unwrapped_fields809) + pretty_config_dict(pp, unwrapped_fields811) dedent!(pp) write(pp, ")") end @@ -678,22 +678,22 @@ function pretty_configure(pp::PrettyPrinter, msg::Proto.Configure) end function pretty_config_dict(pp::PrettyPrinter, msg::Vector{Tuple{String, Proto.Value}}) - flat814 = try_flat(pp, msg, pretty_config_dict) - if !isnothing(flat814) - write(pp, flat814) + flat816 = try_flat(pp, msg, pretty_config_dict) + if !isnothing(flat816) + write(pp, flat816) return nothing else - fields811 = msg + fields813 = msg write(pp, "{") indent!(pp) - if !isempty(fields811) + if !isempty(fields813) newline(pp) - for (i1600, elem812) in enumerate(fields811) - i813 = i1600 - 1 - if (i813 > 0) + for (i1604, elem814) in enumerate(fields813) + i815 = i1604 - 1 + if (i815 > 0) newline(pp) end - pretty_config_key_value(pp, elem812) + pretty_config_key_value(pp, elem814) end end dedent!(pp) @@ -703,163 +703,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}) - flat819 = try_flat(pp, msg, pretty_config_key_value) - if !isnothing(flat819) - write(pp, flat819) + flat821 = try_flat(pp, msg, pretty_config_key_value) + if !isnothing(flat821) + write(pp, flat821) return nothing else _dollar_dollar = msg - fields815 = (_dollar_dollar[1], _dollar_dollar[2],) - unwrapped_fields816 = fields815 + fields817 = (_dollar_dollar[1], _dollar_dollar[2],) + unwrapped_fields818 = fields817 write(pp, ":") - field817 = unwrapped_fields816[1] - write(pp, field817) + field819 = unwrapped_fields818[1] + write(pp, field819) write(pp, " ") - field818 = unwrapped_fields816[2] - pretty_raw_value(pp, field818) + field820 = unwrapped_fields818[2] + pretty_raw_value(pp, field820) end return nothing end function pretty_raw_value(pp::PrettyPrinter, msg::Proto.Value) - flat845 = try_flat(pp, msg, pretty_raw_value) - if !isnothing(flat845) - write(pp, flat845) + flat847 = try_flat(pp, msg, pretty_raw_value) + if !isnothing(flat847) + write(pp, flat847) return nothing else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("date_value")) - _t1601 = _get_oneof_field(_dollar_dollar, :date_value) + _t1605 = _get_oneof_field(_dollar_dollar, :date_value) else - _t1601 = nothing + _t1605 = nothing end - deconstruct_result843 = _t1601 - if !isnothing(deconstruct_result843) - unwrapped844 = deconstruct_result843 - pretty_raw_date(pp, unwrapped844) + deconstruct_result845 = _t1605 + if !isnothing(deconstruct_result845) + unwrapped846 = deconstruct_result845 + pretty_raw_date(pp, unwrapped846) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("datetime_value")) - _t1602 = _get_oneof_field(_dollar_dollar, :datetime_value) + _t1606 = _get_oneof_field(_dollar_dollar, :datetime_value) else - _t1602 = nothing + _t1606 = nothing end - deconstruct_result841 = _t1602 - if !isnothing(deconstruct_result841) - unwrapped842 = deconstruct_result841 - pretty_raw_datetime(pp, unwrapped842) + deconstruct_result843 = _t1606 + if !isnothing(deconstruct_result843) + unwrapped844 = deconstruct_result843 + pretty_raw_datetime(pp, unwrapped844) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("string_value")) - _t1603 = _get_oneof_field(_dollar_dollar, :string_value) + _t1607 = _get_oneof_field(_dollar_dollar, :string_value) else - _t1603 = nothing + _t1607 = nothing end - deconstruct_result839 = _t1603 - if !isnothing(deconstruct_result839) - unwrapped840 = deconstruct_result839 - write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, unwrapped840)) + deconstruct_result841 = _t1607 + if !isnothing(deconstruct_result841) + unwrapped842 = deconstruct_result841 + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, unwrapped842)) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("int32_value")) - _t1604 = _get_oneof_field(_dollar_dollar, :int32_value) + _t1608 = _get_oneof_field(_dollar_dollar, :int32_value) else - _t1604 = nothing + _t1608 = nothing end - deconstruct_result837 = _t1604 - if !isnothing(deconstruct_result837) - unwrapped838 = deconstruct_result837 - write(pp, (string(Int64(unwrapped838)) * "i32")) + deconstruct_result839 = _t1608 + if !isnothing(deconstruct_result839) + unwrapped840 = deconstruct_result839 + write(pp, (string(Int64(unwrapped840)) * "i32")) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("int_value")) - _t1605 = _get_oneof_field(_dollar_dollar, :int_value) + _t1609 = _get_oneof_field(_dollar_dollar, :int_value) else - _t1605 = nothing + _t1609 = nothing end - deconstruct_result835 = _t1605 - if !isnothing(deconstruct_result835) - unwrapped836 = deconstruct_result835 - write(pp, string(unwrapped836)) + deconstruct_result837 = _t1609 + if !isnothing(deconstruct_result837) + unwrapped838 = deconstruct_result837 + write(pp, string(unwrapped838)) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("float32_value")) - _t1606 = _get_oneof_field(_dollar_dollar, :float32_value) + _t1610 = _get_oneof_field(_dollar_dollar, :float32_value) else - _t1606 = nothing + _t1610 = nothing end - deconstruct_result833 = _t1606 - if !isnothing(deconstruct_result833) - unwrapped834 = deconstruct_result833 - write(pp, format_float32_literal(unwrapped834)) + deconstruct_result835 = _t1610 + if !isnothing(deconstruct_result835) + unwrapped836 = deconstruct_result835 + write(pp, format_float32_literal(unwrapped836)) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("float_value")) - _t1607 = _get_oneof_field(_dollar_dollar, :float_value) + _t1611 = _get_oneof_field(_dollar_dollar, :float_value) else - _t1607 = nothing + _t1611 = nothing end - deconstruct_result831 = _t1607 - if !isnothing(deconstruct_result831) - unwrapped832 = deconstruct_result831 - write(pp, lowercase(string(unwrapped832))) + deconstruct_result833 = _t1611 + if !isnothing(deconstruct_result833) + unwrapped834 = deconstruct_result833 + write(pp, lowercase(string(unwrapped834))) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("uint32_value")) - _t1608 = _get_oneof_field(_dollar_dollar, :uint32_value) + _t1612 = _get_oneof_field(_dollar_dollar, :uint32_value) else - _t1608 = nothing + _t1612 = nothing end - deconstruct_result829 = _t1608 - if !isnothing(deconstruct_result829) - unwrapped830 = deconstruct_result829 - write(pp, (string(Int64(unwrapped830)) * "u32")) + deconstruct_result831 = _t1612 + if !isnothing(deconstruct_result831) + unwrapped832 = deconstruct_result831 + write(pp, (string(Int64(unwrapped832)) * "u32")) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("uint128_value")) - _t1609 = _get_oneof_field(_dollar_dollar, :uint128_value) + _t1613 = _get_oneof_field(_dollar_dollar, :uint128_value) else - _t1609 = nothing + _t1613 = nothing end - deconstruct_result827 = _t1609 - if !isnothing(deconstruct_result827) - unwrapped828 = deconstruct_result827 - write(pp, format_uint128(DEFAULT_CONSTANT_FORMATTER, pp, unwrapped828)) + deconstruct_result829 = _t1613 + if !isnothing(deconstruct_result829) + unwrapped830 = deconstruct_result829 + write(pp, format_uint128(DEFAULT_CONSTANT_FORMATTER, pp, unwrapped830)) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("int128_value")) - _t1610 = _get_oneof_field(_dollar_dollar, :int128_value) + _t1614 = _get_oneof_field(_dollar_dollar, :int128_value) else - _t1610 = nothing + _t1614 = nothing end - deconstruct_result825 = _t1610 - if !isnothing(deconstruct_result825) - unwrapped826 = deconstruct_result825 - write(pp, format_int128(DEFAULT_CONSTANT_FORMATTER, pp, unwrapped826)) + deconstruct_result827 = _t1614 + if !isnothing(deconstruct_result827) + unwrapped828 = deconstruct_result827 + write(pp, format_int128(DEFAULT_CONSTANT_FORMATTER, pp, unwrapped828)) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("decimal_value")) - _t1611 = _get_oneof_field(_dollar_dollar, :decimal_value) + _t1615 = _get_oneof_field(_dollar_dollar, :decimal_value) else - _t1611 = nothing + _t1615 = nothing end - deconstruct_result823 = _t1611 - if !isnothing(deconstruct_result823) - unwrapped824 = deconstruct_result823 - write(pp, format_decimal(DEFAULT_CONSTANT_FORMATTER, pp, unwrapped824)) + deconstruct_result825 = _t1615 + if !isnothing(deconstruct_result825) + unwrapped826 = deconstruct_result825 + write(pp, format_decimal(DEFAULT_CONSTANT_FORMATTER, pp, unwrapped826)) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("boolean_value")) - _t1612 = _get_oneof_field(_dollar_dollar, :boolean_value) + _t1616 = _get_oneof_field(_dollar_dollar, :boolean_value) else - _t1612 = nothing + _t1616 = nothing end - deconstruct_result821 = _t1612 - if !isnothing(deconstruct_result821) - unwrapped822 = deconstruct_result821 - pretty_boolean_value(pp, unwrapped822) + deconstruct_result823 = _t1616 + if !isnothing(deconstruct_result823) + unwrapped824 = deconstruct_result823 + pretty_boolean_value(pp, unwrapped824) else - fields820 = msg + fields822 = msg write(pp, "missing") end end @@ -878,25 +878,25 @@ function pretty_raw_value(pp::PrettyPrinter, msg::Proto.Value) end function pretty_raw_date(pp::PrettyPrinter, msg::Proto.DateValue) - flat851 = try_flat(pp, msg, pretty_raw_date) - if !isnothing(flat851) - write(pp, flat851) + flat853 = try_flat(pp, msg, pretty_raw_date) + if !isnothing(flat853) + write(pp, flat853) return nothing else _dollar_dollar = msg - fields846 = (Int64(_dollar_dollar.year), Int64(_dollar_dollar.month), Int64(_dollar_dollar.day),) - unwrapped_fields847 = fields846 + fields848 = (Int64(_dollar_dollar.year), Int64(_dollar_dollar.month), Int64(_dollar_dollar.day),) + unwrapped_fields849 = fields848 write(pp, "(date") indent_sexp!(pp) newline(pp) - field848 = unwrapped_fields847[1] - write(pp, string(field848)) + field850 = unwrapped_fields849[1] + write(pp, string(field850)) newline(pp) - field849 = unwrapped_fields847[2] - write(pp, string(field849)) + field851 = unwrapped_fields849[2] + write(pp, string(field851)) newline(pp) - field850 = unwrapped_fields847[3] - write(pp, string(field850)) + field852 = unwrapped_fields849[3] + write(pp, string(field852)) dedent!(pp) write(pp, ")") end @@ -904,39 +904,39 @@ function pretty_raw_date(pp::PrettyPrinter, msg::Proto.DateValue) end function pretty_raw_datetime(pp::PrettyPrinter, msg::Proto.DateTimeValue) - flat862 = try_flat(pp, msg, pretty_raw_datetime) - if !isnothing(flat862) - write(pp, flat862) + flat864 = try_flat(pp, msg, pretty_raw_datetime) + if !isnothing(flat864) + write(pp, flat864) return nothing else _dollar_dollar = msg - fields852 = (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_fields853 = fields852 + fields854 = (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_fields855 = fields854 write(pp, "(datetime") indent_sexp!(pp) newline(pp) - field854 = unwrapped_fields853[1] - write(pp, string(field854)) - newline(pp) - field855 = unwrapped_fields853[2] - write(pp, string(field855)) - newline(pp) - field856 = unwrapped_fields853[3] + field856 = unwrapped_fields855[1] write(pp, string(field856)) newline(pp) - field857 = unwrapped_fields853[4] + field857 = unwrapped_fields855[2] write(pp, string(field857)) newline(pp) - field858 = unwrapped_fields853[5] + field858 = unwrapped_fields855[3] write(pp, string(field858)) newline(pp) - field859 = unwrapped_fields853[6] + field859 = unwrapped_fields855[4] write(pp, string(field859)) - field860 = unwrapped_fields853[7] - if !isnothing(field860) + newline(pp) + field860 = unwrapped_fields855[5] + write(pp, string(field860)) + newline(pp) + field861 = unwrapped_fields855[6] + write(pp, string(field861)) + field862 = unwrapped_fields855[7] + if !isnothing(field862) newline(pp) - opt_val861 = field860 - write(pp, string(opt_val861)) + opt_val863 = field862 + write(pp, string(opt_val863)) end dedent!(pp) write(pp, ")") @@ -947,24 +947,24 @@ end function pretty_boolean_value(pp::PrettyPrinter, msg::Bool) _dollar_dollar = msg if _dollar_dollar - _t1613 = () + _t1617 = () else - _t1613 = nothing + _t1617 = nothing end - deconstruct_result865 = _t1613 - if !isnothing(deconstruct_result865) - unwrapped866 = deconstruct_result865 + deconstruct_result867 = _t1617 + if !isnothing(deconstruct_result867) + unwrapped868 = deconstruct_result867 write(pp, "true") else _dollar_dollar = msg if !_dollar_dollar - _t1614 = () + _t1618 = () else - _t1614 = nothing + _t1618 = nothing end - deconstruct_result863 = _t1614 - if !isnothing(deconstruct_result863) - unwrapped864 = deconstruct_result863 + deconstruct_result865 = _t1618 + if !isnothing(deconstruct_result865) + unwrapped866 = deconstruct_result865 write(pp, "false") else throw(ParseError("No matching rule for boolean_value")) @@ -974,24 +974,24 @@ function pretty_boolean_value(pp::PrettyPrinter, msg::Bool) end function pretty_sync(pp::PrettyPrinter, msg::Proto.Sync) - flat871 = try_flat(pp, msg, pretty_sync) - if !isnothing(flat871) - write(pp, flat871) + flat873 = try_flat(pp, msg, pretty_sync) + if !isnothing(flat873) + write(pp, flat873) return nothing else _dollar_dollar = msg - fields867 = _dollar_dollar.fragments - unwrapped_fields868 = fields867 + fields869 = _dollar_dollar.fragments + unwrapped_fields870 = fields869 write(pp, "(sync") indent_sexp!(pp) - if !isempty(unwrapped_fields868) + if !isempty(unwrapped_fields870) newline(pp) - for (i1615, elem869) in enumerate(unwrapped_fields868) - i870 = i1615 - 1 - if (i870 > 0) + for (i1619, elem871) in enumerate(unwrapped_fields870) + i872 = i1619 - 1 + if (i872 > 0) newline(pp) end - pretty_fragment_id(pp, elem869) + pretty_fragment_id(pp, elem871) end end dedent!(pp) @@ -1001,52 +1001,52 @@ function pretty_sync(pp::PrettyPrinter, msg::Proto.Sync) end function pretty_fragment_id(pp::PrettyPrinter, msg::Proto.FragmentId) - flat874 = try_flat(pp, msg, pretty_fragment_id) - if !isnothing(flat874) - write(pp, flat874) + flat876 = try_flat(pp, msg, pretty_fragment_id) + if !isnothing(flat876) + write(pp, flat876) return nothing else _dollar_dollar = msg - fields872 = fragment_id_to_string(pp, _dollar_dollar) - unwrapped_fields873 = fields872 + fields874 = fragment_id_to_string(pp, _dollar_dollar) + unwrapped_fields875 = fields874 write(pp, ":") - write(pp, unwrapped_fields873) + write(pp, unwrapped_fields875) end return nothing end function pretty_epoch(pp::PrettyPrinter, msg::Proto.Epoch) - flat881 = try_flat(pp, msg, pretty_epoch) - if !isnothing(flat881) - write(pp, flat881) + flat883 = try_flat(pp, msg, pretty_epoch) + if !isnothing(flat883) + write(pp, flat883) return nothing else _dollar_dollar = msg if !isempty(_dollar_dollar.writes) - _t1616 = _dollar_dollar.writes + _t1620 = _dollar_dollar.writes else - _t1616 = nothing + _t1620 = nothing end if !isempty(_dollar_dollar.reads) - _t1617 = _dollar_dollar.reads + _t1621 = _dollar_dollar.reads else - _t1617 = nothing + _t1621 = nothing end - fields875 = (_t1616, _t1617,) - unwrapped_fields876 = fields875 + fields877 = (_t1620, _t1621,) + unwrapped_fields878 = fields877 write(pp, "(epoch") indent_sexp!(pp) - field877 = unwrapped_fields876[1] - if !isnothing(field877) - newline(pp) - opt_val878 = field877 - pretty_epoch_writes(pp, opt_val878) - end - field879 = unwrapped_fields876[2] + field879 = unwrapped_fields878[1] if !isnothing(field879) newline(pp) opt_val880 = field879 - pretty_epoch_reads(pp, opt_val880) + pretty_epoch_writes(pp, opt_val880) + end + field881 = unwrapped_fields878[2] + if !isnothing(field881) + newline(pp) + opt_val882 = field881 + pretty_epoch_reads(pp, opt_val882) end dedent!(pp) write(pp, ")") @@ -1055,22 +1055,22 @@ function pretty_epoch(pp::PrettyPrinter, msg::Proto.Epoch) end function pretty_epoch_writes(pp::PrettyPrinter, msg::Vector{Proto.Write}) - flat885 = try_flat(pp, msg, pretty_epoch_writes) - if !isnothing(flat885) - write(pp, flat885) + flat887 = try_flat(pp, msg, pretty_epoch_writes) + if !isnothing(flat887) + write(pp, flat887) return nothing else - fields882 = msg + fields884 = msg write(pp, "(writes") indent_sexp!(pp) - if !isempty(fields882) + if !isempty(fields884) newline(pp) - for (i1618, elem883) in enumerate(fields882) - i884 = i1618 - 1 - if (i884 > 0) + for (i1622, elem885) in enumerate(fields884) + i886 = i1622 - 1 + if (i886 > 0) newline(pp) end - pretty_write(pp, elem883) + pretty_write(pp, elem885) end end dedent!(pp) @@ -1080,54 +1080,54 @@ function pretty_epoch_writes(pp::PrettyPrinter, msg::Vector{Proto.Write}) end function pretty_write(pp::PrettyPrinter, msg::Proto.Write) - flat894 = try_flat(pp, msg, pretty_write) - if !isnothing(flat894) - write(pp, flat894) + flat896 = try_flat(pp, msg, pretty_write) + if !isnothing(flat896) + write(pp, flat896) return nothing else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("define")) - _t1619 = _get_oneof_field(_dollar_dollar, :define) + _t1623 = _get_oneof_field(_dollar_dollar, :define) else - _t1619 = nothing + _t1623 = nothing end - deconstruct_result892 = _t1619 - if !isnothing(deconstruct_result892) - unwrapped893 = deconstruct_result892 - pretty_define(pp, unwrapped893) + deconstruct_result894 = _t1623 + if !isnothing(deconstruct_result894) + unwrapped895 = deconstruct_result894 + pretty_define(pp, unwrapped895) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("undefine")) - _t1620 = _get_oneof_field(_dollar_dollar, :undefine) + _t1624 = _get_oneof_field(_dollar_dollar, :undefine) else - _t1620 = nothing + _t1624 = nothing end - deconstruct_result890 = _t1620 - if !isnothing(deconstruct_result890) - unwrapped891 = deconstruct_result890 - pretty_undefine(pp, unwrapped891) + deconstruct_result892 = _t1624 + if !isnothing(deconstruct_result892) + unwrapped893 = deconstruct_result892 + pretty_undefine(pp, unwrapped893) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("context")) - _t1621 = _get_oneof_field(_dollar_dollar, :context) + _t1625 = _get_oneof_field(_dollar_dollar, :context) else - _t1621 = nothing + _t1625 = nothing end - deconstruct_result888 = _t1621 - if !isnothing(deconstruct_result888) - unwrapped889 = deconstruct_result888 - pretty_context(pp, unwrapped889) + deconstruct_result890 = _t1625 + if !isnothing(deconstruct_result890) + unwrapped891 = deconstruct_result890 + pretty_context(pp, unwrapped891) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("snapshot")) - _t1622 = _get_oneof_field(_dollar_dollar, :snapshot) + _t1626 = _get_oneof_field(_dollar_dollar, :snapshot) else - _t1622 = nothing + _t1626 = nothing end - deconstruct_result886 = _t1622 - if !isnothing(deconstruct_result886) - unwrapped887 = deconstruct_result886 - pretty_snapshot(pp, unwrapped887) + deconstruct_result888 = _t1626 + if !isnothing(deconstruct_result888) + unwrapped889 = deconstruct_result888 + pretty_snapshot(pp, unwrapped889) else throw(ParseError("No matching rule for write")) end @@ -1139,18 +1139,18 @@ function pretty_write(pp::PrettyPrinter, msg::Proto.Write) end function pretty_define(pp::PrettyPrinter, msg::Proto.Define) - flat897 = try_flat(pp, msg, pretty_define) - if !isnothing(flat897) - write(pp, flat897) + flat899 = try_flat(pp, msg, pretty_define) + if !isnothing(flat899) + write(pp, flat899) return nothing else _dollar_dollar = msg - fields895 = _dollar_dollar.fragment - unwrapped_fields896 = fields895 + fields897 = _dollar_dollar.fragment + unwrapped_fields898 = fields897 write(pp, "(define") indent_sexp!(pp) newline(pp) - pretty_fragment(pp, unwrapped_fields896) + pretty_fragment(pp, unwrapped_fields898) dedent!(pp) write(pp, ")") end @@ -1158,29 +1158,29 @@ function pretty_define(pp::PrettyPrinter, msg::Proto.Define) end function pretty_fragment(pp::PrettyPrinter, msg::Proto.Fragment) - flat904 = try_flat(pp, msg, pretty_fragment) - if !isnothing(flat904) - write(pp, flat904) + flat906 = try_flat(pp, msg, pretty_fragment) + if !isnothing(flat906) + write(pp, flat906) return nothing else _dollar_dollar = msg start_pretty_fragment(pp, _dollar_dollar) - fields898 = (_dollar_dollar.id, _dollar_dollar.declarations,) - unwrapped_fields899 = fields898 + fields900 = (_dollar_dollar.id, _dollar_dollar.declarations,) + unwrapped_fields901 = fields900 write(pp, "(fragment") indent_sexp!(pp) newline(pp) - field900 = unwrapped_fields899[1] - pretty_new_fragment_id(pp, field900) - field901 = unwrapped_fields899[2] - if !isempty(field901) + field902 = unwrapped_fields901[1] + pretty_new_fragment_id(pp, field902) + field903 = unwrapped_fields901[2] + if !isempty(field903) newline(pp) - for (i1623, elem902) in enumerate(field901) - i903 = i1623 - 1 - if (i903 > 0) + for (i1627, elem904) in enumerate(field903) + i905 = i1627 - 1 + if (i905 > 0) newline(pp) end - pretty_declaration(pp, elem902) + pretty_declaration(pp, elem904) end end dedent!(pp) @@ -1190,66 +1190,66 @@ function pretty_fragment(pp::PrettyPrinter, msg::Proto.Fragment) end function pretty_new_fragment_id(pp::PrettyPrinter, msg::Proto.FragmentId) - flat906 = try_flat(pp, msg, pretty_new_fragment_id) - if !isnothing(flat906) - write(pp, flat906) + flat908 = try_flat(pp, msg, pretty_new_fragment_id) + if !isnothing(flat908) + write(pp, flat908) return nothing else - fields905 = msg - pretty_fragment_id(pp, fields905) + fields907 = msg + pretty_fragment_id(pp, fields907) end return nothing end function pretty_declaration(pp::PrettyPrinter, msg::Proto.Declaration) - flat915 = try_flat(pp, msg, pretty_declaration) - if !isnothing(flat915) - write(pp, flat915) + flat917 = try_flat(pp, msg, pretty_declaration) + if !isnothing(flat917) + write(pp, flat917) return nothing else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("def")) - _t1624 = _get_oneof_field(_dollar_dollar, :def) + _t1628 = _get_oneof_field(_dollar_dollar, :def) else - _t1624 = nothing + _t1628 = nothing end - deconstruct_result913 = _t1624 - if !isnothing(deconstruct_result913) - unwrapped914 = deconstruct_result913 - pretty_def(pp, unwrapped914) + deconstruct_result915 = _t1628 + if !isnothing(deconstruct_result915) + unwrapped916 = deconstruct_result915 + pretty_def(pp, unwrapped916) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("algorithm")) - _t1625 = _get_oneof_field(_dollar_dollar, :algorithm) + _t1629 = _get_oneof_field(_dollar_dollar, :algorithm) else - _t1625 = nothing + _t1629 = nothing end - deconstruct_result911 = _t1625 - if !isnothing(deconstruct_result911) - unwrapped912 = deconstruct_result911 - pretty_algorithm(pp, unwrapped912) + deconstruct_result913 = _t1629 + if !isnothing(deconstruct_result913) + unwrapped914 = deconstruct_result913 + pretty_algorithm(pp, unwrapped914) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("constraint")) - _t1626 = _get_oneof_field(_dollar_dollar, :constraint) + _t1630 = _get_oneof_field(_dollar_dollar, :constraint) else - _t1626 = nothing + _t1630 = nothing end - deconstruct_result909 = _t1626 - if !isnothing(deconstruct_result909) - unwrapped910 = deconstruct_result909 - pretty_constraint(pp, unwrapped910) + deconstruct_result911 = _t1630 + if !isnothing(deconstruct_result911) + unwrapped912 = deconstruct_result911 + pretty_constraint(pp, unwrapped912) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("data")) - _t1627 = _get_oneof_field(_dollar_dollar, :data) + _t1631 = _get_oneof_field(_dollar_dollar, :data) else - _t1627 = nothing + _t1631 = nothing end - deconstruct_result907 = _t1627 - if !isnothing(deconstruct_result907) - unwrapped908 = deconstruct_result907 - pretty_data(pp, unwrapped908) + deconstruct_result909 = _t1631 + if !isnothing(deconstruct_result909) + unwrapped910 = deconstruct_result909 + pretty_data(pp, unwrapped910) else throw(ParseError("No matching rule for declaration")) end @@ -1261,32 +1261,32 @@ function pretty_declaration(pp::PrettyPrinter, msg::Proto.Declaration) end function pretty_def(pp::PrettyPrinter, msg::Proto.Def) - flat922 = try_flat(pp, msg, pretty_def) - if !isnothing(flat922) - write(pp, flat922) + flat924 = try_flat(pp, msg, pretty_def) + if !isnothing(flat924) + write(pp, flat924) return nothing else _dollar_dollar = msg if !isempty(_dollar_dollar.attrs) - _t1628 = _dollar_dollar.attrs + _t1632 = _dollar_dollar.attrs else - _t1628 = nothing + _t1632 = nothing end - fields916 = (_dollar_dollar.name, _dollar_dollar.body, _t1628,) - unwrapped_fields917 = fields916 + fields918 = (_dollar_dollar.name, _dollar_dollar.body, _t1632,) + unwrapped_fields919 = fields918 write(pp, "(def") indent_sexp!(pp) newline(pp) - field918 = unwrapped_fields917[1] - pretty_relation_id(pp, field918) + field920 = unwrapped_fields919[1] + pretty_relation_id(pp, field920) newline(pp) - field919 = unwrapped_fields917[2] - pretty_abstraction(pp, field919) - field920 = unwrapped_fields917[3] - if !isnothing(field920) + field921 = unwrapped_fields919[2] + pretty_abstraction(pp, field921) + field922 = unwrapped_fields919[3] + if !isnothing(field922) newline(pp) - opt_val921 = field920 - pretty_attrs(pp, opt_val921) + opt_val923 = field922 + pretty_attrs(pp, opt_val923) end dedent!(pp) write(pp, ")") @@ -1295,30 +1295,30 @@ function pretty_def(pp::PrettyPrinter, msg::Proto.Def) end function pretty_relation_id(pp::PrettyPrinter, msg::Proto.RelationId) - flat927 = try_flat(pp, msg, pretty_relation_id) - if !isnothing(flat927) - write(pp, flat927) + flat929 = try_flat(pp, msg, pretty_relation_id) + if !isnothing(flat929) + write(pp, flat929) return nothing else _dollar_dollar = msg if !isnothing(relation_id_to_string(pp, _dollar_dollar)) - _t1630 = deconstruct_relation_id_string(pp, _dollar_dollar) - _t1629 = _t1630 + _t1634 = deconstruct_relation_id_string(pp, _dollar_dollar) + _t1633 = _t1634 else - _t1629 = nothing + _t1633 = nothing end - deconstruct_result925 = _t1629 - if !isnothing(deconstruct_result925) - unwrapped926 = deconstruct_result925 + deconstruct_result927 = _t1633 + if !isnothing(deconstruct_result927) + unwrapped928 = deconstruct_result927 write(pp, ":") - write(pp, unwrapped926) + write(pp, unwrapped928) else _dollar_dollar = msg - _t1631 = deconstruct_relation_id_uint128(pp, _dollar_dollar) - deconstruct_result923 = _t1631 - if !isnothing(deconstruct_result923) - unwrapped924 = deconstruct_result923 - write(pp, format_uint128(DEFAULT_CONSTANT_FORMATTER, pp, unwrapped924)) + _t1635 = deconstruct_relation_id_uint128(pp, _dollar_dollar) + deconstruct_result925 = _t1635 + if !isnothing(deconstruct_result925) + unwrapped926 = deconstruct_result925 + write(pp, format_uint128(DEFAULT_CONSTANT_FORMATTER, pp, unwrapped926)) else throw(ParseError("No matching rule for relation_id")) end @@ -1328,22 +1328,22 @@ function pretty_relation_id(pp::PrettyPrinter, msg::Proto.RelationId) end function pretty_abstraction(pp::PrettyPrinter, msg::Proto.Abstraction) - flat932 = try_flat(pp, msg, pretty_abstraction) - if !isnothing(flat932) - write(pp, flat932) + flat934 = try_flat(pp, msg, pretty_abstraction) + if !isnothing(flat934) + write(pp, flat934) return nothing else _dollar_dollar = msg - _t1632 = deconstruct_bindings(pp, _dollar_dollar) - fields928 = (_t1632, _dollar_dollar.value,) - unwrapped_fields929 = fields928 + _t1636 = deconstruct_bindings(pp, _dollar_dollar) + fields930 = (_t1636, _dollar_dollar.value,) + unwrapped_fields931 = fields930 write(pp, "(") indent!(pp) - field930 = unwrapped_fields929[1] - pretty_bindings(pp, field930) + field932 = unwrapped_fields931[1] + pretty_bindings(pp, field932) newline(pp) - field931 = unwrapped_fields929[2] - pretty_formula(pp, field931) + field933 = unwrapped_fields931[2] + pretty_formula(pp, field933) dedent!(pp) write(pp, ")") end @@ -1351,34 +1351,34 @@ function pretty_abstraction(pp::PrettyPrinter, msg::Proto.Abstraction) end function pretty_bindings(pp::PrettyPrinter, msg::Tuple{Vector{Proto.Binding}, Vector{Proto.Binding}}) - flat940 = try_flat(pp, msg, pretty_bindings) - if !isnothing(flat940) - write(pp, flat940) + flat942 = try_flat(pp, msg, pretty_bindings) + if !isnothing(flat942) + write(pp, flat942) return nothing else _dollar_dollar = msg if !isempty(_dollar_dollar[2]) - _t1633 = _dollar_dollar[2] + _t1637 = _dollar_dollar[2] else - _t1633 = nothing + _t1637 = nothing end - fields933 = (_dollar_dollar[1], _t1633,) - unwrapped_fields934 = fields933 + fields935 = (_dollar_dollar[1], _t1637,) + unwrapped_fields936 = fields935 write(pp, "[") indent!(pp) - field935 = unwrapped_fields934[1] - for (i1634, elem936) in enumerate(field935) - i937 = i1634 - 1 - if (i937 > 0) + field937 = unwrapped_fields936[1] + for (i1638, elem938) in enumerate(field937) + i939 = i1638 - 1 + if (i939 > 0) newline(pp) end - pretty_binding(pp, elem936) + pretty_binding(pp, elem938) end - field938 = unwrapped_fields934[2] - if !isnothing(field938) + field940 = unwrapped_fields936[2] + if !isnothing(field940) newline(pp) - opt_val939 = field938 - pretty_value_bindings(pp, opt_val939) + opt_val941 = field940 + pretty_value_bindings(pp, opt_val941) end dedent!(pp) write(pp, "]") @@ -1387,182 +1387,182 @@ function pretty_bindings(pp::PrettyPrinter, msg::Tuple{Vector{Proto.Binding}, Ve end function pretty_binding(pp::PrettyPrinter, msg::Proto.Binding) - flat945 = try_flat(pp, msg, pretty_binding) - if !isnothing(flat945) - write(pp, flat945) + flat947 = try_flat(pp, msg, pretty_binding) + if !isnothing(flat947) + write(pp, flat947) return nothing else _dollar_dollar = msg - fields941 = (_dollar_dollar.var.name, _dollar_dollar.var"#type",) - unwrapped_fields942 = fields941 - field943 = unwrapped_fields942[1] - write(pp, field943) + fields943 = (_dollar_dollar.var.name, _dollar_dollar.var"#type",) + unwrapped_fields944 = fields943 + field945 = unwrapped_fields944[1] + write(pp, field945) write(pp, "::") - field944 = unwrapped_fields942[2] - pretty_type(pp, field944) + field946 = unwrapped_fields944[2] + pretty_type(pp, field946) end return nothing end function pretty_type(pp::PrettyPrinter, msg::Proto.var"#Type") - flat974 = try_flat(pp, msg, pretty_type) - if !isnothing(flat974) - write(pp, flat974) + flat976 = try_flat(pp, msg, pretty_type) + if !isnothing(flat976) + write(pp, flat976) return nothing else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("unspecified_type")) - _t1635 = _get_oneof_field(_dollar_dollar, :unspecified_type) + _t1639 = _get_oneof_field(_dollar_dollar, :unspecified_type) else - _t1635 = nothing + _t1639 = nothing end - deconstruct_result972 = _t1635 - if !isnothing(deconstruct_result972) - unwrapped973 = deconstruct_result972 - pretty_unspecified_type(pp, unwrapped973) + deconstruct_result974 = _t1639 + if !isnothing(deconstruct_result974) + unwrapped975 = deconstruct_result974 + pretty_unspecified_type(pp, unwrapped975) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("string_type")) - _t1636 = _get_oneof_field(_dollar_dollar, :string_type) + _t1640 = _get_oneof_field(_dollar_dollar, :string_type) else - _t1636 = nothing + _t1640 = nothing end - deconstruct_result970 = _t1636 - if !isnothing(deconstruct_result970) - unwrapped971 = deconstruct_result970 - pretty_string_type(pp, unwrapped971) + deconstruct_result972 = _t1640 + if !isnothing(deconstruct_result972) + unwrapped973 = deconstruct_result972 + pretty_string_type(pp, unwrapped973) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("int_type")) - _t1637 = _get_oneof_field(_dollar_dollar, :int_type) + _t1641 = _get_oneof_field(_dollar_dollar, :int_type) else - _t1637 = nothing + _t1641 = nothing end - deconstruct_result968 = _t1637 - if !isnothing(deconstruct_result968) - unwrapped969 = deconstruct_result968 - pretty_int_type(pp, unwrapped969) + deconstruct_result970 = _t1641 + if !isnothing(deconstruct_result970) + unwrapped971 = deconstruct_result970 + pretty_int_type(pp, unwrapped971) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("float_type")) - _t1638 = _get_oneof_field(_dollar_dollar, :float_type) + _t1642 = _get_oneof_field(_dollar_dollar, :float_type) else - _t1638 = nothing + _t1642 = nothing end - deconstruct_result966 = _t1638 - if !isnothing(deconstruct_result966) - unwrapped967 = deconstruct_result966 - pretty_float_type(pp, unwrapped967) + deconstruct_result968 = _t1642 + if !isnothing(deconstruct_result968) + unwrapped969 = deconstruct_result968 + pretty_float_type(pp, unwrapped969) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("uint128_type")) - _t1639 = _get_oneof_field(_dollar_dollar, :uint128_type) + _t1643 = _get_oneof_field(_dollar_dollar, :uint128_type) else - _t1639 = nothing + _t1643 = nothing end - deconstruct_result964 = _t1639 - if !isnothing(deconstruct_result964) - unwrapped965 = deconstruct_result964 - pretty_uint128_type(pp, unwrapped965) + deconstruct_result966 = _t1643 + if !isnothing(deconstruct_result966) + unwrapped967 = deconstruct_result966 + pretty_uint128_type(pp, unwrapped967) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("int128_type")) - _t1640 = _get_oneof_field(_dollar_dollar, :int128_type) + _t1644 = _get_oneof_field(_dollar_dollar, :int128_type) else - _t1640 = nothing + _t1644 = nothing end - deconstruct_result962 = _t1640 - if !isnothing(deconstruct_result962) - unwrapped963 = deconstruct_result962 - pretty_int128_type(pp, unwrapped963) + deconstruct_result964 = _t1644 + if !isnothing(deconstruct_result964) + unwrapped965 = deconstruct_result964 + pretty_int128_type(pp, unwrapped965) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("date_type")) - _t1641 = _get_oneof_field(_dollar_dollar, :date_type) + _t1645 = _get_oneof_field(_dollar_dollar, :date_type) else - _t1641 = nothing + _t1645 = nothing end - deconstruct_result960 = _t1641 - if !isnothing(deconstruct_result960) - unwrapped961 = deconstruct_result960 - pretty_date_type(pp, unwrapped961) + deconstruct_result962 = _t1645 + if !isnothing(deconstruct_result962) + unwrapped963 = deconstruct_result962 + pretty_date_type(pp, unwrapped963) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("datetime_type")) - _t1642 = _get_oneof_field(_dollar_dollar, :datetime_type) + _t1646 = _get_oneof_field(_dollar_dollar, :datetime_type) else - _t1642 = nothing + _t1646 = nothing end - deconstruct_result958 = _t1642 - if !isnothing(deconstruct_result958) - unwrapped959 = deconstruct_result958 - pretty_datetime_type(pp, unwrapped959) + deconstruct_result960 = _t1646 + if !isnothing(deconstruct_result960) + unwrapped961 = deconstruct_result960 + pretty_datetime_type(pp, unwrapped961) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("missing_type")) - _t1643 = _get_oneof_field(_dollar_dollar, :missing_type) + _t1647 = _get_oneof_field(_dollar_dollar, :missing_type) else - _t1643 = nothing + _t1647 = nothing end - deconstruct_result956 = _t1643 - if !isnothing(deconstruct_result956) - unwrapped957 = deconstruct_result956 - pretty_missing_type(pp, unwrapped957) + deconstruct_result958 = _t1647 + if !isnothing(deconstruct_result958) + unwrapped959 = deconstruct_result958 + pretty_missing_type(pp, unwrapped959) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("decimal_type")) - _t1644 = _get_oneof_field(_dollar_dollar, :decimal_type) + _t1648 = _get_oneof_field(_dollar_dollar, :decimal_type) else - _t1644 = nothing + _t1648 = nothing end - deconstruct_result954 = _t1644 - if !isnothing(deconstruct_result954) - unwrapped955 = deconstruct_result954 - pretty_decimal_type(pp, unwrapped955) + deconstruct_result956 = _t1648 + if !isnothing(deconstruct_result956) + unwrapped957 = deconstruct_result956 + pretty_decimal_type(pp, unwrapped957) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("boolean_type")) - _t1645 = _get_oneof_field(_dollar_dollar, :boolean_type) + _t1649 = _get_oneof_field(_dollar_dollar, :boolean_type) else - _t1645 = nothing + _t1649 = nothing end - deconstruct_result952 = _t1645 - if !isnothing(deconstruct_result952) - unwrapped953 = deconstruct_result952 - pretty_boolean_type(pp, unwrapped953) + deconstruct_result954 = _t1649 + if !isnothing(deconstruct_result954) + unwrapped955 = deconstruct_result954 + pretty_boolean_type(pp, unwrapped955) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("int32_type")) - _t1646 = _get_oneof_field(_dollar_dollar, :int32_type) + _t1650 = _get_oneof_field(_dollar_dollar, :int32_type) else - _t1646 = nothing + _t1650 = nothing end - deconstruct_result950 = _t1646 - if !isnothing(deconstruct_result950) - unwrapped951 = deconstruct_result950 - pretty_int32_type(pp, unwrapped951) + deconstruct_result952 = _t1650 + if !isnothing(deconstruct_result952) + unwrapped953 = deconstruct_result952 + pretty_int32_type(pp, unwrapped953) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("float32_type")) - _t1647 = _get_oneof_field(_dollar_dollar, :float32_type) + _t1651 = _get_oneof_field(_dollar_dollar, :float32_type) else - _t1647 = nothing + _t1651 = nothing end - deconstruct_result948 = _t1647 - if !isnothing(deconstruct_result948) - unwrapped949 = deconstruct_result948 - pretty_float32_type(pp, unwrapped949) + deconstruct_result950 = _t1651 + if !isnothing(deconstruct_result950) + unwrapped951 = deconstruct_result950 + pretty_float32_type(pp, unwrapped951) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("uint32_type")) - _t1648 = _get_oneof_field(_dollar_dollar, :uint32_type) + _t1652 = _get_oneof_field(_dollar_dollar, :uint32_type) else - _t1648 = nothing + _t1652 = nothing end - deconstruct_result946 = _t1648 - if !isnothing(deconstruct_result946) - unwrapped947 = deconstruct_result946 - pretty_uint32_type(pp, unwrapped947) + deconstruct_result948 = _t1652 + if !isnothing(deconstruct_result948) + unwrapped949 = deconstruct_result948 + pretty_uint32_type(pp, unwrapped949) else throw(ParseError("No matching rule for type")) end @@ -1584,76 +1584,76 @@ function pretty_type(pp::PrettyPrinter, msg::Proto.var"#Type") end function pretty_unspecified_type(pp::PrettyPrinter, msg::Proto.UnspecifiedType) - fields975 = msg + fields977 = msg write(pp, "UNKNOWN") return nothing end function pretty_string_type(pp::PrettyPrinter, msg::Proto.StringType) - fields976 = msg + fields978 = msg write(pp, "STRING") return nothing end function pretty_int_type(pp::PrettyPrinter, msg::Proto.IntType) - fields977 = msg + fields979 = msg write(pp, "INT") return nothing end function pretty_float_type(pp::PrettyPrinter, msg::Proto.FloatType) - fields978 = msg + fields980 = msg write(pp, "FLOAT") return nothing end function pretty_uint128_type(pp::PrettyPrinter, msg::Proto.UInt128Type) - fields979 = msg + fields981 = msg write(pp, "UINT128") return nothing end function pretty_int128_type(pp::PrettyPrinter, msg::Proto.Int128Type) - fields980 = msg + fields982 = msg write(pp, "INT128") return nothing end function pretty_date_type(pp::PrettyPrinter, msg::Proto.DateType) - fields981 = msg + fields983 = msg write(pp, "DATE") return nothing end function pretty_datetime_type(pp::PrettyPrinter, msg::Proto.DateTimeType) - fields982 = msg + fields984 = msg write(pp, "DATETIME") return nothing end function pretty_missing_type(pp::PrettyPrinter, msg::Proto.MissingType) - fields983 = msg + fields985 = msg write(pp, "MISSING") return nothing end function pretty_decimal_type(pp::PrettyPrinter, msg::Proto.DecimalType) - flat988 = try_flat(pp, msg, pretty_decimal_type) - if !isnothing(flat988) - write(pp, flat988) + flat990 = try_flat(pp, msg, pretty_decimal_type) + if !isnothing(flat990) + write(pp, flat990) return nothing else _dollar_dollar = msg - fields984 = (Int64(_dollar_dollar.precision), Int64(_dollar_dollar.scale),) - unwrapped_fields985 = fields984 + fields986 = (Int64(_dollar_dollar.precision), Int64(_dollar_dollar.scale),) + unwrapped_fields987 = fields986 write(pp, "(DECIMAL") indent_sexp!(pp) newline(pp) - field986 = unwrapped_fields985[1] - write(pp, string(field986)) + field988 = unwrapped_fields987[1] + write(pp, string(field988)) newline(pp) - field987 = unwrapped_fields985[2] - write(pp, string(field987)) + field989 = unwrapped_fields987[2] + write(pp, string(field989)) dedent!(pp) write(pp, ")") end @@ -1661,45 +1661,45 @@ function pretty_decimal_type(pp::PrettyPrinter, msg::Proto.DecimalType) end function pretty_boolean_type(pp::PrettyPrinter, msg::Proto.BooleanType) - fields989 = msg + fields991 = msg write(pp, "BOOLEAN") return nothing end function pretty_int32_type(pp::PrettyPrinter, msg::Proto.Int32Type) - fields990 = msg + fields992 = msg write(pp, "INT32") return nothing end function pretty_float32_type(pp::PrettyPrinter, msg::Proto.Float32Type) - fields991 = msg + fields993 = msg write(pp, "FLOAT32") return nothing end function pretty_uint32_type(pp::PrettyPrinter, msg::Proto.UInt32Type) - fields992 = msg + fields994 = msg write(pp, "UINT32") return nothing end function pretty_value_bindings(pp::PrettyPrinter, msg::Vector{Proto.Binding}) - flat996 = try_flat(pp, msg, pretty_value_bindings) - if !isnothing(flat996) - write(pp, flat996) + flat998 = try_flat(pp, msg, pretty_value_bindings) + if !isnothing(flat998) + write(pp, flat998) return nothing else - fields993 = msg + fields995 = msg write(pp, "|") - if !isempty(fields993) + if !isempty(fields995) write(pp, " ") - for (i1649, elem994) in enumerate(fields993) - i995 = i1649 - 1 - if (i995 > 0) + for (i1653, elem996) in enumerate(fields995) + i997 = i1653 - 1 + if (i997 > 0) newline(pp) end - pretty_binding(pp, elem994) + pretty_binding(pp, elem996) end end end @@ -1707,153 +1707,153 @@ function pretty_value_bindings(pp::PrettyPrinter, msg::Vector{Proto.Binding}) end function pretty_formula(pp::PrettyPrinter, msg::Proto.Formula) - flat1023 = try_flat(pp, msg, pretty_formula) - if !isnothing(flat1023) - write(pp, flat1023) + flat1025 = try_flat(pp, msg, pretty_formula) + if !isnothing(flat1025) + write(pp, flat1025) return nothing else _dollar_dollar = msg if (_has_proto_field(_dollar_dollar, Symbol("conjunction")) && isempty(_get_oneof_field(_dollar_dollar, :conjunction).args)) - _t1650 = _get_oneof_field(_dollar_dollar, :conjunction) + _t1654 = _get_oneof_field(_dollar_dollar, :conjunction) else - _t1650 = nothing + _t1654 = nothing end - deconstruct_result1021 = _t1650 - if !isnothing(deconstruct_result1021) - unwrapped1022 = deconstruct_result1021 - pretty_true(pp, unwrapped1022) + deconstruct_result1023 = _t1654 + if !isnothing(deconstruct_result1023) + unwrapped1024 = deconstruct_result1023 + pretty_true(pp, unwrapped1024) else _dollar_dollar = msg if (_has_proto_field(_dollar_dollar, Symbol("disjunction")) && isempty(_get_oneof_field(_dollar_dollar, :disjunction).args)) - _t1651 = _get_oneof_field(_dollar_dollar, :disjunction) + _t1655 = _get_oneof_field(_dollar_dollar, :disjunction) else - _t1651 = nothing + _t1655 = nothing end - deconstruct_result1019 = _t1651 - if !isnothing(deconstruct_result1019) - unwrapped1020 = deconstruct_result1019 - pretty_false(pp, unwrapped1020) + deconstruct_result1021 = _t1655 + if !isnothing(deconstruct_result1021) + unwrapped1022 = deconstruct_result1021 + pretty_false(pp, unwrapped1022) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("exists")) - _t1652 = _get_oneof_field(_dollar_dollar, :exists) + _t1656 = _get_oneof_field(_dollar_dollar, :exists) else - _t1652 = nothing + _t1656 = nothing end - deconstruct_result1017 = _t1652 - if !isnothing(deconstruct_result1017) - unwrapped1018 = deconstruct_result1017 - pretty_exists(pp, unwrapped1018) + deconstruct_result1019 = _t1656 + if !isnothing(deconstruct_result1019) + unwrapped1020 = deconstruct_result1019 + pretty_exists(pp, unwrapped1020) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("reduce")) - _t1653 = _get_oneof_field(_dollar_dollar, :reduce) + _t1657 = _get_oneof_field(_dollar_dollar, :reduce) else - _t1653 = nothing + _t1657 = nothing end - deconstruct_result1015 = _t1653 - if !isnothing(deconstruct_result1015) - unwrapped1016 = deconstruct_result1015 - pretty_reduce(pp, unwrapped1016) + deconstruct_result1017 = _t1657 + if !isnothing(deconstruct_result1017) + unwrapped1018 = deconstruct_result1017 + pretty_reduce(pp, unwrapped1018) else _dollar_dollar = msg if (_has_proto_field(_dollar_dollar, Symbol("conjunction")) && !isempty(_get_oneof_field(_dollar_dollar, :conjunction).args)) - _t1654 = _get_oneof_field(_dollar_dollar, :conjunction) + _t1658 = _get_oneof_field(_dollar_dollar, :conjunction) else - _t1654 = nothing + _t1658 = nothing end - deconstruct_result1013 = _t1654 - if !isnothing(deconstruct_result1013) - unwrapped1014 = deconstruct_result1013 - pretty_conjunction(pp, unwrapped1014) + deconstruct_result1015 = _t1658 + if !isnothing(deconstruct_result1015) + unwrapped1016 = deconstruct_result1015 + pretty_conjunction(pp, unwrapped1016) else _dollar_dollar = msg if (_has_proto_field(_dollar_dollar, Symbol("disjunction")) && !isempty(_get_oneof_field(_dollar_dollar, :disjunction).args)) - _t1655 = _get_oneof_field(_dollar_dollar, :disjunction) + _t1659 = _get_oneof_field(_dollar_dollar, :disjunction) else - _t1655 = nothing + _t1659 = nothing end - deconstruct_result1011 = _t1655 - if !isnothing(deconstruct_result1011) - unwrapped1012 = deconstruct_result1011 - pretty_disjunction(pp, unwrapped1012) + deconstruct_result1013 = _t1659 + if !isnothing(deconstruct_result1013) + unwrapped1014 = deconstruct_result1013 + pretty_disjunction(pp, unwrapped1014) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("not")) - _t1656 = _get_oneof_field(_dollar_dollar, :not) + _t1660 = _get_oneof_field(_dollar_dollar, :not) else - _t1656 = nothing + _t1660 = nothing end - deconstruct_result1009 = _t1656 - if !isnothing(deconstruct_result1009) - unwrapped1010 = deconstruct_result1009 - pretty_not(pp, unwrapped1010) + deconstruct_result1011 = _t1660 + if !isnothing(deconstruct_result1011) + unwrapped1012 = deconstruct_result1011 + pretty_not(pp, unwrapped1012) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("ffi")) - _t1657 = _get_oneof_field(_dollar_dollar, :ffi) + _t1661 = _get_oneof_field(_dollar_dollar, :ffi) else - _t1657 = nothing + _t1661 = nothing end - deconstruct_result1007 = _t1657 - if !isnothing(deconstruct_result1007) - unwrapped1008 = deconstruct_result1007 - pretty_ffi(pp, unwrapped1008) + deconstruct_result1009 = _t1661 + if !isnothing(deconstruct_result1009) + unwrapped1010 = deconstruct_result1009 + pretty_ffi(pp, unwrapped1010) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("atom")) - _t1658 = _get_oneof_field(_dollar_dollar, :atom) + _t1662 = _get_oneof_field(_dollar_dollar, :atom) else - _t1658 = nothing + _t1662 = nothing end - deconstruct_result1005 = _t1658 - if !isnothing(deconstruct_result1005) - unwrapped1006 = deconstruct_result1005 - pretty_atom(pp, unwrapped1006) + deconstruct_result1007 = _t1662 + if !isnothing(deconstruct_result1007) + unwrapped1008 = deconstruct_result1007 + pretty_atom(pp, unwrapped1008) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("pragma")) - _t1659 = _get_oneof_field(_dollar_dollar, :pragma) + _t1663 = _get_oneof_field(_dollar_dollar, :pragma) else - _t1659 = nothing + _t1663 = nothing end - deconstruct_result1003 = _t1659 - if !isnothing(deconstruct_result1003) - unwrapped1004 = deconstruct_result1003 - pretty_pragma(pp, unwrapped1004) + deconstruct_result1005 = _t1663 + if !isnothing(deconstruct_result1005) + unwrapped1006 = deconstruct_result1005 + pretty_pragma(pp, unwrapped1006) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("primitive")) - _t1660 = _get_oneof_field(_dollar_dollar, :primitive) + _t1664 = _get_oneof_field(_dollar_dollar, :primitive) else - _t1660 = nothing + _t1664 = nothing end - deconstruct_result1001 = _t1660 - if !isnothing(deconstruct_result1001) - unwrapped1002 = deconstruct_result1001 - pretty_primitive(pp, unwrapped1002) + deconstruct_result1003 = _t1664 + if !isnothing(deconstruct_result1003) + unwrapped1004 = deconstruct_result1003 + pretty_primitive(pp, unwrapped1004) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("rel_atom")) - _t1661 = _get_oneof_field(_dollar_dollar, :rel_atom) + _t1665 = _get_oneof_field(_dollar_dollar, :rel_atom) else - _t1661 = nothing + _t1665 = nothing end - deconstruct_result999 = _t1661 - if !isnothing(deconstruct_result999) - unwrapped1000 = deconstruct_result999 - pretty_rel_atom(pp, unwrapped1000) + deconstruct_result1001 = _t1665 + if !isnothing(deconstruct_result1001) + unwrapped1002 = deconstruct_result1001 + pretty_rel_atom(pp, unwrapped1002) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("cast")) - _t1662 = _get_oneof_field(_dollar_dollar, :cast) + _t1666 = _get_oneof_field(_dollar_dollar, :cast) else - _t1662 = nothing + _t1666 = nothing end - deconstruct_result997 = _t1662 - if !isnothing(deconstruct_result997) - unwrapped998 = deconstruct_result997 - pretty_cast(pp, unwrapped998) + deconstruct_result999 = _t1666 + if !isnothing(deconstruct_result999) + unwrapped1000 = deconstruct_result999 + pretty_cast(pp, unwrapped1000) else throw(ParseError("No matching rule for formula")) end @@ -1874,35 +1874,35 @@ function pretty_formula(pp::PrettyPrinter, msg::Proto.Formula) end function pretty_true(pp::PrettyPrinter, msg::Proto.Conjunction) - fields1024 = msg + fields1026 = msg write(pp, "(true)") return nothing end function pretty_false(pp::PrettyPrinter, msg::Proto.Disjunction) - fields1025 = msg + fields1027 = msg write(pp, "(false)") return nothing end function pretty_exists(pp::PrettyPrinter, msg::Proto.Exists) - flat1030 = try_flat(pp, msg, pretty_exists) - if !isnothing(flat1030) - write(pp, flat1030) + flat1032 = try_flat(pp, msg, pretty_exists) + if !isnothing(flat1032) + write(pp, flat1032) return nothing else _dollar_dollar = msg - _t1663 = deconstruct_bindings(pp, _dollar_dollar.body) - fields1026 = (_t1663, _dollar_dollar.body.value,) - unwrapped_fields1027 = fields1026 + _t1667 = deconstruct_bindings(pp, _dollar_dollar.body) + fields1028 = (_t1667, _dollar_dollar.body.value,) + unwrapped_fields1029 = fields1028 write(pp, "(exists") indent_sexp!(pp) newline(pp) - field1028 = unwrapped_fields1027[1] - pretty_bindings(pp, field1028) + field1030 = unwrapped_fields1029[1] + pretty_bindings(pp, field1030) newline(pp) - field1029 = unwrapped_fields1027[2] - pretty_formula(pp, field1029) + field1031 = unwrapped_fields1029[2] + pretty_formula(pp, field1031) dedent!(pp) write(pp, ")") end @@ -1910,25 +1910,25 @@ function pretty_exists(pp::PrettyPrinter, msg::Proto.Exists) end function pretty_reduce(pp::PrettyPrinter, msg::Proto.Reduce) - flat1036 = try_flat(pp, msg, pretty_reduce) - if !isnothing(flat1036) - write(pp, flat1036) + flat1038 = try_flat(pp, msg, pretty_reduce) + if !isnothing(flat1038) + write(pp, flat1038) return nothing else _dollar_dollar = msg - fields1031 = (_dollar_dollar.op, _dollar_dollar.body, _dollar_dollar.terms,) - unwrapped_fields1032 = fields1031 + fields1033 = (_dollar_dollar.op, _dollar_dollar.body, _dollar_dollar.terms,) + unwrapped_fields1034 = fields1033 write(pp, "(reduce") indent_sexp!(pp) newline(pp) - field1033 = unwrapped_fields1032[1] - pretty_abstraction(pp, field1033) + field1035 = unwrapped_fields1034[1] + pretty_abstraction(pp, field1035) newline(pp) - field1034 = unwrapped_fields1032[2] - pretty_abstraction(pp, field1034) + field1036 = unwrapped_fields1034[2] + pretty_abstraction(pp, field1036) newline(pp) - field1035 = unwrapped_fields1032[3] - pretty_terms(pp, field1035) + field1037 = unwrapped_fields1034[3] + pretty_terms(pp, field1037) dedent!(pp) write(pp, ")") end @@ -1936,22 +1936,22 @@ function pretty_reduce(pp::PrettyPrinter, msg::Proto.Reduce) end function pretty_terms(pp::PrettyPrinter, msg::Vector{Proto.Term}) - flat1040 = try_flat(pp, msg, pretty_terms) - if !isnothing(flat1040) - write(pp, flat1040) + flat1042 = try_flat(pp, msg, pretty_terms) + if !isnothing(flat1042) + write(pp, flat1042) return nothing else - fields1037 = msg + fields1039 = msg write(pp, "(terms") indent_sexp!(pp) - if !isempty(fields1037) + if !isempty(fields1039) newline(pp) - for (i1664, elem1038) in enumerate(fields1037) - i1039 = i1664 - 1 - if (i1039 > 0) + for (i1668, elem1040) in enumerate(fields1039) + i1041 = i1668 - 1 + if (i1041 > 0) newline(pp) end - pretty_term(pp, elem1038) + pretty_term(pp, elem1040) end end dedent!(pp) @@ -1961,32 +1961,32 @@ function pretty_terms(pp::PrettyPrinter, msg::Vector{Proto.Term}) end function pretty_term(pp::PrettyPrinter, msg::Proto.Term) - flat1045 = try_flat(pp, msg, pretty_term) - if !isnothing(flat1045) - write(pp, flat1045) + flat1047 = try_flat(pp, msg, pretty_term) + if !isnothing(flat1047) + write(pp, flat1047) return nothing else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("var")) - _t1665 = _get_oneof_field(_dollar_dollar, :var) + _t1669 = _get_oneof_field(_dollar_dollar, :var) else - _t1665 = nothing + _t1669 = nothing end - deconstruct_result1043 = _t1665 - if !isnothing(deconstruct_result1043) - unwrapped1044 = deconstruct_result1043 - pretty_var(pp, unwrapped1044) + deconstruct_result1045 = _t1669 + if !isnothing(deconstruct_result1045) + unwrapped1046 = deconstruct_result1045 + pretty_var(pp, unwrapped1046) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("constant")) - _t1666 = _get_oneof_field(_dollar_dollar, :constant) + _t1670 = _get_oneof_field(_dollar_dollar, :constant) else - _t1666 = nothing + _t1670 = nothing end - deconstruct_result1041 = _t1666 - if !isnothing(deconstruct_result1041) - unwrapped1042 = deconstruct_result1041 - pretty_value(pp, unwrapped1042) + deconstruct_result1043 = _t1670 + if !isnothing(deconstruct_result1043) + unwrapped1044 = deconstruct_result1043 + pretty_value(pp, unwrapped1044) else throw(ParseError("No matching rule for term")) end @@ -1996,158 +1996,158 @@ function pretty_term(pp::PrettyPrinter, msg::Proto.Term) end function pretty_var(pp::PrettyPrinter, msg::Proto.Var) - flat1048 = try_flat(pp, msg, pretty_var) - if !isnothing(flat1048) - write(pp, flat1048) + flat1050 = try_flat(pp, msg, pretty_var) + if !isnothing(flat1050) + write(pp, flat1050) return nothing else _dollar_dollar = msg - fields1046 = _dollar_dollar.name - unwrapped_fields1047 = fields1046 - write(pp, unwrapped_fields1047) + fields1048 = _dollar_dollar.name + unwrapped_fields1049 = fields1048 + write(pp, unwrapped_fields1049) end return nothing end function pretty_value(pp::PrettyPrinter, msg::Proto.Value) - flat1074 = try_flat(pp, msg, pretty_value) - if !isnothing(flat1074) - write(pp, flat1074) + flat1076 = try_flat(pp, msg, pretty_value) + if !isnothing(flat1076) + write(pp, flat1076) return nothing else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("date_value")) - _t1667 = _get_oneof_field(_dollar_dollar, :date_value) + _t1671 = _get_oneof_field(_dollar_dollar, :date_value) else - _t1667 = nothing + _t1671 = nothing end - deconstruct_result1072 = _t1667 - if !isnothing(deconstruct_result1072) - unwrapped1073 = deconstruct_result1072 - pretty_date(pp, unwrapped1073) + deconstruct_result1074 = _t1671 + if !isnothing(deconstruct_result1074) + unwrapped1075 = deconstruct_result1074 + pretty_date(pp, unwrapped1075) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("datetime_value")) - _t1668 = _get_oneof_field(_dollar_dollar, :datetime_value) + _t1672 = _get_oneof_field(_dollar_dollar, :datetime_value) else - _t1668 = nothing + _t1672 = nothing end - deconstruct_result1070 = _t1668 - if !isnothing(deconstruct_result1070) - unwrapped1071 = deconstruct_result1070 - pretty_datetime(pp, unwrapped1071) + deconstruct_result1072 = _t1672 + if !isnothing(deconstruct_result1072) + unwrapped1073 = deconstruct_result1072 + pretty_datetime(pp, unwrapped1073) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("string_value")) - _t1669 = _get_oneof_field(_dollar_dollar, :string_value) + _t1673 = _get_oneof_field(_dollar_dollar, :string_value) else - _t1669 = nothing + _t1673 = nothing end - deconstruct_result1068 = _t1669 - if !isnothing(deconstruct_result1068) - unwrapped1069 = deconstruct_result1068 - write(pp, format_string(pp, unwrapped1069)) + deconstruct_result1070 = _t1673 + if !isnothing(deconstruct_result1070) + unwrapped1071 = deconstruct_result1070 + write(pp, format_string(pp, unwrapped1071)) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("int32_value")) - _t1670 = _get_oneof_field(_dollar_dollar, :int32_value) + _t1674 = _get_oneof_field(_dollar_dollar, :int32_value) else - _t1670 = nothing + _t1674 = nothing end - deconstruct_result1066 = _t1670 - if !isnothing(deconstruct_result1066) - unwrapped1067 = deconstruct_result1066 - write(pp, format_int32(pp, unwrapped1067)) + deconstruct_result1068 = _t1674 + if !isnothing(deconstruct_result1068) + unwrapped1069 = deconstruct_result1068 + write(pp, format_int32(pp, unwrapped1069)) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("int_value")) - _t1671 = _get_oneof_field(_dollar_dollar, :int_value) + _t1675 = _get_oneof_field(_dollar_dollar, :int_value) else - _t1671 = nothing + _t1675 = nothing end - deconstruct_result1064 = _t1671 - if !isnothing(deconstruct_result1064) - unwrapped1065 = deconstruct_result1064 - write(pp, format_int(pp, unwrapped1065)) + deconstruct_result1066 = _t1675 + if !isnothing(deconstruct_result1066) + unwrapped1067 = deconstruct_result1066 + write(pp, format_int(pp, unwrapped1067)) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("float32_value")) - _t1672 = _get_oneof_field(_dollar_dollar, :float32_value) + _t1676 = _get_oneof_field(_dollar_dollar, :float32_value) else - _t1672 = nothing + _t1676 = nothing end - deconstruct_result1062 = _t1672 - if !isnothing(deconstruct_result1062) - unwrapped1063 = deconstruct_result1062 - write(pp, format_float32(pp, unwrapped1063)) + deconstruct_result1064 = _t1676 + if !isnothing(deconstruct_result1064) + unwrapped1065 = deconstruct_result1064 + write(pp, format_float32(pp, unwrapped1065)) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("float_value")) - _t1673 = _get_oneof_field(_dollar_dollar, :float_value) + _t1677 = _get_oneof_field(_dollar_dollar, :float_value) else - _t1673 = nothing + _t1677 = nothing end - deconstruct_result1060 = _t1673 - if !isnothing(deconstruct_result1060) - unwrapped1061 = deconstruct_result1060 - write(pp, format_float(pp, unwrapped1061)) + deconstruct_result1062 = _t1677 + if !isnothing(deconstruct_result1062) + unwrapped1063 = deconstruct_result1062 + write(pp, format_float(pp, unwrapped1063)) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("uint32_value")) - _t1674 = _get_oneof_field(_dollar_dollar, :uint32_value) + _t1678 = _get_oneof_field(_dollar_dollar, :uint32_value) else - _t1674 = nothing + _t1678 = nothing end - deconstruct_result1058 = _t1674 - if !isnothing(deconstruct_result1058) - unwrapped1059 = deconstruct_result1058 - write(pp, format_uint32(pp, unwrapped1059)) + deconstruct_result1060 = _t1678 + if !isnothing(deconstruct_result1060) + unwrapped1061 = deconstruct_result1060 + write(pp, format_uint32(pp, unwrapped1061)) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("uint128_value")) - _t1675 = _get_oneof_field(_dollar_dollar, :uint128_value) + _t1679 = _get_oneof_field(_dollar_dollar, :uint128_value) else - _t1675 = nothing + _t1679 = nothing end - deconstruct_result1056 = _t1675 - if !isnothing(deconstruct_result1056) - unwrapped1057 = deconstruct_result1056 - write(pp, format_uint128(pp, unwrapped1057)) + deconstruct_result1058 = _t1679 + if !isnothing(deconstruct_result1058) + unwrapped1059 = deconstruct_result1058 + write(pp, format_uint128(pp, unwrapped1059)) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("int128_value")) - _t1676 = _get_oneof_field(_dollar_dollar, :int128_value) + _t1680 = _get_oneof_field(_dollar_dollar, :int128_value) else - _t1676 = nothing + _t1680 = nothing end - deconstruct_result1054 = _t1676 - if !isnothing(deconstruct_result1054) - unwrapped1055 = deconstruct_result1054 - write(pp, format_int128(pp, unwrapped1055)) + deconstruct_result1056 = _t1680 + if !isnothing(deconstruct_result1056) + unwrapped1057 = deconstruct_result1056 + write(pp, format_int128(pp, unwrapped1057)) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("decimal_value")) - _t1677 = _get_oneof_field(_dollar_dollar, :decimal_value) + _t1681 = _get_oneof_field(_dollar_dollar, :decimal_value) else - _t1677 = nothing + _t1681 = nothing end - deconstruct_result1052 = _t1677 - if !isnothing(deconstruct_result1052) - unwrapped1053 = deconstruct_result1052 - write(pp, format_decimal(pp, unwrapped1053)) + deconstruct_result1054 = _t1681 + if !isnothing(deconstruct_result1054) + unwrapped1055 = deconstruct_result1054 + write(pp, format_decimal(pp, unwrapped1055)) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("boolean_value")) - _t1678 = _get_oneof_field(_dollar_dollar, :boolean_value) + _t1682 = _get_oneof_field(_dollar_dollar, :boolean_value) else - _t1678 = nothing + _t1682 = nothing end - deconstruct_result1050 = _t1678 - if !isnothing(deconstruct_result1050) - unwrapped1051 = deconstruct_result1050 - pretty_boolean_value(pp, unwrapped1051) + deconstruct_result1052 = _t1682 + if !isnothing(deconstruct_result1052) + unwrapped1053 = deconstruct_result1052 + pretty_boolean_value(pp, unwrapped1053) else - fields1049 = msg + fields1051 = msg write(pp, "missing") end end @@ -2166,25 +2166,25 @@ function pretty_value(pp::PrettyPrinter, msg::Proto.Value) end function pretty_date(pp::PrettyPrinter, msg::Proto.DateValue) - flat1080 = try_flat(pp, msg, pretty_date) - if !isnothing(flat1080) - write(pp, flat1080) + flat1082 = try_flat(pp, msg, pretty_date) + if !isnothing(flat1082) + write(pp, flat1082) return nothing else _dollar_dollar = msg - fields1075 = (Int64(_dollar_dollar.year), Int64(_dollar_dollar.month), Int64(_dollar_dollar.day),) - unwrapped_fields1076 = fields1075 + fields1077 = (Int64(_dollar_dollar.year), Int64(_dollar_dollar.month), Int64(_dollar_dollar.day),) + unwrapped_fields1078 = fields1077 write(pp, "(date") indent_sexp!(pp) newline(pp) - field1077 = unwrapped_fields1076[1] - write(pp, format_int(pp, field1077)) + field1079 = unwrapped_fields1078[1] + write(pp, format_int(pp, field1079)) newline(pp) - field1078 = unwrapped_fields1076[2] - write(pp, format_int(pp, field1078)) + field1080 = unwrapped_fields1078[2] + write(pp, format_int(pp, field1080)) newline(pp) - field1079 = unwrapped_fields1076[3] - write(pp, format_int(pp, field1079)) + field1081 = unwrapped_fields1078[3] + write(pp, format_int(pp, field1081)) dedent!(pp) write(pp, ")") end @@ -2192,39 +2192,39 @@ function pretty_date(pp::PrettyPrinter, msg::Proto.DateValue) end function pretty_datetime(pp::PrettyPrinter, msg::Proto.DateTimeValue) - flat1091 = try_flat(pp, msg, pretty_datetime) - if !isnothing(flat1091) - write(pp, flat1091) + flat1093 = try_flat(pp, msg, pretty_datetime) + if !isnothing(flat1093) + write(pp, flat1093) return nothing else _dollar_dollar = msg - fields1081 = (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_fields1082 = fields1081 + fields1083 = (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_fields1084 = fields1083 write(pp, "(datetime") indent_sexp!(pp) newline(pp) - field1083 = unwrapped_fields1082[1] - write(pp, format_int(pp, field1083)) - newline(pp) - field1084 = unwrapped_fields1082[2] - write(pp, format_int(pp, field1084)) - newline(pp) - field1085 = unwrapped_fields1082[3] + field1085 = unwrapped_fields1084[1] write(pp, format_int(pp, field1085)) newline(pp) - field1086 = unwrapped_fields1082[4] + field1086 = unwrapped_fields1084[2] write(pp, format_int(pp, field1086)) newline(pp) - field1087 = unwrapped_fields1082[5] + field1087 = unwrapped_fields1084[3] write(pp, format_int(pp, field1087)) newline(pp) - field1088 = unwrapped_fields1082[6] + field1088 = unwrapped_fields1084[4] write(pp, format_int(pp, field1088)) - field1089 = unwrapped_fields1082[7] - if !isnothing(field1089) + newline(pp) + field1089 = unwrapped_fields1084[5] + write(pp, format_int(pp, field1089)) + newline(pp) + field1090 = unwrapped_fields1084[6] + write(pp, format_int(pp, field1090)) + field1091 = unwrapped_fields1084[7] + if !isnothing(field1091) newline(pp) - opt_val1090 = field1089 - write(pp, format_int(pp, opt_val1090)) + opt_val1092 = field1091 + write(pp, format_int(pp, opt_val1092)) end dedent!(pp) write(pp, ")") @@ -2233,24 +2233,24 @@ function pretty_datetime(pp::PrettyPrinter, msg::Proto.DateTimeValue) end function pretty_conjunction(pp::PrettyPrinter, msg::Proto.Conjunction) - flat1096 = try_flat(pp, msg, pretty_conjunction) - if !isnothing(flat1096) - write(pp, flat1096) + flat1098 = try_flat(pp, msg, pretty_conjunction) + if !isnothing(flat1098) + write(pp, flat1098) return nothing else _dollar_dollar = msg - fields1092 = _dollar_dollar.args - unwrapped_fields1093 = fields1092 + fields1094 = _dollar_dollar.args + unwrapped_fields1095 = fields1094 write(pp, "(and") indent_sexp!(pp) - if !isempty(unwrapped_fields1093) + if !isempty(unwrapped_fields1095) newline(pp) - for (i1679, elem1094) in enumerate(unwrapped_fields1093) - i1095 = i1679 - 1 - if (i1095 > 0) + for (i1683, elem1096) in enumerate(unwrapped_fields1095) + i1097 = i1683 - 1 + if (i1097 > 0) newline(pp) end - pretty_formula(pp, elem1094) + pretty_formula(pp, elem1096) end end dedent!(pp) @@ -2260,24 +2260,24 @@ function pretty_conjunction(pp::PrettyPrinter, msg::Proto.Conjunction) end function pretty_disjunction(pp::PrettyPrinter, msg::Proto.Disjunction) - flat1101 = try_flat(pp, msg, pretty_disjunction) - if !isnothing(flat1101) - write(pp, flat1101) + flat1103 = try_flat(pp, msg, pretty_disjunction) + if !isnothing(flat1103) + write(pp, flat1103) return nothing else _dollar_dollar = msg - fields1097 = _dollar_dollar.args - unwrapped_fields1098 = fields1097 + fields1099 = _dollar_dollar.args + unwrapped_fields1100 = fields1099 write(pp, "(or") indent_sexp!(pp) - if !isempty(unwrapped_fields1098) + if !isempty(unwrapped_fields1100) newline(pp) - for (i1680, elem1099) in enumerate(unwrapped_fields1098) - i1100 = i1680 - 1 - if (i1100 > 0) + for (i1684, elem1101) in enumerate(unwrapped_fields1100) + i1102 = i1684 - 1 + if (i1102 > 0) newline(pp) end - pretty_formula(pp, elem1099) + pretty_formula(pp, elem1101) end end dedent!(pp) @@ -2287,18 +2287,18 @@ function pretty_disjunction(pp::PrettyPrinter, msg::Proto.Disjunction) end function pretty_not(pp::PrettyPrinter, msg::Proto.Not) - flat1104 = try_flat(pp, msg, pretty_not) - if !isnothing(flat1104) - write(pp, flat1104) + flat1106 = try_flat(pp, msg, pretty_not) + if !isnothing(flat1106) + write(pp, flat1106) return nothing else _dollar_dollar = msg - fields1102 = _dollar_dollar.arg - unwrapped_fields1103 = fields1102 + fields1104 = _dollar_dollar.arg + unwrapped_fields1105 = fields1104 write(pp, "(not") indent_sexp!(pp) newline(pp) - pretty_formula(pp, unwrapped_fields1103) + pretty_formula(pp, unwrapped_fields1105) dedent!(pp) write(pp, ")") end @@ -2306,25 +2306,25 @@ function pretty_not(pp::PrettyPrinter, msg::Proto.Not) end function pretty_ffi(pp::PrettyPrinter, msg::Proto.FFI) - flat1110 = try_flat(pp, msg, pretty_ffi) - if !isnothing(flat1110) - write(pp, flat1110) + flat1112 = try_flat(pp, msg, pretty_ffi) + if !isnothing(flat1112) + write(pp, flat1112) return nothing else _dollar_dollar = msg - fields1105 = (_dollar_dollar.name, _dollar_dollar.args, _dollar_dollar.terms,) - unwrapped_fields1106 = fields1105 + fields1107 = (_dollar_dollar.name, _dollar_dollar.args, _dollar_dollar.terms,) + unwrapped_fields1108 = fields1107 write(pp, "(ffi") indent_sexp!(pp) newline(pp) - field1107 = unwrapped_fields1106[1] - pretty_name(pp, field1107) + field1109 = unwrapped_fields1108[1] + pretty_name(pp, field1109) newline(pp) - field1108 = unwrapped_fields1106[2] - pretty_ffi_args(pp, field1108) + field1110 = unwrapped_fields1108[2] + pretty_ffi_args(pp, field1110) newline(pp) - field1109 = unwrapped_fields1106[3] - pretty_terms(pp, field1109) + field1111 = unwrapped_fields1108[3] + pretty_terms(pp, field1111) dedent!(pp) write(pp, ")") end @@ -2332,35 +2332,35 @@ function pretty_ffi(pp::PrettyPrinter, msg::Proto.FFI) end function pretty_name(pp::PrettyPrinter, msg::String) - flat1112 = try_flat(pp, msg, pretty_name) - if !isnothing(flat1112) - write(pp, flat1112) + flat1114 = try_flat(pp, msg, pretty_name) + if !isnothing(flat1114) + write(pp, flat1114) return nothing else - fields1111 = msg + fields1113 = msg write(pp, ":") - write(pp, fields1111) + write(pp, fields1113) end return nothing end function pretty_ffi_args(pp::PrettyPrinter, msg::Vector{Proto.Abstraction}) - flat1116 = try_flat(pp, msg, pretty_ffi_args) - if !isnothing(flat1116) - write(pp, flat1116) + flat1118 = try_flat(pp, msg, pretty_ffi_args) + if !isnothing(flat1118) + write(pp, flat1118) return nothing else - fields1113 = msg + fields1115 = msg write(pp, "(args") indent_sexp!(pp) - if !isempty(fields1113) + if !isempty(fields1115) newline(pp) - for (i1681, elem1114) in enumerate(fields1113) - i1115 = i1681 - 1 - if (i1115 > 0) + for (i1685, elem1116) in enumerate(fields1115) + i1117 = i1685 - 1 + if (i1117 > 0) newline(pp) end - pretty_abstraction(pp, elem1114) + pretty_abstraction(pp, elem1116) end end dedent!(pp) @@ -2370,28 +2370,28 @@ function pretty_ffi_args(pp::PrettyPrinter, msg::Vector{Proto.Abstraction}) end function pretty_atom(pp::PrettyPrinter, msg::Proto.Atom) - flat1123 = try_flat(pp, msg, pretty_atom) - if !isnothing(flat1123) - write(pp, flat1123) + flat1125 = try_flat(pp, msg, pretty_atom) + if !isnothing(flat1125) + write(pp, flat1125) return nothing else _dollar_dollar = msg - fields1117 = (_dollar_dollar.name, _dollar_dollar.terms,) - unwrapped_fields1118 = fields1117 + fields1119 = (_dollar_dollar.name, _dollar_dollar.terms,) + unwrapped_fields1120 = fields1119 write(pp, "(atom") indent_sexp!(pp) newline(pp) - field1119 = unwrapped_fields1118[1] - pretty_relation_id(pp, field1119) - field1120 = unwrapped_fields1118[2] - if !isempty(field1120) + field1121 = unwrapped_fields1120[1] + pretty_relation_id(pp, field1121) + field1122 = unwrapped_fields1120[2] + if !isempty(field1122) newline(pp) - for (i1682, elem1121) in enumerate(field1120) - i1122 = i1682 - 1 - if (i1122 > 0) + for (i1686, elem1123) in enumerate(field1122) + i1124 = i1686 - 1 + if (i1124 > 0) newline(pp) end - pretty_term(pp, elem1121) + pretty_term(pp, elem1123) end end dedent!(pp) @@ -2401,28 +2401,28 @@ function pretty_atom(pp::PrettyPrinter, msg::Proto.Atom) end function pretty_pragma(pp::PrettyPrinter, msg::Proto.Pragma) - flat1130 = try_flat(pp, msg, pretty_pragma) - if !isnothing(flat1130) - write(pp, flat1130) + flat1132 = try_flat(pp, msg, pretty_pragma) + if !isnothing(flat1132) + write(pp, flat1132) return nothing else _dollar_dollar = msg - fields1124 = (_dollar_dollar.name, _dollar_dollar.terms,) - unwrapped_fields1125 = fields1124 + fields1126 = (_dollar_dollar.name, _dollar_dollar.terms,) + unwrapped_fields1127 = fields1126 write(pp, "(pragma") indent_sexp!(pp) newline(pp) - field1126 = unwrapped_fields1125[1] - pretty_name(pp, field1126) - field1127 = unwrapped_fields1125[2] - if !isempty(field1127) + field1128 = unwrapped_fields1127[1] + pretty_name(pp, field1128) + field1129 = unwrapped_fields1127[2] + if !isempty(field1129) newline(pp) - for (i1683, elem1128) in enumerate(field1127) - i1129 = i1683 - 1 - if (i1129 > 0) + for (i1687, elem1130) in enumerate(field1129) + i1131 = i1687 - 1 + if (i1131 > 0) newline(pp) end - pretty_term(pp, elem1128) + pretty_term(pp, elem1130) end end dedent!(pp) @@ -2432,118 +2432,118 @@ function pretty_pragma(pp::PrettyPrinter, msg::Proto.Pragma) end function pretty_primitive(pp::PrettyPrinter, msg::Proto.Primitive) - flat1146 = try_flat(pp, msg, pretty_primitive) - if !isnothing(flat1146) - write(pp, flat1146) + flat1148 = try_flat(pp, msg, pretty_primitive) + if !isnothing(flat1148) + write(pp, flat1148) return nothing else _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_eq" - _t1684 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) + _t1688 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) else - _t1684 = nothing + _t1688 = nothing end - guard_result1145 = _t1684 - if !isnothing(guard_result1145) + guard_result1147 = _t1688 + if !isnothing(guard_result1147) pretty_eq(pp, msg) else _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_lt_monotype" - _t1685 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) + _t1689 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) else - _t1685 = nothing + _t1689 = nothing end - guard_result1144 = _t1685 - if !isnothing(guard_result1144) + guard_result1146 = _t1689 + if !isnothing(guard_result1146) pretty_lt(pp, msg) else _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_lt_eq_monotype" - _t1686 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) + _t1690 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) else - _t1686 = nothing + _t1690 = nothing end - guard_result1143 = _t1686 - if !isnothing(guard_result1143) + guard_result1145 = _t1690 + if !isnothing(guard_result1145) pretty_lt_eq(pp, msg) else _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_gt_monotype" - _t1687 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) + _t1691 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) else - _t1687 = nothing + _t1691 = nothing end - guard_result1142 = _t1687 - if !isnothing(guard_result1142) + guard_result1144 = _t1691 + if !isnothing(guard_result1144) pretty_gt(pp, msg) else _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_gt_eq_monotype" - _t1688 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) + _t1692 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) else - _t1688 = nothing + _t1692 = nothing end - guard_result1141 = _t1688 - if !isnothing(guard_result1141) + guard_result1143 = _t1692 + if !isnothing(guard_result1143) pretty_gt_eq(pp, msg) else _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_add_monotype" - _t1689 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term), _get_oneof_field(_dollar_dollar.terms[3], :term),) + _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),) else - _t1689 = nothing + _t1693 = nothing end - guard_result1140 = _t1689 - if !isnothing(guard_result1140) + guard_result1142 = _t1693 + if !isnothing(guard_result1142) pretty_add(pp, msg) else _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_subtract_monotype" - _t1690 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term), _get_oneof_field(_dollar_dollar.terms[3], :term),) + _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),) else - _t1690 = nothing + _t1694 = nothing end - guard_result1139 = _t1690 - if !isnothing(guard_result1139) + guard_result1141 = _t1694 + if !isnothing(guard_result1141) pretty_minus(pp, msg) else _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_multiply_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),) + _t1695 = (_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 + _t1695 = nothing end - guard_result1138 = _t1691 - if !isnothing(guard_result1138) + guard_result1140 = _t1695 + if !isnothing(guard_result1140) pretty_multiply(pp, msg) else _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_divide_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),) + _t1696 = (_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 + _t1696 = nothing end - guard_result1137 = _t1692 - if !isnothing(guard_result1137) + guard_result1139 = _t1696 + if !isnothing(guard_result1139) pretty_divide(pp, msg) else _dollar_dollar = msg - fields1131 = (_dollar_dollar.name, _dollar_dollar.terms,) - unwrapped_fields1132 = fields1131 + fields1133 = (_dollar_dollar.name, _dollar_dollar.terms,) + unwrapped_fields1134 = fields1133 write(pp, "(primitive") indent_sexp!(pp) newline(pp) - field1133 = unwrapped_fields1132[1] - pretty_name(pp, field1133) - field1134 = unwrapped_fields1132[2] - if !isempty(field1134) + field1135 = unwrapped_fields1134[1] + pretty_name(pp, field1135) + field1136 = unwrapped_fields1134[2] + if !isempty(field1136) newline(pp) - for (i1693, elem1135) in enumerate(field1134) - i1136 = i1693 - 1 - if (i1136 > 0) + for (i1697, elem1137) in enumerate(field1136) + i1138 = i1697 - 1 + if (i1138 > 0) newline(pp) end - pretty_rel_term(pp, elem1135) + pretty_rel_term(pp, elem1137) end end dedent!(pp) @@ -2562,27 +2562,27 @@ function pretty_primitive(pp::PrettyPrinter, msg::Proto.Primitive) end function pretty_eq(pp::PrettyPrinter, msg::Proto.Primitive) - flat1151 = try_flat(pp, msg, pretty_eq) - if !isnothing(flat1151) - write(pp, flat1151) + flat1153 = try_flat(pp, msg, pretty_eq) + if !isnothing(flat1153) + write(pp, flat1153) return nothing else _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_eq" - _t1694 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) + _t1698 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) else - _t1694 = nothing + _t1698 = nothing end - fields1147 = _t1694 - unwrapped_fields1148 = fields1147 + fields1149 = _t1698 + unwrapped_fields1150 = fields1149 write(pp, "(=") indent_sexp!(pp) newline(pp) - field1149 = unwrapped_fields1148[1] - pretty_term(pp, field1149) + field1151 = unwrapped_fields1150[1] + pretty_term(pp, field1151) newline(pp) - field1150 = unwrapped_fields1148[2] - pretty_term(pp, field1150) + field1152 = unwrapped_fields1150[2] + pretty_term(pp, field1152) dedent!(pp) write(pp, ")") end @@ -2590,27 +2590,27 @@ function pretty_eq(pp::PrettyPrinter, msg::Proto.Primitive) end function pretty_lt(pp::PrettyPrinter, msg::Proto.Primitive) - flat1156 = try_flat(pp, msg, pretty_lt) - if !isnothing(flat1156) - write(pp, flat1156) + flat1158 = try_flat(pp, msg, pretty_lt) + if !isnothing(flat1158) + write(pp, flat1158) return nothing else _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_lt_monotype" - _t1695 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) + _t1699 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) else - _t1695 = nothing + _t1699 = nothing end - fields1152 = _t1695 - unwrapped_fields1153 = fields1152 + fields1154 = _t1699 + unwrapped_fields1155 = fields1154 write(pp, "(<") indent_sexp!(pp) newline(pp) - field1154 = unwrapped_fields1153[1] - pretty_term(pp, field1154) + field1156 = unwrapped_fields1155[1] + pretty_term(pp, field1156) newline(pp) - field1155 = unwrapped_fields1153[2] - pretty_term(pp, field1155) + field1157 = unwrapped_fields1155[2] + pretty_term(pp, field1157) dedent!(pp) write(pp, ")") end @@ -2618,27 +2618,27 @@ function pretty_lt(pp::PrettyPrinter, msg::Proto.Primitive) end function pretty_lt_eq(pp::PrettyPrinter, msg::Proto.Primitive) - flat1161 = try_flat(pp, msg, pretty_lt_eq) - if !isnothing(flat1161) - write(pp, flat1161) + flat1163 = try_flat(pp, msg, pretty_lt_eq) + if !isnothing(flat1163) + write(pp, flat1163) return nothing else _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_lt_eq_monotype" - _t1696 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) + _t1700 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) else - _t1696 = nothing + _t1700 = nothing end - fields1157 = _t1696 - unwrapped_fields1158 = fields1157 + fields1159 = _t1700 + unwrapped_fields1160 = fields1159 write(pp, "(<=") indent_sexp!(pp) newline(pp) - field1159 = unwrapped_fields1158[1] - pretty_term(pp, field1159) + field1161 = unwrapped_fields1160[1] + pretty_term(pp, field1161) newline(pp) - field1160 = unwrapped_fields1158[2] - pretty_term(pp, field1160) + field1162 = unwrapped_fields1160[2] + pretty_term(pp, field1162) dedent!(pp) write(pp, ")") end @@ -2646,27 +2646,27 @@ function pretty_lt_eq(pp::PrettyPrinter, msg::Proto.Primitive) end function pretty_gt(pp::PrettyPrinter, msg::Proto.Primitive) - flat1166 = try_flat(pp, msg, pretty_gt) - if !isnothing(flat1166) - write(pp, flat1166) + flat1168 = try_flat(pp, msg, pretty_gt) + if !isnothing(flat1168) + write(pp, flat1168) return nothing else _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_gt_monotype" - _t1697 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) + _t1701 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) else - _t1697 = nothing + _t1701 = nothing end - fields1162 = _t1697 - unwrapped_fields1163 = fields1162 + fields1164 = _t1701 + unwrapped_fields1165 = fields1164 write(pp, "(>") indent_sexp!(pp) newline(pp) - field1164 = unwrapped_fields1163[1] - pretty_term(pp, field1164) + field1166 = unwrapped_fields1165[1] + pretty_term(pp, field1166) newline(pp) - field1165 = unwrapped_fields1163[2] - pretty_term(pp, field1165) + field1167 = unwrapped_fields1165[2] + pretty_term(pp, field1167) dedent!(pp) write(pp, ")") end @@ -2674,27 +2674,27 @@ function pretty_gt(pp::PrettyPrinter, msg::Proto.Primitive) end function pretty_gt_eq(pp::PrettyPrinter, msg::Proto.Primitive) - flat1171 = try_flat(pp, msg, pretty_gt_eq) - if !isnothing(flat1171) - write(pp, flat1171) + flat1173 = try_flat(pp, msg, pretty_gt_eq) + if !isnothing(flat1173) + write(pp, flat1173) return nothing else _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_gt_eq_monotype" - _t1698 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) + _t1702 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) else - _t1698 = nothing + _t1702 = nothing end - fields1167 = _t1698 - unwrapped_fields1168 = fields1167 + fields1169 = _t1702 + unwrapped_fields1170 = fields1169 write(pp, "(>=") indent_sexp!(pp) newline(pp) - field1169 = unwrapped_fields1168[1] - pretty_term(pp, field1169) + field1171 = unwrapped_fields1170[1] + pretty_term(pp, field1171) newline(pp) - field1170 = unwrapped_fields1168[2] - pretty_term(pp, field1170) + field1172 = unwrapped_fields1170[2] + pretty_term(pp, field1172) dedent!(pp) write(pp, ")") end @@ -2702,30 +2702,30 @@ function pretty_gt_eq(pp::PrettyPrinter, msg::Proto.Primitive) end function pretty_add(pp::PrettyPrinter, msg::Proto.Primitive) - flat1177 = try_flat(pp, msg, pretty_add) - if !isnothing(flat1177) - write(pp, flat1177) + flat1179 = try_flat(pp, msg, pretty_add) + if !isnothing(flat1179) + write(pp, flat1179) return nothing else _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_add_monotype" - _t1699 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term), _get_oneof_field(_dollar_dollar.terms[3], :term),) + _t1703 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term), _get_oneof_field(_dollar_dollar.terms[3], :term),) else - _t1699 = nothing + _t1703 = nothing end - fields1172 = _t1699 - unwrapped_fields1173 = fields1172 + fields1174 = _t1703 + unwrapped_fields1175 = fields1174 write(pp, "(+") indent_sexp!(pp) newline(pp) - field1174 = unwrapped_fields1173[1] - pretty_term(pp, field1174) + field1176 = unwrapped_fields1175[1] + pretty_term(pp, field1176) newline(pp) - field1175 = unwrapped_fields1173[2] - pretty_term(pp, field1175) + field1177 = unwrapped_fields1175[2] + pretty_term(pp, field1177) newline(pp) - field1176 = unwrapped_fields1173[3] - pretty_term(pp, field1176) + field1178 = unwrapped_fields1175[3] + pretty_term(pp, field1178) dedent!(pp) write(pp, ")") end @@ -2733,30 +2733,30 @@ function pretty_add(pp::PrettyPrinter, msg::Proto.Primitive) end function pretty_minus(pp::PrettyPrinter, msg::Proto.Primitive) - flat1183 = try_flat(pp, msg, pretty_minus) - if !isnothing(flat1183) - write(pp, flat1183) + flat1185 = try_flat(pp, msg, pretty_minus) + if !isnothing(flat1185) + write(pp, flat1185) return nothing else _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_subtract_monotype" - _t1700 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term), _get_oneof_field(_dollar_dollar.terms[3], :term),) + _t1704 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term), _get_oneof_field(_dollar_dollar.terms[3], :term),) else - _t1700 = nothing + _t1704 = nothing end - fields1178 = _t1700 - unwrapped_fields1179 = fields1178 + fields1180 = _t1704 + 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) newline(pp) - field1182 = unwrapped_fields1179[3] - pretty_term(pp, field1182) + field1184 = unwrapped_fields1181[3] + pretty_term(pp, field1184) dedent!(pp) write(pp, ")") end @@ -2764,30 +2764,30 @@ function pretty_minus(pp::PrettyPrinter, msg::Proto.Primitive) end function pretty_multiply(pp::PrettyPrinter, msg::Proto.Primitive) - flat1189 = try_flat(pp, msg, pretty_multiply) - if !isnothing(flat1189) - write(pp, flat1189) + flat1191 = try_flat(pp, msg, pretty_multiply) + if !isnothing(flat1191) + write(pp, flat1191) return nothing else _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_multiply_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),) + _t1705 = (_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 + _t1705 = nothing end - fields1184 = _t1701 - unwrapped_fields1185 = fields1184 + fields1186 = _t1705 + unwrapped_fields1187 = fields1186 write(pp, "(*") indent_sexp!(pp) newline(pp) - field1186 = unwrapped_fields1185[1] - pretty_term(pp, field1186) + field1188 = unwrapped_fields1187[1] + pretty_term(pp, field1188) newline(pp) - field1187 = unwrapped_fields1185[2] - pretty_term(pp, field1187) + field1189 = unwrapped_fields1187[2] + pretty_term(pp, field1189) newline(pp) - field1188 = unwrapped_fields1185[3] - pretty_term(pp, field1188) + field1190 = unwrapped_fields1187[3] + pretty_term(pp, field1190) dedent!(pp) write(pp, ")") end @@ -2795,30 +2795,30 @@ function pretty_multiply(pp::PrettyPrinter, msg::Proto.Primitive) end function pretty_divide(pp::PrettyPrinter, msg::Proto.Primitive) - flat1195 = try_flat(pp, msg, pretty_divide) - if !isnothing(flat1195) - write(pp, flat1195) + flat1197 = try_flat(pp, msg, pretty_divide) + if !isnothing(flat1197) + write(pp, flat1197) return nothing else _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_divide_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),) + _t1706 = (_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 + _t1706 = nothing end - fields1190 = _t1702 - unwrapped_fields1191 = fields1190 + fields1192 = _t1706 + unwrapped_fields1193 = fields1192 write(pp, "(/") indent_sexp!(pp) newline(pp) - field1192 = unwrapped_fields1191[1] - pretty_term(pp, field1192) + field1194 = unwrapped_fields1193[1] + pretty_term(pp, field1194) newline(pp) - field1193 = unwrapped_fields1191[2] - pretty_term(pp, field1193) + field1195 = unwrapped_fields1193[2] + pretty_term(pp, field1195) newline(pp) - field1194 = unwrapped_fields1191[3] - pretty_term(pp, field1194) + field1196 = unwrapped_fields1193[3] + pretty_term(pp, field1196) dedent!(pp) write(pp, ")") end @@ -2826,32 +2826,32 @@ function pretty_divide(pp::PrettyPrinter, msg::Proto.Primitive) end function pretty_rel_term(pp::PrettyPrinter, msg::Proto.RelTerm) - flat1200 = try_flat(pp, msg, pretty_rel_term) - if !isnothing(flat1200) - write(pp, flat1200) + flat1202 = try_flat(pp, msg, pretty_rel_term) + if !isnothing(flat1202) + write(pp, flat1202) return nothing else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("specialized_value")) - _t1703 = _get_oneof_field(_dollar_dollar, :specialized_value) + _t1707 = _get_oneof_field(_dollar_dollar, :specialized_value) else - _t1703 = nothing + _t1707 = nothing end - deconstruct_result1198 = _t1703 - if !isnothing(deconstruct_result1198) - unwrapped1199 = deconstruct_result1198 - pretty_specialized_value(pp, unwrapped1199) + deconstruct_result1200 = _t1707 + if !isnothing(deconstruct_result1200) + unwrapped1201 = deconstruct_result1200 + pretty_specialized_value(pp, unwrapped1201) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("term")) - _t1704 = _get_oneof_field(_dollar_dollar, :term) + _t1708 = _get_oneof_field(_dollar_dollar, :term) else - _t1704 = nothing + _t1708 = nothing end - deconstruct_result1196 = _t1704 - if !isnothing(deconstruct_result1196) - unwrapped1197 = deconstruct_result1196 - pretty_term(pp, unwrapped1197) + deconstruct_result1198 = _t1708 + if !isnothing(deconstruct_result1198) + unwrapped1199 = deconstruct_result1198 + pretty_term(pp, unwrapped1199) else throw(ParseError("No matching rule for rel_term")) end @@ -2861,41 +2861,41 @@ function pretty_rel_term(pp::PrettyPrinter, msg::Proto.RelTerm) end function pretty_specialized_value(pp::PrettyPrinter, msg::Proto.Value) - flat1202 = try_flat(pp, msg, pretty_specialized_value) - if !isnothing(flat1202) - write(pp, flat1202) + flat1204 = try_flat(pp, msg, pretty_specialized_value) + if !isnothing(flat1204) + write(pp, flat1204) return nothing else - fields1201 = msg + fields1203 = msg write(pp, "#") - pretty_raw_value(pp, fields1201) + pretty_raw_value(pp, fields1203) end return nothing end function pretty_rel_atom(pp::PrettyPrinter, msg::Proto.RelAtom) - flat1209 = try_flat(pp, msg, pretty_rel_atom) - if !isnothing(flat1209) - write(pp, flat1209) + flat1211 = try_flat(pp, msg, pretty_rel_atom) + if !isnothing(flat1211) + write(pp, flat1211) return nothing else _dollar_dollar = msg - fields1203 = (_dollar_dollar.name, _dollar_dollar.terms,) - unwrapped_fields1204 = fields1203 + fields1205 = (_dollar_dollar.name, _dollar_dollar.terms,) + unwrapped_fields1206 = fields1205 write(pp, "(relatom") indent_sexp!(pp) newline(pp) - field1205 = unwrapped_fields1204[1] - pretty_name(pp, field1205) - field1206 = unwrapped_fields1204[2] - if !isempty(field1206) + field1207 = unwrapped_fields1206[1] + pretty_name(pp, field1207) + field1208 = unwrapped_fields1206[2] + if !isempty(field1208) newline(pp) - for (i1705, elem1207) in enumerate(field1206) - i1208 = i1705 - 1 - if (i1208 > 0) + for (i1709, elem1209) in enumerate(field1208) + i1210 = i1709 - 1 + if (i1210 > 0) newline(pp) end - pretty_rel_term(pp, elem1207) + pretty_rel_term(pp, elem1209) end end dedent!(pp) @@ -2905,22 +2905,22 @@ function pretty_rel_atom(pp::PrettyPrinter, msg::Proto.RelAtom) end function pretty_cast(pp::PrettyPrinter, msg::Proto.Cast) - flat1214 = try_flat(pp, msg, pretty_cast) - if !isnothing(flat1214) - write(pp, flat1214) + flat1216 = try_flat(pp, msg, pretty_cast) + if !isnothing(flat1216) + write(pp, flat1216) return nothing else _dollar_dollar = msg - fields1210 = (_dollar_dollar.input, _dollar_dollar.result,) - unwrapped_fields1211 = fields1210 + fields1212 = (_dollar_dollar.input, _dollar_dollar.result,) + unwrapped_fields1213 = fields1212 write(pp, "(cast") indent_sexp!(pp) newline(pp) - field1212 = unwrapped_fields1211[1] - pretty_term(pp, field1212) + field1214 = unwrapped_fields1213[1] + pretty_term(pp, field1214) newline(pp) - field1213 = unwrapped_fields1211[2] - pretty_term(pp, field1213) + field1215 = unwrapped_fields1213[2] + pretty_term(pp, field1215) dedent!(pp) write(pp, ")") end @@ -2928,22 +2928,22 @@ function pretty_cast(pp::PrettyPrinter, msg::Proto.Cast) end function pretty_attrs(pp::PrettyPrinter, msg::Vector{Proto.Attribute}) - flat1218 = try_flat(pp, msg, pretty_attrs) - if !isnothing(flat1218) - write(pp, flat1218) + flat1220 = try_flat(pp, msg, pretty_attrs) + if !isnothing(flat1220) + write(pp, flat1220) return nothing else - fields1215 = msg + fields1217 = msg write(pp, "(attrs") indent_sexp!(pp) - if !isempty(fields1215) + if !isempty(fields1217) newline(pp) - for (i1706, elem1216) in enumerate(fields1215) - i1217 = i1706 - 1 - if (i1217 > 0) + for (i1710, elem1218) in enumerate(fields1217) + i1219 = i1710 - 1 + if (i1219 > 0) newline(pp) end - pretty_attribute(pp, elem1216) + pretty_attribute(pp, elem1218) end end dedent!(pp) @@ -2953,28 +2953,28 @@ function pretty_attrs(pp::PrettyPrinter, msg::Vector{Proto.Attribute}) end function pretty_attribute(pp::PrettyPrinter, msg::Proto.Attribute) - flat1225 = try_flat(pp, msg, pretty_attribute) - if !isnothing(flat1225) - write(pp, flat1225) + flat1227 = try_flat(pp, msg, pretty_attribute) + if !isnothing(flat1227) + write(pp, flat1227) return nothing else _dollar_dollar = msg - fields1219 = (_dollar_dollar.name, _dollar_dollar.args,) - unwrapped_fields1220 = fields1219 + fields1221 = (_dollar_dollar.name, _dollar_dollar.args,) + unwrapped_fields1222 = fields1221 write(pp, "(attribute") indent_sexp!(pp) newline(pp) - field1221 = unwrapped_fields1220[1] - pretty_name(pp, field1221) - field1222 = unwrapped_fields1220[2] - if !isempty(field1222) + field1223 = unwrapped_fields1222[1] + pretty_name(pp, field1223) + field1224 = unwrapped_fields1222[2] + if !isempty(field1224) newline(pp) - for (i1707, elem1223) in enumerate(field1222) - i1224 = i1707 - 1 - if (i1224 > 0) + for (i1711, elem1225) in enumerate(field1224) + i1226 = i1711 - 1 + if (i1226 > 0) newline(pp) end - pretty_raw_value(pp, elem1223) + pretty_raw_value(pp, elem1225) end end dedent!(pp) @@ -2984,30 +2984,30 @@ function pretty_attribute(pp::PrettyPrinter, msg::Proto.Attribute) end function pretty_algorithm(pp::PrettyPrinter, msg::Proto.Algorithm) - flat1232 = try_flat(pp, msg, pretty_algorithm) - if !isnothing(flat1232) - write(pp, flat1232) + flat1234 = try_flat(pp, msg, pretty_algorithm) + if !isnothing(flat1234) + write(pp, flat1234) return nothing else _dollar_dollar = msg - fields1226 = (_dollar_dollar.var"#global", _dollar_dollar.body,) - unwrapped_fields1227 = fields1226 + fields1228 = (_dollar_dollar.var"#global", _dollar_dollar.body,) + unwrapped_fields1229 = fields1228 write(pp, "(algorithm") indent_sexp!(pp) - field1228 = unwrapped_fields1227[1] - if !isempty(field1228) + field1230 = unwrapped_fields1229[1] + if !isempty(field1230) newline(pp) - for (i1708, elem1229) in enumerate(field1228) - i1230 = i1708 - 1 - if (i1230 > 0) + for (i1712, elem1231) in enumerate(field1230) + i1232 = i1712 - 1 + if (i1232 > 0) newline(pp) end - pretty_relation_id(pp, elem1229) + pretty_relation_id(pp, elem1231) end end newline(pp) - field1231 = unwrapped_fields1227[2] - pretty_script(pp, field1231) + field1233 = unwrapped_fields1229[2] + pretty_script(pp, field1233) dedent!(pp) write(pp, ")") end @@ -3015,24 +3015,24 @@ function pretty_algorithm(pp::PrettyPrinter, msg::Proto.Algorithm) end function pretty_script(pp::PrettyPrinter, msg::Proto.Script) - flat1237 = try_flat(pp, msg, pretty_script) - if !isnothing(flat1237) - write(pp, flat1237) + flat1239 = try_flat(pp, msg, pretty_script) + if !isnothing(flat1239) + write(pp, flat1239) return nothing else _dollar_dollar = msg - fields1233 = _dollar_dollar.constructs - unwrapped_fields1234 = fields1233 + fields1235 = _dollar_dollar.constructs + unwrapped_fields1236 = fields1235 write(pp, "(script") indent_sexp!(pp) - if !isempty(unwrapped_fields1234) + if !isempty(unwrapped_fields1236) newline(pp) - for (i1709, elem1235) in enumerate(unwrapped_fields1234) - i1236 = i1709 - 1 - if (i1236 > 0) + for (i1713, elem1237) in enumerate(unwrapped_fields1236) + i1238 = i1713 - 1 + if (i1238 > 0) newline(pp) end - pretty_construct(pp, elem1235) + pretty_construct(pp, elem1237) end end dedent!(pp) @@ -3042,32 +3042,32 @@ function pretty_script(pp::PrettyPrinter, msg::Proto.Script) end function pretty_construct(pp::PrettyPrinter, msg::Proto.Construct) - flat1242 = try_flat(pp, msg, pretty_construct) - if !isnothing(flat1242) - write(pp, flat1242) + flat1244 = try_flat(pp, msg, pretty_construct) + if !isnothing(flat1244) + write(pp, flat1244) return nothing else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("loop")) - _t1710 = _get_oneof_field(_dollar_dollar, :loop) + _t1714 = _get_oneof_field(_dollar_dollar, :loop) else - _t1710 = nothing + _t1714 = nothing end - deconstruct_result1240 = _t1710 - if !isnothing(deconstruct_result1240) - unwrapped1241 = deconstruct_result1240 - pretty_loop(pp, unwrapped1241) + deconstruct_result1242 = _t1714 + if !isnothing(deconstruct_result1242) + unwrapped1243 = deconstruct_result1242 + pretty_loop(pp, unwrapped1243) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("instruction")) - _t1711 = _get_oneof_field(_dollar_dollar, :instruction) + _t1715 = _get_oneof_field(_dollar_dollar, :instruction) else - _t1711 = nothing + _t1715 = nothing end - deconstruct_result1238 = _t1711 - if !isnothing(deconstruct_result1238) - unwrapped1239 = deconstruct_result1238 - pretty_instruction(pp, unwrapped1239) + deconstruct_result1240 = _t1715 + if !isnothing(deconstruct_result1240) + unwrapped1241 = deconstruct_result1240 + pretty_instruction(pp, unwrapped1241) else throw(ParseError("No matching rule for construct")) end @@ -3077,22 +3077,22 @@ function pretty_construct(pp::PrettyPrinter, msg::Proto.Construct) end function pretty_loop(pp::PrettyPrinter, msg::Proto.Loop) - flat1247 = try_flat(pp, msg, pretty_loop) - if !isnothing(flat1247) - write(pp, flat1247) + flat1249 = try_flat(pp, msg, pretty_loop) + if !isnothing(flat1249) + write(pp, flat1249) return nothing else _dollar_dollar = msg - fields1243 = (_dollar_dollar.init, _dollar_dollar.body,) - unwrapped_fields1244 = fields1243 + fields1245 = (_dollar_dollar.init, _dollar_dollar.body,) + unwrapped_fields1246 = fields1245 write(pp, "(loop") indent_sexp!(pp) newline(pp) - field1245 = unwrapped_fields1244[1] - pretty_init(pp, field1245) + field1247 = unwrapped_fields1246[1] + pretty_init(pp, field1247) newline(pp) - field1246 = unwrapped_fields1244[2] - pretty_script(pp, field1246) + field1248 = unwrapped_fields1246[2] + pretty_script(pp, field1248) dedent!(pp) write(pp, ")") end @@ -3100,22 +3100,22 @@ function pretty_loop(pp::PrettyPrinter, msg::Proto.Loop) end function pretty_init(pp::PrettyPrinter, msg::Vector{Proto.Instruction}) - flat1251 = try_flat(pp, msg, pretty_init) - if !isnothing(flat1251) - write(pp, flat1251) + flat1253 = try_flat(pp, msg, pretty_init) + if !isnothing(flat1253) + write(pp, flat1253) return nothing else - fields1248 = msg + fields1250 = msg write(pp, "(init") indent_sexp!(pp) - if !isempty(fields1248) + if !isempty(fields1250) newline(pp) - for (i1712, elem1249) in enumerate(fields1248) - i1250 = i1712 - 1 - if (i1250 > 0) + for (i1716, elem1251) in enumerate(fields1250) + i1252 = i1716 - 1 + if (i1252 > 0) newline(pp) end - pretty_instruction(pp, elem1249) + pretty_instruction(pp, elem1251) end end dedent!(pp) @@ -3125,65 +3125,65 @@ function pretty_init(pp::PrettyPrinter, msg::Vector{Proto.Instruction}) end function pretty_instruction(pp::PrettyPrinter, msg::Proto.Instruction) - flat1262 = try_flat(pp, msg, pretty_instruction) - if !isnothing(flat1262) - write(pp, flat1262) + flat1264 = try_flat(pp, msg, pretty_instruction) + if !isnothing(flat1264) + write(pp, flat1264) return nothing else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("assign")) - _t1713 = _get_oneof_field(_dollar_dollar, :assign) + _t1717 = _get_oneof_field(_dollar_dollar, :assign) else - _t1713 = nothing + _t1717 = nothing end - deconstruct_result1260 = _t1713 - if !isnothing(deconstruct_result1260) - unwrapped1261 = deconstruct_result1260 - pretty_assign(pp, unwrapped1261) + deconstruct_result1262 = _t1717 + if !isnothing(deconstruct_result1262) + unwrapped1263 = deconstruct_result1262 + pretty_assign(pp, unwrapped1263) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("upsert")) - _t1714 = _get_oneof_field(_dollar_dollar, :upsert) + _t1718 = _get_oneof_field(_dollar_dollar, :upsert) else - _t1714 = nothing + _t1718 = nothing end - deconstruct_result1258 = _t1714 - if !isnothing(deconstruct_result1258) - unwrapped1259 = deconstruct_result1258 - pretty_upsert(pp, unwrapped1259) + deconstruct_result1260 = _t1718 + if !isnothing(deconstruct_result1260) + unwrapped1261 = deconstruct_result1260 + pretty_upsert(pp, unwrapped1261) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("#break")) - _t1715 = _get_oneof_field(_dollar_dollar, :var"#break") + _t1719 = _get_oneof_field(_dollar_dollar, :var"#break") else - _t1715 = nothing + _t1719 = nothing end - deconstruct_result1256 = _t1715 - if !isnothing(deconstruct_result1256) - unwrapped1257 = deconstruct_result1256 - pretty_break(pp, unwrapped1257) + deconstruct_result1258 = _t1719 + if !isnothing(deconstruct_result1258) + unwrapped1259 = deconstruct_result1258 + pretty_break(pp, unwrapped1259) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("monoid_def")) - _t1716 = _get_oneof_field(_dollar_dollar, :monoid_def) + _t1720 = _get_oneof_field(_dollar_dollar, :monoid_def) else - _t1716 = nothing + _t1720 = nothing end - deconstruct_result1254 = _t1716 - if !isnothing(deconstruct_result1254) - unwrapped1255 = deconstruct_result1254 - pretty_monoid_def(pp, unwrapped1255) + deconstruct_result1256 = _t1720 + if !isnothing(deconstruct_result1256) + unwrapped1257 = deconstruct_result1256 + pretty_monoid_def(pp, unwrapped1257) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("monus_def")) - _t1717 = _get_oneof_field(_dollar_dollar, :monus_def) + _t1721 = _get_oneof_field(_dollar_dollar, :monus_def) else - _t1717 = nothing + _t1721 = nothing end - deconstruct_result1252 = _t1717 - if !isnothing(deconstruct_result1252) - unwrapped1253 = deconstruct_result1252 - pretty_monus_def(pp, unwrapped1253) + deconstruct_result1254 = _t1721 + if !isnothing(deconstruct_result1254) + unwrapped1255 = deconstruct_result1254 + pretty_monus_def(pp, unwrapped1255) else throw(ParseError("No matching rule for instruction")) end @@ -3196,32 +3196,32 @@ function pretty_instruction(pp::PrettyPrinter, msg::Proto.Instruction) end function pretty_assign(pp::PrettyPrinter, msg::Proto.Assign) - flat1269 = try_flat(pp, msg, pretty_assign) - if !isnothing(flat1269) - write(pp, flat1269) + flat1271 = try_flat(pp, msg, pretty_assign) + if !isnothing(flat1271) + write(pp, flat1271) return nothing else _dollar_dollar = msg if !isempty(_dollar_dollar.attrs) - _t1718 = _dollar_dollar.attrs + _t1722 = _dollar_dollar.attrs else - _t1718 = nothing + _t1722 = nothing end - fields1263 = (_dollar_dollar.name, _dollar_dollar.body, _t1718,) - unwrapped_fields1264 = fields1263 + fields1265 = (_dollar_dollar.name, _dollar_dollar.body, _t1722,) + unwrapped_fields1266 = fields1265 write(pp, "(assign") indent_sexp!(pp) newline(pp) - field1265 = unwrapped_fields1264[1] - pretty_relation_id(pp, field1265) + field1267 = unwrapped_fields1266[1] + pretty_relation_id(pp, field1267) newline(pp) - field1266 = unwrapped_fields1264[2] - pretty_abstraction(pp, field1266) - field1267 = unwrapped_fields1264[3] - if !isnothing(field1267) + field1268 = unwrapped_fields1266[2] + pretty_abstraction(pp, field1268) + field1269 = unwrapped_fields1266[3] + if !isnothing(field1269) newline(pp) - opt_val1268 = field1267 - pretty_attrs(pp, opt_val1268) + opt_val1270 = field1269 + pretty_attrs(pp, opt_val1270) end dedent!(pp) write(pp, ")") @@ -3230,32 +3230,32 @@ function pretty_assign(pp::PrettyPrinter, msg::Proto.Assign) end function pretty_upsert(pp::PrettyPrinter, msg::Proto.Upsert) - flat1276 = try_flat(pp, msg, pretty_upsert) - if !isnothing(flat1276) - write(pp, flat1276) + flat1278 = try_flat(pp, msg, pretty_upsert) + if !isnothing(flat1278) + write(pp, flat1278) return nothing else _dollar_dollar = msg if !isempty(_dollar_dollar.attrs) - _t1719 = _dollar_dollar.attrs + _t1723 = _dollar_dollar.attrs else - _t1719 = nothing + _t1723 = nothing end - fields1270 = (_dollar_dollar.name, (_dollar_dollar.body, _dollar_dollar.value_arity,), _t1719,) - unwrapped_fields1271 = fields1270 + fields1272 = (_dollar_dollar.name, (_dollar_dollar.body, _dollar_dollar.value_arity,), _t1723,) + unwrapped_fields1273 = fields1272 write(pp, "(upsert") indent_sexp!(pp) newline(pp) - field1272 = unwrapped_fields1271[1] - pretty_relation_id(pp, field1272) + field1274 = unwrapped_fields1273[1] + pretty_relation_id(pp, field1274) newline(pp) - field1273 = unwrapped_fields1271[2] - pretty_abstraction_with_arity(pp, field1273) - field1274 = unwrapped_fields1271[3] - if !isnothing(field1274) + field1275 = unwrapped_fields1273[2] + pretty_abstraction_with_arity(pp, field1275) + field1276 = unwrapped_fields1273[3] + if !isnothing(field1276) newline(pp) - opt_val1275 = field1274 - pretty_attrs(pp, opt_val1275) + opt_val1277 = field1276 + pretty_attrs(pp, opt_val1277) end dedent!(pp) write(pp, ")") @@ -3264,22 +3264,22 @@ function pretty_upsert(pp::PrettyPrinter, msg::Proto.Upsert) end function pretty_abstraction_with_arity(pp::PrettyPrinter, msg::Tuple{Proto.Abstraction, Int64}) - flat1281 = try_flat(pp, msg, pretty_abstraction_with_arity) - if !isnothing(flat1281) - write(pp, flat1281) + flat1283 = try_flat(pp, msg, pretty_abstraction_with_arity) + if !isnothing(flat1283) + write(pp, flat1283) return nothing else _dollar_dollar = msg - _t1720 = deconstruct_bindings_with_arity(pp, _dollar_dollar[1], _dollar_dollar[2]) - fields1277 = (_t1720, _dollar_dollar[1].value,) - unwrapped_fields1278 = fields1277 + _t1724 = deconstruct_bindings_with_arity(pp, _dollar_dollar[1], _dollar_dollar[2]) + fields1279 = (_t1724, _dollar_dollar[1].value,) + unwrapped_fields1280 = fields1279 write(pp, "(") indent!(pp) - field1279 = unwrapped_fields1278[1] - pretty_bindings(pp, field1279) + field1281 = unwrapped_fields1280[1] + pretty_bindings(pp, field1281) newline(pp) - field1280 = unwrapped_fields1278[2] - pretty_formula(pp, field1280) + field1282 = unwrapped_fields1280[2] + pretty_formula(pp, field1282) dedent!(pp) write(pp, ")") end @@ -3287,32 +3287,32 @@ function pretty_abstraction_with_arity(pp::PrettyPrinter, msg::Tuple{Proto.Abstr end function pretty_break(pp::PrettyPrinter, msg::Proto.Break) - flat1288 = try_flat(pp, msg, pretty_break) - if !isnothing(flat1288) - write(pp, flat1288) + flat1290 = try_flat(pp, msg, pretty_break) + if !isnothing(flat1290) + write(pp, flat1290) return nothing else _dollar_dollar = msg if !isempty(_dollar_dollar.attrs) - _t1721 = _dollar_dollar.attrs + _t1725 = _dollar_dollar.attrs else - _t1721 = nothing + _t1725 = nothing end - fields1282 = (_dollar_dollar.name, _dollar_dollar.body, _t1721,) - unwrapped_fields1283 = fields1282 + fields1284 = (_dollar_dollar.name, _dollar_dollar.body, _t1725,) + unwrapped_fields1285 = fields1284 write(pp, "(break") indent_sexp!(pp) newline(pp) - field1284 = unwrapped_fields1283[1] - pretty_relation_id(pp, field1284) + field1286 = unwrapped_fields1285[1] + pretty_relation_id(pp, field1286) newline(pp) - field1285 = unwrapped_fields1283[2] - pretty_abstraction(pp, field1285) - field1286 = unwrapped_fields1283[3] - if !isnothing(field1286) + field1287 = unwrapped_fields1285[2] + pretty_abstraction(pp, field1287) + field1288 = unwrapped_fields1285[3] + if !isnothing(field1288) newline(pp) - opt_val1287 = field1286 - pretty_attrs(pp, opt_val1287) + opt_val1289 = field1288 + pretty_attrs(pp, opt_val1289) end dedent!(pp) write(pp, ")") @@ -3321,35 +3321,35 @@ function pretty_break(pp::PrettyPrinter, msg::Proto.Break) end function pretty_monoid_def(pp::PrettyPrinter, msg::Proto.MonoidDef) - flat1296 = try_flat(pp, msg, pretty_monoid_def) - if !isnothing(flat1296) - write(pp, flat1296) + flat1298 = try_flat(pp, msg, pretty_monoid_def) + if !isnothing(flat1298) + write(pp, flat1298) return nothing else _dollar_dollar = msg if !isempty(_dollar_dollar.attrs) - _t1722 = _dollar_dollar.attrs + _t1726 = _dollar_dollar.attrs else - _t1722 = nothing + _t1726 = nothing end - fields1289 = (_dollar_dollar.monoid, _dollar_dollar.name, (_dollar_dollar.body, _dollar_dollar.value_arity,), _t1722,) - unwrapped_fields1290 = fields1289 + fields1291 = (_dollar_dollar.monoid, _dollar_dollar.name, (_dollar_dollar.body, _dollar_dollar.value_arity,), _t1726,) + unwrapped_fields1292 = fields1291 write(pp, "(monoid") indent_sexp!(pp) newline(pp) - field1291 = unwrapped_fields1290[1] - pretty_monoid(pp, field1291) + field1293 = unwrapped_fields1292[1] + pretty_monoid(pp, field1293) newline(pp) - field1292 = unwrapped_fields1290[2] - pretty_relation_id(pp, field1292) + field1294 = unwrapped_fields1292[2] + pretty_relation_id(pp, field1294) newline(pp) - field1293 = unwrapped_fields1290[3] - pretty_abstraction_with_arity(pp, field1293) - field1294 = unwrapped_fields1290[4] - if !isnothing(field1294) + field1295 = unwrapped_fields1292[3] + pretty_abstraction_with_arity(pp, field1295) + field1296 = unwrapped_fields1292[4] + if !isnothing(field1296) newline(pp) - opt_val1295 = field1294 - pretty_attrs(pp, opt_val1295) + opt_val1297 = field1296 + pretty_attrs(pp, opt_val1297) end dedent!(pp) write(pp, ")") @@ -3358,54 +3358,54 @@ function pretty_monoid_def(pp::PrettyPrinter, msg::Proto.MonoidDef) end function pretty_monoid(pp::PrettyPrinter, msg::Proto.Monoid) - flat1305 = try_flat(pp, msg, pretty_monoid) - if !isnothing(flat1305) - write(pp, flat1305) + flat1307 = try_flat(pp, msg, pretty_monoid) + if !isnothing(flat1307) + write(pp, flat1307) return nothing else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("or_monoid")) - _t1723 = _get_oneof_field(_dollar_dollar, :or_monoid) + _t1727 = _get_oneof_field(_dollar_dollar, :or_monoid) else - _t1723 = nothing + _t1727 = nothing end - deconstruct_result1303 = _t1723 - if !isnothing(deconstruct_result1303) - unwrapped1304 = deconstruct_result1303 - pretty_or_monoid(pp, unwrapped1304) + deconstruct_result1305 = _t1727 + if !isnothing(deconstruct_result1305) + unwrapped1306 = deconstruct_result1305 + pretty_or_monoid(pp, unwrapped1306) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("min_monoid")) - _t1724 = _get_oneof_field(_dollar_dollar, :min_monoid) + _t1728 = _get_oneof_field(_dollar_dollar, :min_monoid) else - _t1724 = nothing + _t1728 = nothing end - deconstruct_result1301 = _t1724 - if !isnothing(deconstruct_result1301) - unwrapped1302 = deconstruct_result1301 - pretty_min_monoid(pp, unwrapped1302) + deconstruct_result1303 = _t1728 + if !isnothing(deconstruct_result1303) + unwrapped1304 = deconstruct_result1303 + pretty_min_monoid(pp, unwrapped1304) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("max_monoid")) - _t1725 = _get_oneof_field(_dollar_dollar, :max_monoid) + _t1729 = _get_oneof_field(_dollar_dollar, :max_monoid) else - _t1725 = nothing + _t1729 = nothing end - deconstruct_result1299 = _t1725 - if !isnothing(deconstruct_result1299) - unwrapped1300 = deconstruct_result1299 - pretty_max_monoid(pp, unwrapped1300) + deconstruct_result1301 = _t1729 + if !isnothing(deconstruct_result1301) + unwrapped1302 = deconstruct_result1301 + pretty_max_monoid(pp, unwrapped1302) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("sum_monoid")) - _t1726 = _get_oneof_field(_dollar_dollar, :sum_monoid) + _t1730 = _get_oneof_field(_dollar_dollar, :sum_monoid) else - _t1726 = nothing + _t1730 = nothing end - deconstruct_result1297 = _t1726 - if !isnothing(deconstruct_result1297) - unwrapped1298 = deconstruct_result1297 - pretty_sum_monoid(pp, unwrapped1298) + deconstruct_result1299 = _t1730 + if !isnothing(deconstruct_result1299) + unwrapped1300 = deconstruct_result1299 + pretty_sum_monoid(pp, unwrapped1300) else throw(ParseError("No matching rule for monoid")) end @@ -3417,24 +3417,24 @@ function pretty_monoid(pp::PrettyPrinter, msg::Proto.Monoid) end function pretty_or_monoid(pp::PrettyPrinter, msg::Proto.OrMonoid) - fields1306 = msg + fields1308 = msg write(pp, "(or)") return nothing end function pretty_min_monoid(pp::PrettyPrinter, msg::Proto.MinMonoid) - flat1309 = try_flat(pp, msg, pretty_min_monoid) - if !isnothing(flat1309) - write(pp, flat1309) + flat1311 = try_flat(pp, msg, pretty_min_monoid) + if !isnothing(flat1311) + write(pp, flat1311) return nothing else _dollar_dollar = msg - fields1307 = _dollar_dollar.var"#type" - unwrapped_fields1308 = fields1307 + fields1309 = _dollar_dollar.var"#type" + unwrapped_fields1310 = fields1309 write(pp, "(min") indent_sexp!(pp) newline(pp) - pretty_type(pp, unwrapped_fields1308) + pretty_type(pp, unwrapped_fields1310) dedent!(pp) write(pp, ")") end @@ -3442,18 +3442,18 @@ function pretty_min_monoid(pp::PrettyPrinter, msg::Proto.MinMonoid) end function pretty_max_monoid(pp::PrettyPrinter, msg::Proto.MaxMonoid) - flat1312 = try_flat(pp, msg, pretty_max_monoid) - if !isnothing(flat1312) - write(pp, flat1312) + flat1314 = try_flat(pp, msg, pretty_max_monoid) + if !isnothing(flat1314) + write(pp, flat1314) return nothing else _dollar_dollar = msg - fields1310 = _dollar_dollar.var"#type" - unwrapped_fields1311 = fields1310 + fields1312 = _dollar_dollar.var"#type" + unwrapped_fields1313 = fields1312 write(pp, "(max") indent_sexp!(pp) newline(pp) - pretty_type(pp, unwrapped_fields1311) + pretty_type(pp, unwrapped_fields1313) dedent!(pp) write(pp, ")") end @@ -3461,18 +3461,18 @@ function pretty_max_monoid(pp::PrettyPrinter, msg::Proto.MaxMonoid) end function pretty_sum_monoid(pp::PrettyPrinter, msg::Proto.SumMonoid) - flat1315 = try_flat(pp, msg, pretty_sum_monoid) - if !isnothing(flat1315) - write(pp, flat1315) + flat1317 = try_flat(pp, msg, pretty_sum_monoid) + if !isnothing(flat1317) + write(pp, flat1317) return nothing else _dollar_dollar = msg - fields1313 = _dollar_dollar.var"#type" - unwrapped_fields1314 = fields1313 + fields1315 = _dollar_dollar.var"#type" + unwrapped_fields1316 = fields1315 write(pp, "(sum") indent_sexp!(pp) newline(pp) - pretty_type(pp, unwrapped_fields1314) + pretty_type(pp, unwrapped_fields1316) dedent!(pp) write(pp, ")") end @@ -3480,35 +3480,35 @@ function pretty_sum_monoid(pp::PrettyPrinter, msg::Proto.SumMonoid) end function pretty_monus_def(pp::PrettyPrinter, msg::Proto.MonusDef) - flat1323 = try_flat(pp, msg, pretty_monus_def) - if !isnothing(flat1323) - write(pp, flat1323) + flat1325 = try_flat(pp, msg, pretty_monus_def) + if !isnothing(flat1325) + write(pp, flat1325) return nothing else _dollar_dollar = msg if !isempty(_dollar_dollar.attrs) - _t1727 = _dollar_dollar.attrs + _t1731 = _dollar_dollar.attrs else - _t1727 = nothing + _t1731 = nothing end - fields1316 = (_dollar_dollar.monoid, _dollar_dollar.name, (_dollar_dollar.body, _dollar_dollar.value_arity,), _t1727,) - unwrapped_fields1317 = fields1316 + fields1318 = (_dollar_dollar.monoid, _dollar_dollar.name, (_dollar_dollar.body, _dollar_dollar.value_arity,), _t1731,) + unwrapped_fields1319 = fields1318 write(pp, "(monus") indent_sexp!(pp) newline(pp) - field1318 = unwrapped_fields1317[1] - pretty_monoid(pp, field1318) + field1320 = unwrapped_fields1319[1] + pretty_monoid(pp, field1320) newline(pp) - field1319 = unwrapped_fields1317[2] - pretty_relation_id(pp, field1319) + field1321 = unwrapped_fields1319[2] + pretty_relation_id(pp, field1321) newline(pp) - field1320 = unwrapped_fields1317[3] - pretty_abstraction_with_arity(pp, field1320) - field1321 = unwrapped_fields1317[4] - if !isnothing(field1321) + field1322 = unwrapped_fields1319[3] + pretty_abstraction_with_arity(pp, field1322) + field1323 = unwrapped_fields1319[4] + if !isnothing(field1323) newline(pp) - opt_val1322 = field1321 - pretty_attrs(pp, opt_val1322) + opt_val1324 = field1323 + pretty_attrs(pp, opt_val1324) end dedent!(pp) write(pp, ")") @@ -3517,28 +3517,28 @@ function pretty_monus_def(pp::PrettyPrinter, msg::Proto.MonusDef) end function pretty_constraint(pp::PrettyPrinter, msg::Proto.Constraint) - flat1330 = try_flat(pp, msg, pretty_constraint) - if !isnothing(flat1330) - write(pp, flat1330) + flat1332 = try_flat(pp, msg, pretty_constraint) + if !isnothing(flat1332) + write(pp, flat1332) return nothing else _dollar_dollar = msg - fields1324 = (_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_fields1325 = fields1324 + fields1326 = (_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_fields1327 = fields1326 write(pp, "(functional_dependency") indent_sexp!(pp) newline(pp) - field1326 = unwrapped_fields1325[1] - pretty_relation_id(pp, field1326) + field1328 = unwrapped_fields1327[1] + pretty_relation_id(pp, field1328) newline(pp) - field1327 = unwrapped_fields1325[2] - pretty_abstraction(pp, field1327) + field1329 = unwrapped_fields1327[2] + pretty_abstraction(pp, field1329) newline(pp) - field1328 = unwrapped_fields1325[3] - pretty_functional_dependency_keys(pp, field1328) + field1330 = unwrapped_fields1327[3] + pretty_functional_dependency_keys(pp, field1330) newline(pp) - field1329 = unwrapped_fields1325[4] - pretty_functional_dependency_values(pp, field1329) + field1331 = unwrapped_fields1327[4] + pretty_functional_dependency_values(pp, field1331) dedent!(pp) write(pp, ")") end @@ -3546,22 +3546,22 @@ function pretty_constraint(pp::PrettyPrinter, msg::Proto.Constraint) end function pretty_functional_dependency_keys(pp::PrettyPrinter, msg::Vector{Proto.Var}) - flat1334 = try_flat(pp, msg, pretty_functional_dependency_keys) - if !isnothing(flat1334) - write(pp, flat1334) + flat1336 = try_flat(pp, msg, pretty_functional_dependency_keys) + if !isnothing(flat1336) + write(pp, flat1336) return nothing else - fields1331 = msg + fields1333 = msg write(pp, "(keys") indent_sexp!(pp) - if !isempty(fields1331) + if !isempty(fields1333) newline(pp) - for (i1728, elem1332) in enumerate(fields1331) - i1333 = i1728 - 1 - if (i1333 > 0) + for (i1732, elem1334) in enumerate(fields1333) + i1335 = i1732 - 1 + if (i1335 > 0) newline(pp) end - pretty_var(pp, elem1332) + pretty_var(pp, elem1334) end end dedent!(pp) @@ -3571,22 +3571,22 @@ function pretty_functional_dependency_keys(pp::PrettyPrinter, msg::Vector{Proto. end function pretty_functional_dependency_values(pp::PrettyPrinter, msg::Vector{Proto.Var}) - flat1338 = try_flat(pp, msg, pretty_functional_dependency_values) - if !isnothing(flat1338) - write(pp, flat1338) + flat1340 = try_flat(pp, msg, pretty_functional_dependency_values) + if !isnothing(flat1340) + write(pp, flat1340) return nothing else - fields1335 = msg + fields1337 = msg write(pp, "(values") indent_sexp!(pp) - if !isempty(fields1335) + if !isempty(fields1337) newline(pp) - for (i1729, elem1336) in enumerate(fields1335) - i1337 = i1729 - 1 - if (i1337 > 0) + for (i1733, elem1338) in enumerate(fields1337) + i1339 = i1733 - 1 + if (i1339 > 0) newline(pp) end - pretty_var(pp, elem1336) + pretty_var(pp, elem1338) end end dedent!(pp) @@ -3596,54 +3596,54 @@ function pretty_functional_dependency_values(pp::PrettyPrinter, msg::Vector{Prot end function pretty_data(pp::PrettyPrinter, msg::Proto.Data) - flat1347 = try_flat(pp, msg, pretty_data) - if !isnothing(flat1347) - write(pp, flat1347) + flat1349 = try_flat(pp, msg, pretty_data) + if !isnothing(flat1349) + write(pp, flat1349) return nothing else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("edb")) - _t1730 = _get_oneof_field(_dollar_dollar, :edb) + _t1734 = _get_oneof_field(_dollar_dollar, :edb) else - _t1730 = nothing + _t1734 = nothing end - deconstruct_result1345 = _t1730 - if !isnothing(deconstruct_result1345) - unwrapped1346 = deconstruct_result1345 - pretty_edb(pp, unwrapped1346) + deconstruct_result1347 = _t1734 + if !isnothing(deconstruct_result1347) + unwrapped1348 = deconstruct_result1347 + pretty_edb(pp, unwrapped1348) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("betree_relation")) - _t1731 = _get_oneof_field(_dollar_dollar, :betree_relation) + _t1735 = _get_oneof_field(_dollar_dollar, :betree_relation) else - _t1731 = nothing + _t1735 = nothing end - deconstruct_result1343 = _t1731 - if !isnothing(deconstruct_result1343) - unwrapped1344 = deconstruct_result1343 - pretty_betree_relation(pp, unwrapped1344) + deconstruct_result1345 = _t1735 + if !isnothing(deconstruct_result1345) + unwrapped1346 = deconstruct_result1345 + pretty_betree_relation(pp, unwrapped1346) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("csv_data")) - _t1732 = _get_oneof_field(_dollar_dollar, :csv_data) + _t1736 = _get_oneof_field(_dollar_dollar, :csv_data) else - _t1732 = nothing + _t1736 = nothing end - deconstruct_result1341 = _t1732 - if !isnothing(deconstruct_result1341) - unwrapped1342 = deconstruct_result1341 - pretty_csv_data(pp, unwrapped1342) + deconstruct_result1343 = _t1736 + if !isnothing(deconstruct_result1343) + unwrapped1344 = deconstruct_result1343 + pretty_csv_data(pp, unwrapped1344) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("iceberg_data")) - _t1733 = _get_oneof_field(_dollar_dollar, :iceberg_data) + _t1737 = _get_oneof_field(_dollar_dollar, :iceberg_data) else - _t1733 = nothing + _t1737 = nothing end - deconstruct_result1339 = _t1733 - if !isnothing(deconstruct_result1339) - unwrapped1340 = deconstruct_result1339 - pretty_iceberg_data(pp, unwrapped1340) + deconstruct_result1341 = _t1737 + if !isnothing(deconstruct_result1341) + unwrapped1342 = deconstruct_result1341 + pretty_iceberg_data(pp, unwrapped1342) else throw(ParseError("No matching rule for data")) end @@ -3655,25 +3655,25 @@ function pretty_data(pp::PrettyPrinter, msg::Proto.Data) end function pretty_edb(pp::PrettyPrinter, msg::Proto.EDB) - flat1353 = try_flat(pp, msg, pretty_edb) - if !isnothing(flat1353) - write(pp, flat1353) + flat1355 = try_flat(pp, msg, pretty_edb) + if !isnothing(flat1355) + write(pp, flat1355) return nothing else _dollar_dollar = msg - fields1348 = (_dollar_dollar.target_id, _dollar_dollar.path, _dollar_dollar.types,) - unwrapped_fields1349 = fields1348 + fields1350 = (_dollar_dollar.target_id, _dollar_dollar.path, _dollar_dollar.types,) + unwrapped_fields1351 = fields1350 write(pp, "(edb") indent_sexp!(pp) newline(pp) - field1350 = unwrapped_fields1349[1] - pretty_relation_id(pp, field1350) + field1352 = unwrapped_fields1351[1] + pretty_relation_id(pp, field1352) newline(pp) - field1351 = unwrapped_fields1349[2] - pretty_edb_path(pp, field1351) + field1353 = unwrapped_fields1351[2] + pretty_edb_path(pp, field1353) newline(pp) - field1352 = unwrapped_fields1349[3] - pretty_edb_types(pp, field1352) + field1354 = unwrapped_fields1351[3] + pretty_edb_types(pp, field1354) dedent!(pp) write(pp, ")") end @@ -3681,20 +3681,20 @@ function pretty_edb(pp::PrettyPrinter, msg::Proto.EDB) end function pretty_edb_path(pp::PrettyPrinter, msg::Vector{String}) - flat1357 = try_flat(pp, msg, pretty_edb_path) - if !isnothing(flat1357) - write(pp, flat1357) + flat1359 = try_flat(pp, msg, pretty_edb_path) + if !isnothing(flat1359) + write(pp, flat1359) return nothing else - fields1354 = msg + fields1356 = msg write(pp, "[") indent!(pp) - for (i1734, elem1355) in enumerate(fields1354) - i1356 = i1734 - 1 - if (i1356 > 0) + for (i1738, elem1357) in enumerate(fields1356) + i1358 = i1738 - 1 + if (i1358 > 0) newline(pp) end - write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, elem1355)) + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, elem1357)) end dedent!(pp) write(pp, "]") @@ -3703,20 +3703,20 @@ function pretty_edb_path(pp::PrettyPrinter, msg::Vector{String}) end function pretty_edb_types(pp::PrettyPrinter, msg::Vector{Proto.var"#Type"}) - flat1361 = try_flat(pp, msg, pretty_edb_types) - if !isnothing(flat1361) - write(pp, flat1361) + flat1363 = try_flat(pp, msg, pretty_edb_types) + if !isnothing(flat1363) + write(pp, flat1363) return nothing else - fields1358 = msg + fields1360 = msg write(pp, "[") indent!(pp) - for (i1735, elem1359) in enumerate(fields1358) - i1360 = i1735 - 1 - if (i1360 > 0) + for (i1739, elem1361) in enumerate(fields1360) + i1362 = i1739 - 1 + if (i1362 > 0) newline(pp) end - pretty_type(pp, elem1359) + pretty_type(pp, elem1361) end dedent!(pp) write(pp, "]") @@ -3725,22 +3725,22 @@ function pretty_edb_types(pp::PrettyPrinter, msg::Vector{Proto.var"#Type"}) end function pretty_betree_relation(pp::PrettyPrinter, msg::Proto.BeTreeRelation) - flat1366 = try_flat(pp, msg, pretty_betree_relation) - if !isnothing(flat1366) - write(pp, flat1366) + flat1368 = try_flat(pp, msg, pretty_betree_relation) + if !isnothing(flat1368) + write(pp, flat1368) return nothing else _dollar_dollar = msg - fields1362 = (_dollar_dollar.name, _dollar_dollar.relation_info,) - unwrapped_fields1363 = fields1362 + fields1364 = (_dollar_dollar.name, _dollar_dollar.relation_info,) + unwrapped_fields1365 = fields1364 write(pp, "(betree_relation") indent_sexp!(pp) newline(pp) - field1364 = unwrapped_fields1363[1] - pretty_relation_id(pp, field1364) + field1366 = unwrapped_fields1365[1] + pretty_relation_id(pp, field1366) newline(pp) - field1365 = unwrapped_fields1363[2] - pretty_betree_info(pp, field1365) + field1367 = unwrapped_fields1365[2] + pretty_betree_info(pp, field1367) dedent!(pp) write(pp, ")") end @@ -3748,26 +3748,26 @@ function pretty_betree_relation(pp::PrettyPrinter, msg::Proto.BeTreeRelation) end function pretty_betree_info(pp::PrettyPrinter, msg::Proto.BeTreeInfo) - flat1372 = try_flat(pp, msg, pretty_betree_info) - if !isnothing(flat1372) - write(pp, flat1372) + flat1374 = try_flat(pp, msg, pretty_betree_info) + if !isnothing(flat1374) + write(pp, flat1374) return nothing else _dollar_dollar = msg - _t1736 = deconstruct_betree_info_config(pp, _dollar_dollar) - fields1367 = (_dollar_dollar.key_types, _dollar_dollar.value_types, _t1736,) - unwrapped_fields1368 = fields1367 + _t1740 = deconstruct_betree_info_config(pp, _dollar_dollar) + fields1369 = (_dollar_dollar.key_types, _dollar_dollar.value_types, _t1740,) + unwrapped_fields1370 = fields1369 write(pp, "(betree_info") indent_sexp!(pp) newline(pp) - field1369 = unwrapped_fields1368[1] - pretty_betree_info_key_types(pp, field1369) + field1371 = unwrapped_fields1370[1] + pretty_betree_info_key_types(pp, field1371) newline(pp) - field1370 = unwrapped_fields1368[2] - pretty_betree_info_value_types(pp, field1370) + field1372 = unwrapped_fields1370[2] + pretty_betree_info_value_types(pp, field1372) newline(pp) - field1371 = unwrapped_fields1368[3] - pretty_config_dict(pp, field1371) + field1373 = unwrapped_fields1370[3] + pretty_config_dict(pp, field1373) dedent!(pp) write(pp, ")") end @@ -3775,22 +3775,22 @@ function pretty_betree_info(pp::PrettyPrinter, msg::Proto.BeTreeInfo) end function pretty_betree_info_key_types(pp::PrettyPrinter, msg::Vector{Proto.var"#Type"}) - flat1376 = try_flat(pp, msg, pretty_betree_info_key_types) - if !isnothing(flat1376) - write(pp, flat1376) + flat1378 = try_flat(pp, msg, pretty_betree_info_key_types) + if !isnothing(flat1378) + write(pp, flat1378) return nothing else - fields1373 = msg + fields1375 = msg write(pp, "(key_types") indent_sexp!(pp) - if !isempty(fields1373) + if !isempty(fields1375) newline(pp) - for (i1737, elem1374) in enumerate(fields1373) - i1375 = i1737 - 1 - if (i1375 > 0) + for (i1741, elem1376) in enumerate(fields1375) + i1377 = i1741 - 1 + if (i1377 > 0) newline(pp) end - pretty_type(pp, elem1374) + pretty_type(pp, elem1376) end end dedent!(pp) @@ -3800,22 +3800,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"}) - flat1380 = try_flat(pp, msg, pretty_betree_info_value_types) - if !isnothing(flat1380) - write(pp, flat1380) + flat1382 = try_flat(pp, msg, pretty_betree_info_value_types) + if !isnothing(flat1382) + write(pp, flat1382) return nothing else - fields1377 = msg + fields1379 = msg write(pp, "(value_types") indent_sexp!(pp) - if !isempty(fields1377) + if !isempty(fields1379) newline(pp) - for (i1738, elem1378) in enumerate(fields1377) - i1379 = i1738 - 1 - if (i1379 > 0) + for (i1742, elem1380) in enumerate(fields1379) + i1381 = i1742 - 1 + if (i1381 > 0) newline(pp) end - pretty_type(pp, elem1378) + pretty_type(pp, elem1380) end end dedent!(pp) @@ -3825,28 +3825,28 @@ function pretty_betree_info_value_types(pp::PrettyPrinter, msg::Vector{Proto.var end function pretty_csv_data(pp::PrettyPrinter, msg::Proto.CSVData) - flat1387 = try_flat(pp, msg, pretty_csv_data) - if !isnothing(flat1387) - write(pp, flat1387) + flat1389 = try_flat(pp, msg, pretty_csv_data) + if !isnothing(flat1389) + write(pp, flat1389) return nothing else _dollar_dollar = msg - fields1381 = (_dollar_dollar.locator, _dollar_dollar.config, _dollar_dollar.columns, _dollar_dollar.asof,) - unwrapped_fields1382 = fields1381 + fields1383 = (_dollar_dollar.locator, _dollar_dollar.config, _dollar_dollar.columns, _dollar_dollar.asof,) + unwrapped_fields1384 = fields1383 write(pp, "(csv_data") indent_sexp!(pp) newline(pp) - field1383 = unwrapped_fields1382[1] - pretty_csvlocator(pp, field1383) + field1385 = unwrapped_fields1384[1] + pretty_csvlocator(pp, field1385) newline(pp) - field1384 = unwrapped_fields1382[2] - pretty_csv_config(pp, field1384) + field1386 = unwrapped_fields1384[2] + pretty_csv_config(pp, field1386) newline(pp) - field1385 = unwrapped_fields1382[3] - pretty_gnf_columns(pp, field1385) + field1387 = unwrapped_fields1384[3] + pretty_gnf_columns(pp, field1387) newline(pp) - field1386 = unwrapped_fields1382[4] - pretty_csv_asof(pp, field1386) + field1388 = unwrapped_fields1384[4] + pretty_csv_asof(pp, field1388) dedent!(pp) write(pp, ")") end @@ -3854,37 +3854,37 @@ function pretty_csv_data(pp::PrettyPrinter, msg::Proto.CSVData) end function pretty_csvlocator(pp::PrettyPrinter, msg::Proto.CSVLocator) - flat1394 = try_flat(pp, msg, pretty_csvlocator) - if !isnothing(flat1394) - write(pp, flat1394) + flat1396 = try_flat(pp, msg, pretty_csvlocator) + if !isnothing(flat1396) + write(pp, flat1396) return nothing else _dollar_dollar = msg if !isempty(_dollar_dollar.paths) - _t1739 = _dollar_dollar.paths + _t1743 = _dollar_dollar.paths else - _t1739 = nothing + _t1743 = nothing end if String(copy(_dollar_dollar.inline_data)) != "" - _t1740 = String(copy(_dollar_dollar.inline_data)) + _t1744 = String(copy(_dollar_dollar.inline_data)) else - _t1740 = nothing + _t1744 = nothing end - fields1388 = (_t1739, _t1740,) - unwrapped_fields1389 = fields1388 + fields1390 = (_t1743, _t1744,) + unwrapped_fields1391 = fields1390 write(pp, "(csv_locator") indent_sexp!(pp) - field1390 = unwrapped_fields1389[1] - if !isnothing(field1390) - newline(pp) - opt_val1391 = field1390 - pretty_csv_locator_paths(pp, opt_val1391) - end - field1392 = unwrapped_fields1389[2] + field1392 = unwrapped_fields1391[1] if !isnothing(field1392) newline(pp) opt_val1393 = field1392 - pretty_csv_locator_inline_data(pp, opt_val1393) + pretty_csv_locator_paths(pp, opt_val1393) + end + field1394 = unwrapped_fields1391[2] + if !isnothing(field1394) + newline(pp) + opt_val1395 = field1394 + pretty_csv_locator_inline_data(pp, opt_val1395) end dedent!(pp) write(pp, ")") @@ -3893,22 +3893,22 @@ function pretty_csvlocator(pp::PrettyPrinter, msg::Proto.CSVLocator) end function pretty_csv_locator_paths(pp::PrettyPrinter, msg::Vector{String}) - flat1398 = try_flat(pp, msg, pretty_csv_locator_paths) - if !isnothing(flat1398) - write(pp, flat1398) + flat1400 = try_flat(pp, msg, pretty_csv_locator_paths) + if !isnothing(flat1400) + write(pp, flat1400) return nothing else - fields1395 = msg + fields1397 = msg write(pp, "(paths") indent_sexp!(pp) - if !isempty(fields1395) + if !isempty(fields1397) newline(pp) - for (i1741, elem1396) in enumerate(fields1395) - i1397 = i1741 - 1 - if (i1397 > 0) + for (i1745, elem1398) in enumerate(fields1397) + i1399 = i1745 - 1 + if (i1399 > 0) newline(pp) end - write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, elem1396)) + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, elem1398)) end end dedent!(pp) @@ -3918,16 +3918,16 @@ function pretty_csv_locator_paths(pp::PrettyPrinter, msg::Vector{String}) end function pretty_csv_locator_inline_data(pp::PrettyPrinter, msg::String) - flat1400 = try_flat(pp, msg, pretty_csv_locator_inline_data) - if !isnothing(flat1400) - write(pp, flat1400) + flat1402 = try_flat(pp, msg, pretty_csv_locator_inline_data) + if !isnothing(flat1402) + write(pp, flat1402) return nothing else - fields1399 = msg + fields1401 = msg write(pp, "(inline_data") indent_sexp!(pp) newline(pp) - write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, fields1399)) + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, fields1401)) dedent!(pp) write(pp, ")") end @@ -3935,19 +3935,19 @@ function pretty_csv_locator_inline_data(pp::PrettyPrinter, msg::String) end function pretty_csv_config(pp::PrettyPrinter, msg::Proto.CSVConfig) - flat1403 = try_flat(pp, msg, pretty_csv_config) - if !isnothing(flat1403) - write(pp, flat1403) + flat1405 = try_flat(pp, msg, pretty_csv_config) + if !isnothing(flat1405) + write(pp, flat1405) return nothing else _dollar_dollar = msg - _t1742 = deconstruct_csv_config(pp, _dollar_dollar) - fields1401 = _t1742 - unwrapped_fields1402 = fields1401 + _t1746 = deconstruct_csv_config(pp, _dollar_dollar) + fields1403 = _t1746 + unwrapped_fields1404 = fields1403 write(pp, "(csv_config") indent_sexp!(pp) newline(pp) - pretty_config_dict(pp, unwrapped_fields1402) + pretty_config_dict(pp, unwrapped_fields1404) dedent!(pp) write(pp, ")") end @@ -3955,22 +3955,22 @@ function pretty_csv_config(pp::PrettyPrinter, msg::Proto.CSVConfig) end function pretty_gnf_columns(pp::PrettyPrinter, msg::Vector{Proto.GNFColumn}) - flat1407 = try_flat(pp, msg, pretty_gnf_columns) - if !isnothing(flat1407) - write(pp, flat1407) + flat1409 = try_flat(pp, msg, pretty_gnf_columns) + if !isnothing(flat1409) + write(pp, flat1409) return nothing else - fields1404 = msg + fields1406 = msg write(pp, "(columns") indent_sexp!(pp) - if !isempty(fields1404) + if !isempty(fields1406) newline(pp) - for (i1743, elem1405) in enumerate(fields1404) - i1406 = i1743 - 1 - if (i1406 > 0) + for (i1747, elem1407) in enumerate(fields1406) + i1408 = i1747 - 1 + if (i1408 > 0) newline(pp) end - pretty_gnf_column(pp, elem1405) + pretty_gnf_column(pp, elem1407) end end dedent!(pp) @@ -3980,39 +3980,39 @@ function pretty_gnf_columns(pp::PrettyPrinter, msg::Vector{Proto.GNFColumn}) end function pretty_gnf_column(pp::PrettyPrinter, msg::Proto.GNFColumn) - flat1416 = try_flat(pp, msg, pretty_gnf_column) - if !isnothing(flat1416) - write(pp, flat1416) + flat1418 = try_flat(pp, msg, pretty_gnf_column) + if !isnothing(flat1418) + write(pp, flat1418) return nothing else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("target_id")) - _t1744 = _dollar_dollar.target_id + _t1748 = _dollar_dollar.target_id else - _t1744 = nothing + _t1748 = nothing end - fields1408 = (_dollar_dollar.column_path, _t1744, _dollar_dollar.types,) - unwrapped_fields1409 = fields1408 + fields1410 = (_dollar_dollar.column_path, _t1748, _dollar_dollar.types,) + unwrapped_fields1411 = fields1410 write(pp, "(column") indent_sexp!(pp) newline(pp) - field1410 = unwrapped_fields1409[1] - pretty_gnf_column_path(pp, field1410) - field1411 = unwrapped_fields1409[2] - if !isnothing(field1411) + field1412 = unwrapped_fields1411[1] + pretty_gnf_column_path(pp, field1412) + field1413 = unwrapped_fields1411[2] + if !isnothing(field1413) newline(pp) - opt_val1412 = field1411 - pretty_relation_id(pp, opt_val1412) + opt_val1414 = field1413 + pretty_relation_id(pp, opt_val1414) end newline(pp) write(pp, "[") - field1413 = unwrapped_fields1409[3] - for (i1745, elem1414) in enumerate(field1413) - i1415 = i1745 - 1 - if (i1415 > 0) + field1415 = unwrapped_fields1411[3] + for (i1749, elem1416) in enumerate(field1415) + i1417 = i1749 - 1 + if (i1417 > 0) newline(pp) end - pretty_type(pp, elem1414) + pretty_type(pp, elem1416) end write(pp, "]") dedent!(pp) @@ -4022,39 +4022,39 @@ function pretty_gnf_column(pp::PrettyPrinter, msg::Proto.GNFColumn) end function pretty_gnf_column_path(pp::PrettyPrinter, msg::Vector{String}) - flat1423 = try_flat(pp, msg, pretty_gnf_column_path) - if !isnothing(flat1423) - write(pp, flat1423) + flat1425 = try_flat(pp, msg, pretty_gnf_column_path) + if !isnothing(flat1425) + write(pp, flat1425) return nothing else _dollar_dollar = msg if length(_dollar_dollar) == 1 - _t1746 = _dollar_dollar[1] + _t1750 = _dollar_dollar[1] else - _t1746 = nothing + _t1750 = nothing end - deconstruct_result1421 = _t1746 - if !isnothing(deconstruct_result1421) - unwrapped1422 = deconstruct_result1421 - write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, unwrapped1422)) + deconstruct_result1423 = _t1750 + if !isnothing(deconstruct_result1423) + unwrapped1424 = deconstruct_result1423 + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, unwrapped1424)) else _dollar_dollar = msg if length(_dollar_dollar) != 1 - _t1747 = _dollar_dollar + _t1751 = _dollar_dollar else - _t1747 = nothing + _t1751 = nothing end - deconstruct_result1417 = _t1747 - if !isnothing(deconstruct_result1417) - unwrapped1418 = deconstruct_result1417 + deconstruct_result1419 = _t1751 + if !isnothing(deconstruct_result1419) + unwrapped1420 = deconstruct_result1419 write(pp, "[") indent!(pp) - for (i1748, elem1419) in enumerate(unwrapped1418) - i1420 = i1748 - 1 - if (i1420 > 0) + for (i1752, elem1421) in enumerate(unwrapped1420) + i1422 = i1752 - 1 + if (i1422 > 0) newline(pp) end - write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, elem1419)) + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, elem1421)) end dedent!(pp) write(pp, "]") @@ -4067,16 +4067,16 @@ function pretty_gnf_column_path(pp::PrettyPrinter, msg::Vector{String}) end function pretty_csv_asof(pp::PrettyPrinter, msg::String) - flat1425 = try_flat(pp, msg, pretty_csv_asof) - if !isnothing(flat1425) - write(pp, flat1425) + flat1427 = try_flat(pp, msg, pretty_csv_asof) + if !isnothing(flat1427) + write(pp, flat1427) return nothing else - fields1424 = msg + fields1426 = msg write(pp, "(asof") indent_sexp!(pp) newline(pp) - write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, fields1424)) + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, fields1426)) dedent!(pp) write(pp, ")") end @@ -4084,42 +4084,42 @@ function pretty_csv_asof(pp::PrettyPrinter, msg::String) end function pretty_iceberg_data(pp::PrettyPrinter, msg::Proto.IcebergData) - flat1436 = try_flat(pp, msg, pretty_iceberg_data) - if !isnothing(flat1436) - write(pp, flat1436) + flat1438 = try_flat(pp, msg, pretty_iceberg_data) + if !isnothing(flat1438) + write(pp, flat1438) return nothing else _dollar_dollar = msg - _t1749 = deconstruct_iceberg_data_from_snapshot_optional(pp, _dollar_dollar) - _t1750 = deconstruct_iceberg_data_to_snapshot_optional(pp, _dollar_dollar) - fields1426 = (_dollar_dollar.locator, _dollar_dollar.config, _dollar_dollar.columns, _t1749, _t1750, _dollar_dollar.returns_delta,) - unwrapped_fields1427 = fields1426 + _t1753 = deconstruct_iceberg_data_from_snapshot_optional(pp, _dollar_dollar) + _t1754 = deconstruct_iceberg_data_to_snapshot_optional(pp, _dollar_dollar) + fields1428 = (_dollar_dollar.locator, _dollar_dollar.config, _dollar_dollar.columns, _t1753, _t1754, _dollar_dollar.returns_delta,) + unwrapped_fields1429 = fields1428 write(pp, "(iceberg_data") indent_sexp!(pp) newline(pp) - field1428 = unwrapped_fields1427[1] - pretty_iceberg_locator(pp, field1428) + field1430 = unwrapped_fields1429[1] + pretty_iceberg_locator(pp, field1430) newline(pp) - field1429 = unwrapped_fields1427[2] - pretty_iceberg_catalog_config(pp, field1429) + field1431 = unwrapped_fields1429[2] + pretty_iceberg_catalog_config(pp, field1431) newline(pp) - field1430 = unwrapped_fields1427[3] - pretty_gnf_columns(pp, field1430) - field1431 = unwrapped_fields1427[4] - if !isnothing(field1431) - newline(pp) - opt_val1432 = field1431 - pretty_iceberg_from_snapshot(pp, opt_val1432) - end - field1433 = unwrapped_fields1427[5] + field1432 = unwrapped_fields1429[3] + pretty_gnf_columns(pp, field1432) + field1433 = unwrapped_fields1429[4] if !isnothing(field1433) newline(pp) opt_val1434 = field1433 - pretty_iceberg_to_snapshot(pp, opt_val1434) + pretty_iceberg_from_snapshot(pp, opt_val1434) + end + field1435 = unwrapped_fields1429[5] + if !isnothing(field1435) + newline(pp) + opt_val1436 = field1435 + pretty_iceberg_to_snapshot(pp, opt_val1436) end newline(pp) - field1435 = unwrapped_fields1427[6] - pretty_boolean_value(pp, field1435) + field1437 = unwrapped_fields1429[6] + pretty_boolean_value(pp, field1437) dedent!(pp) write(pp, ")") end @@ -4127,25 +4127,25 @@ function pretty_iceberg_data(pp::PrettyPrinter, msg::Proto.IcebergData) end function pretty_iceberg_locator(pp::PrettyPrinter, msg::Proto.IcebergLocator) - flat1442 = try_flat(pp, msg, pretty_iceberg_locator) - if !isnothing(flat1442) - write(pp, flat1442) + flat1444 = try_flat(pp, msg, pretty_iceberg_locator) + if !isnothing(flat1444) + write(pp, flat1444) return nothing else _dollar_dollar = msg - fields1437 = (_dollar_dollar.table_name, _dollar_dollar.namespace, _dollar_dollar.warehouse,) - unwrapped_fields1438 = fields1437 + fields1439 = (_dollar_dollar.table_name, _dollar_dollar.namespace, _dollar_dollar.warehouse,) + unwrapped_fields1440 = fields1439 write(pp, "(iceberg_locator") indent_sexp!(pp) newline(pp) - field1439 = unwrapped_fields1438[1] - pretty_iceberg_locator_table_name(pp, field1439) + field1441 = unwrapped_fields1440[1] + pretty_iceberg_locator_table_name(pp, field1441) newline(pp) - field1440 = unwrapped_fields1438[2] - pretty_iceberg_locator_namespace(pp, field1440) + field1442 = unwrapped_fields1440[2] + pretty_iceberg_locator_namespace(pp, field1442) newline(pp) - field1441 = unwrapped_fields1438[3] - pretty_iceberg_locator_warehouse(pp, field1441) + field1443 = unwrapped_fields1440[3] + pretty_iceberg_locator_warehouse(pp, field1443) dedent!(pp) write(pp, ")") end @@ -4153,16 +4153,16 @@ function pretty_iceberg_locator(pp::PrettyPrinter, msg::Proto.IcebergLocator) end function pretty_iceberg_locator_table_name(pp::PrettyPrinter, msg::String) - flat1444 = try_flat(pp, msg, pretty_iceberg_locator_table_name) - if !isnothing(flat1444) - write(pp, flat1444) + flat1446 = try_flat(pp, msg, pretty_iceberg_locator_table_name) + if !isnothing(flat1446) + write(pp, flat1446) return nothing else - fields1443 = msg + fields1445 = msg write(pp, "(table_name") indent_sexp!(pp) newline(pp) - write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, fields1443)) + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, fields1445)) dedent!(pp) write(pp, ")") end @@ -4170,22 +4170,22 @@ function pretty_iceberg_locator_table_name(pp::PrettyPrinter, msg::String) end function pretty_iceberg_locator_namespace(pp::PrettyPrinter, msg::Vector{String}) - flat1448 = try_flat(pp, msg, pretty_iceberg_locator_namespace) - if !isnothing(flat1448) - write(pp, flat1448) + flat1450 = try_flat(pp, msg, pretty_iceberg_locator_namespace) + if !isnothing(flat1450) + write(pp, flat1450) return nothing else - fields1445 = msg + fields1447 = msg write(pp, "(namespace") indent_sexp!(pp) - if !isempty(fields1445) + if !isempty(fields1447) newline(pp) - for (i1751, elem1446) in enumerate(fields1445) - i1447 = i1751 - 1 - if (i1447 > 0) + for (i1755, elem1448) in enumerate(fields1447) + i1449 = i1755 - 1 + if (i1449 > 0) newline(pp) end - write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, elem1446)) + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, elem1448)) end end dedent!(pp) @@ -4195,16 +4195,16 @@ function pretty_iceberg_locator_namespace(pp::PrettyPrinter, msg::Vector{String} end function pretty_iceberg_locator_warehouse(pp::PrettyPrinter, msg::String) - flat1450 = try_flat(pp, msg, pretty_iceberg_locator_warehouse) - if !isnothing(flat1450) - write(pp, flat1450) + flat1452 = try_flat(pp, msg, pretty_iceberg_locator_warehouse) + if !isnothing(flat1452) + write(pp, flat1452) return nothing else - fields1449 = msg + fields1451 = msg write(pp, "(warehouse") indent_sexp!(pp) newline(pp) - write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, fields1449)) + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, fields1451)) dedent!(pp) write(pp, ")") end @@ -4212,32 +4212,32 @@ function pretty_iceberg_locator_warehouse(pp::PrettyPrinter, msg::String) end function pretty_iceberg_catalog_config(pp::PrettyPrinter, msg::Proto.IcebergCatalogConfig) - flat1458 = try_flat(pp, msg, pretty_iceberg_catalog_config) - if !isnothing(flat1458) - write(pp, flat1458) + flat1460 = try_flat(pp, msg, pretty_iceberg_catalog_config) + if !isnothing(flat1460) + write(pp, flat1460) return nothing else _dollar_dollar = msg - _t1752 = deconstruct_iceberg_catalog_config_scope_optional(pp, _dollar_dollar) - fields1451 = (_dollar_dollar.catalog_uri, _t1752, sort([(k, v) for (k, v) in _dollar_dollar.properties]), sort([(k, v) for (k, v) in _dollar_dollar.auth_properties]),) - unwrapped_fields1452 = fields1451 + _t1756 = deconstruct_iceberg_catalog_config_scope_optional(pp, _dollar_dollar) + fields1453 = (_dollar_dollar.catalog_uri, _t1756, sort([(k, v) for (k, v) in _dollar_dollar.properties]), sort([(k, v) for (k, v) in _dollar_dollar.auth_properties]),) + unwrapped_fields1454 = fields1453 write(pp, "(iceberg_catalog_config") indent_sexp!(pp) newline(pp) - field1453 = unwrapped_fields1452[1] - pretty_iceberg_catalog_uri(pp, field1453) - field1454 = unwrapped_fields1452[2] - if !isnothing(field1454) + field1455 = unwrapped_fields1454[1] + pretty_iceberg_catalog_uri(pp, field1455) + field1456 = unwrapped_fields1454[2] + if !isnothing(field1456) newline(pp) - opt_val1455 = field1454 - pretty_iceberg_catalog_config_scope(pp, opt_val1455) + opt_val1457 = field1456 + pretty_iceberg_catalog_config_scope(pp, opt_val1457) end newline(pp) - field1456 = unwrapped_fields1452[3] - pretty_iceberg_properties(pp, field1456) + field1458 = unwrapped_fields1454[3] + pretty_iceberg_properties(pp, field1458) newline(pp) - field1457 = unwrapped_fields1452[4] - pretty_iceberg_auth_properties(pp, field1457) + field1459 = unwrapped_fields1454[4] + pretty_iceberg_auth_properties(pp, field1459) dedent!(pp) write(pp, ")") end @@ -4245,16 +4245,16 @@ function pretty_iceberg_catalog_config(pp::PrettyPrinter, msg::Proto.IcebergCata end function pretty_iceberg_catalog_uri(pp::PrettyPrinter, msg::String) - flat1460 = try_flat(pp, msg, pretty_iceberg_catalog_uri) - if !isnothing(flat1460) - write(pp, flat1460) + flat1462 = try_flat(pp, msg, pretty_iceberg_catalog_uri) + if !isnothing(flat1462) + write(pp, flat1462) return nothing else - fields1459 = msg + fields1461 = msg write(pp, "(catalog_uri") indent_sexp!(pp) newline(pp) - write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, fields1459)) + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, fields1461)) dedent!(pp) write(pp, ")") end @@ -4262,16 +4262,16 @@ function pretty_iceberg_catalog_uri(pp::PrettyPrinter, msg::String) end function pretty_iceberg_catalog_config_scope(pp::PrettyPrinter, msg::String) - flat1462 = try_flat(pp, msg, pretty_iceberg_catalog_config_scope) - if !isnothing(flat1462) - write(pp, flat1462) + flat1464 = try_flat(pp, msg, pretty_iceberg_catalog_config_scope) + if !isnothing(flat1464) + write(pp, flat1464) return nothing else - fields1461 = msg + fields1463 = msg write(pp, "(scope") indent_sexp!(pp) newline(pp) - write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, fields1461)) + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, fields1463)) dedent!(pp) write(pp, ")") end @@ -4279,22 +4279,22 @@ function pretty_iceberg_catalog_config_scope(pp::PrettyPrinter, msg::String) end function pretty_iceberg_properties(pp::PrettyPrinter, msg::Vector{Tuple{String, String}}) - flat1466 = try_flat(pp, msg, pretty_iceberg_properties) - if !isnothing(flat1466) - write(pp, flat1466) + flat1468 = try_flat(pp, msg, pretty_iceberg_properties) + if !isnothing(flat1468) + write(pp, flat1468) return nothing else - fields1463 = msg + fields1465 = msg write(pp, "(properties") indent_sexp!(pp) - if !isempty(fields1463) + if !isempty(fields1465) newline(pp) - for (i1753, elem1464) in enumerate(fields1463) - i1465 = i1753 - 1 - if (i1465 > 0) + for (i1757, elem1466) in enumerate(fields1465) + i1467 = i1757 - 1 + if (i1467 > 0) newline(pp) end - pretty_iceberg_property_entry(pp, elem1464) + pretty_iceberg_property_entry(pp, elem1466) end end dedent!(pp) @@ -4304,22 +4304,22 @@ function pretty_iceberg_properties(pp::PrettyPrinter, msg::Vector{Tuple{String, end function pretty_iceberg_property_entry(pp::PrettyPrinter, msg::Tuple{String, String}) - flat1471 = try_flat(pp, msg, pretty_iceberg_property_entry) - if !isnothing(flat1471) - write(pp, flat1471) + flat1473 = try_flat(pp, msg, pretty_iceberg_property_entry) + if !isnothing(flat1473) + write(pp, flat1473) return nothing else _dollar_dollar = msg - fields1467 = (_dollar_dollar[1], _dollar_dollar[2],) - unwrapped_fields1468 = fields1467 + fields1469 = (_dollar_dollar[1], _dollar_dollar[2],) + unwrapped_fields1470 = fields1469 write(pp, "(prop") indent_sexp!(pp) newline(pp) - field1469 = unwrapped_fields1468[1] - write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, field1469)) + field1471 = unwrapped_fields1470[1] + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, field1471)) newline(pp) - field1470 = unwrapped_fields1468[2] - write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, field1470)) + field1472 = unwrapped_fields1470[2] + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, field1472)) dedent!(pp) write(pp, ")") end @@ -4327,22 +4327,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}}) - flat1475 = try_flat(pp, msg, pretty_iceberg_auth_properties) - if !isnothing(flat1475) - write(pp, flat1475) + flat1477 = try_flat(pp, msg, pretty_iceberg_auth_properties) + if !isnothing(flat1477) + write(pp, flat1477) return nothing else - fields1472 = msg + fields1474 = msg write(pp, "(auth_properties") indent_sexp!(pp) - if !isempty(fields1472) + if !isempty(fields1474) newline(pp) - for (i1754, elem1473) in enumerate(fields1472) - i1474 = i1754 - 1 - if (i1474 > 0) + for (i1758, elem1475) in enumerate(fields1474) + i1476 = i1758 - 1 + if (i1476 > 0) newline(pp) end - pretty_iceberg_masked_property_entry(pp, elem1473) + pretty_iceberg_masked_property_entry(pp, elem1475) end end dedent!(pp) @@ -4352,23 +4352,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}) - flat1480 = try_flat(pp, msg, pretty_iceberg_masked_property_entry) - if !isnothing(flat1480) - write(pp, flat1480) + flat1482 = try_flat(pp, msg, pretty_iceberg_masked_property_entry) + if !isnothing(flat1482) + write(pp, flat1482) return nothing else _dollar_dollar = msg - _t1755 = mask_secret_value(pp, _dollar_dollar) - fields1476 = (_dollar_dollar[1], _t1755,) - unwrapped_fields1477 = fields1476 + _t1759 = mask_secret_value(pp, _dollar_dollar) + fields1478 = (_dollar_dollar[1], _t1759,) + unwrapped_fields1479 = fields1478 write(pp, "(prop") indent_sexp!(pp) newline(pp) - field1478 = unwrapped_fields1477[1] - write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, field1478)) + field1480 = unwrapped_fields1479[1] + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, field1480)) newline(pp) - field1479 = unwrapped_fields1477[2] - write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, field1479)) + field1481 = unwrapped_fields1479[2] + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, field1481)) dedent!(pp) write(pp, ")") end @@ -4376,16 +4376,16 @@ function pretty_iceberg_masked_property_entry(pp::PrettyPrinter, msg::Tuple{Stri end function pretty_iceberg_from_snapshot(pp::PrettyPrinter, msg::String) - flat1482 = try_flat(pp, msg, pretty_iceberg_from_snapshot) - if !isnothing(flat1482) - write(pp, flat1482) + flat1484 = try_flat(pp, msg, pretty_iceberg_from_snapshot) + if !isnothing(flat1484) + write(pp, flat1484) return nothing else - fields1481 = msg + fields1483 = msg write(pp, "(from_snapshot") 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 @@ -4393,16 +4393,16 @@ function pretty_iceberg_from_snapshot(pp::PrettyPrinter, msg::String) end function pretty_iceberg_to_snapshot(pp::PrettyPrinter, msg::String) - flat1484 = try_flat(pp, msg, pretty_iceberg_to_snapshot) - if !isnothing(flat1484) - write(pp, flat1484) + flat1486 = try_flat(pp, msg, pretty_iceberg_to_snapshot) + if !isnothing(flat1486) + write(pp, flat1486) return nothing else - fields1483 = msg + fields1485 = msg write(pp, "(to_snapshot") indent_sexp!(pp) newline(pp) - write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, fields1483)) + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, fields1485)) dedent!(pp) write(pp, ")") end @@ -4410,18 +4410,18 @@ function pretty_iceberg_to_snapshot(pp::PrettyPrinter, msg::String) end function pretty_undefine(pp::PrettyPrinter, msg::Proto.Undefine) - flat1487 = try_flat(pp, msg, pretty_undefine) - if !isnothing(flat1487) - write(pp, flat1487) + flat1489 = try_flat(pp, msg, pretty_undefine) + if !isnothing(flat1489) + write(pp, flat1489) return nothing else _dollar_dollar = msg - fields1485 = _dollar_dollar.fragment_id - unwrapped_fields1486 = fields1485 + fields1487 = _dollar_dollar.fragment_id + unwrapped_fields1488 = fields1487 write(pp, "(undefine") indent_sexp!(pp) newline(pp) - pretty_fragment_id(pp, unwrapped_fields1486) + pretty_fragment_id(pp, unwrapped_fields1488) dedent!(pp) write(pp, ")") end @@ -4429,24 +4429,24 @@ function pretty_undefine(pp::PrettyPrinter, msg::Proto.Undefine) end function pretty_context(pp::PrettyPrinter, msg::Proto.Context) - flat1492 = try_flat(pp, msg, pretty_context) - if !isnothing(flat1492) - write(pp, flat1492) + flat1494 = try_flat(pp, msg, pretty_context) + if !isnothing(flat1494) + write(pp, flat1494) return nothing else _dollar_dollar = msg - fields1488 = _dollar_dollar.relations - unwrapped_fields1489 = fields1488 + fields1490 = _dollar_dollar.relations + unwrapped_fields1491 = fields1490 write(pp, "(context") indent_sexp!(pp) - if !isempty(unwrapped_fields1489) + if !isempty(unwrapped_fields1491) newline(pp) - for (i1756, elem1490) in enumerate(unwrapped_fields1489) - i1491 = i1756 - 1 - if (i1491 > 0) + for (i1760, elem1492) in enumerate(unwrapped_fields1491) + i1493 = i1760 - 1 + if (i1493 > 0) newline(pp) end - pretty_relation_id(pp, elem1490) + pretty_relation_id(pp, elem1492) end end dedent!(pp) @@ -4456,24 +4456,28 @@ function pretty_context(pp::PrettyPrinter, msg::Proto.Context) end function pretty_snapshot(pp::PrettyPrinter, msg::Proto.Snapshot) - flat1497 = try_flat(pp, msg, pretty_snapshot) - if !isnothing(flat1497) - write(pp, flat1497) + flat1501 = try_flat(pp, msg, pretty_snapshot) + if !isnothing(flat1501) + write(pp, flat1501) return nothing else _dollar_dollar = msg - fields1493 = _dollar_dollar.mappings - unwrapped_fields1494 = fields1493 + fields1495 = (_dollar_dollar.prefix, _dollar_dollar.mappings,) + unwrapped_fields1496 = fields1495 write(pp, "(snapshot") indent_sexp!(pp) - if !isempty(unwrapped_fields1494) + newline(pp) + field1497 = unwrapped_fields1496[1] + pretty_edb_path(pp, field1497) + field1498 = unwrapped_fields1496[2] + if !isempty(field1498) newline(pp) - for (i1757, elem1495) in enumerate(unwrapped_fields1494) - i1496 = i1757 - 1 - if (i1496 > 0) + for (i1761, elem1499) in enumerate(field1498) + i1500 = i1761 - 1 + if (i1500 > 0) newline(pp) end - pretty_snapshot_mapping(pp, elem1495) + pretty_snapshot_mapping(pp, elem1499) end end dedent!(pp) @@ -4483,40 +4487,40 @@ function pretty_snapshot(pp::PrettyPrinter, msg::Proto.Snapshot) end function pretty_snapshot_mapping(pp::PrettyPrinter, msg::Proto.SnapshotMapping) - flat1502 = try_flat(pp, msg, pretty_snapshot_mapping) - if !isnothing(flat1502) - write(pp, flat1502) + flat1506 = try_flat(pp, msg, pretty_snapshot_mapping) + if !isnothing(flat1506) + write(pp, flat1506) return nothing else _dollar_dollar = msg - fields1498 = (_dollar_dollar.destination_path, _dollar_dollar.source_relation,) - unwrapped_fields1499 = fields1498 - field1500 = unwrapped_fields1499[1] - pretty_edb_path(pp, field1500) + fields1502 = (_dollar_dollar.destination_path, _dollar_dollar.source_relation,) + unwrapped_fields1503 = fields1502 + field1504 = unwrapped_fields1503[1] + pretty_edb_path(pp, field1504) write(pp, " ") - field1501 = unwrapped_fields1499[2] - pretty_relation_id(pp, field1501) + field1505 = unwrapped_fields1503[2] + pretty_relation_id(pp, field1505) end return nothing end function pretty_epoch_reads(pp::PrettyPrinter, msg::Vector{Proto.Read}) - flat1506 = try_flat(pp, msg, pretty_epoch_reads) - if !isnothing(flat1506) - write(pp, flat1506) + flat1510 = try_flat(pp, msg, pretty_epoch_reads) + if !isnothing(flat1510) + write(pp, flat1510) return nothing else - fields1503 = msg + fields1507 = msg write(pp, "(reads") indent_sexp!(pp) - if !isempty(fields1503) + if !isempty(fields1507) newline(pp) - for (i1758, elem1504) in enumerate(fields1503) - i1505 = i1758 - 1 - if (i1505 > 0) + for (i1762, elem1508) in enumerate(fields1507) + i1509 = i1762 - 1 + if (i1509 > 0) newline(pp) end - pretty_read(pp, elem1504) + pretty_read(pp, elem1508) end end dedent!(pp) @@ -4526,65 +4530,65 @@ function pretty_epoch_reads(pp::PrettyPrinter, msg::Vector{Proto.Read}) end function pretty_read(pp::PrettyPrinter, msg::Proto.Read) - flat1517 = try_flat(pp, msg, pretty_read) - if !isnothing(flat1517) - write(pp, flat1517) + flat1521 = try_flat(pp, msg, pretty_read) + if !isnothing(flat1521) + write(pp, flat1521) return nothing else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("demand")) - _t1759 = _get_oneof_field(_dollar_dollar, :demand) + _t1763 = _get_oneof_field(_dollar_dollar, :demand) else - _t1759 = nothing + _t1763 = nothing end - deconstruct_result1515 = _t1759 - if !isnothing(deconstruct_result1515) - unwrapped1516 = deconstruct_result1515 - pretty_demand(pp, unwrapped1516) + deconstruct_result1519 = _t1763 + if !isnothing(deconstruct_result1519) + unwrapped1520 = deconstruct_result1519 + pretty_demand(pp, unwrapped1520) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("output")) - _t1760 = _get_oneof_field(_dollar_dollar, :output) + _t1764 = _get_oneof_field(_dollar_dollar, :output) else - _t1760 = nothing + _t1764 = nothing end - deconstruct_result1513 = _t1760 - if !isnothing(deconstruct_result1513) - unwrapped1514 = deconstruct_result1513 - pretty_output(pp, unwrapped1514) + deconstruct_result1517 = _t1764 + if !isnothing(deconstruct_result1517) + unwrapped1518 = deconstruct_result1517 + pretty_output(pp, unwrapped1518) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("what_if")) - _t1761 = _get_oneof_field(_dollar_dollar, :what_if) + _t1765 = _get_oneof_field(_dollar_dollar, :what_if) else - _t1761 = nothing + _t1765 = nothing end - deconstruct_result1511 = _t1761 - if !isnothing(deconstruct_result1511) - unwrapped1512 = deconstruct_result1511 - pretty_what_if(pp, unwrapped1512) + deconstruct_result1515 = _t1765 + if !isnothing(deconstruct_result1515) + unwrapped1516 = deconstruct_result1515 + pretty_what_if(pp, unwrapped1516) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("abort")) - _t1762 = _get_oneof_field(_dollar_dollar, :abort) + _t1766 = _get_oneof_field(_dollar_dollar, :abort) else - _t1762 = nothing + _t1766 = nothing end - deconstruct_result1509 = _t1762 - if !isnothing(deconstruct_result1509) - unwrapped1510 = deconstruct_result1509 - pretty_abort(pp, unwrapped1510) + deconstruct_result1513 = _t1766 + if !isnothing(deconstruct_result1513) + unwrapped1514 = deconstruct_result1513 + pretty_abort(pp, unwrapped1514) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("#export")) - _t1763 = _get_oneof_field(_dollar_dollar, :var"#export") + _t1767 = _get_oneof_field(_dollar_dollar, :var"#export") else - _t1763 = nothing + _t1767 = nothing end - deconstruct_result1507 = _t1763 - if !isnothing(deconstruct_result1507) - unwrapped1508 = deconstruct_result1507 - pretty_export(pp, unwrapped1508) + deconstruct_result1511 = _t1767 + if !isnothing(deconstruct_result1511) + unwrapped1512 = deconstruct_result1511 + pretty_export(pp, unwrapped1512) else throw(ParseError("No matching rule for read")) end @@ -4597,18 +4601,18 @@ function pretty_read(pp::PrettyPrinter, msg::Proto.Read) end function pretty_demand(pp::PrettyPrinter, msg::Proto.Demand) - flat1520 = try_flat(pp, msg, pretty_demand) - if !isnothing(flat1520) - write(pp, flat1520) + flat1524 = try_flat(pp, msg, pretty_demand) + if !isnothing(flat1524) + write(pp, flat1524) return nothing else _dollar_dollar = msg - fields1518 = _dollar_dollar.relation_id - unwrapped_fields1519 = fields1518 + fields1522 = _dollar_dollar.relation_id + unwrapped_fields1523 = fields1522 write(pp, "(demand") indent_sexp!(pp) newline(pp) - pretty_relation_id(pp, unwrapped_fields1519) + pretty_relation_id(pp, unwrapped_fields1523) dedent!(pp) write(pp, ")") end @@ -4616,22 +4620,22 @@ function pretty_demand(pp::PrettyPrinter, msg::Proto.Demand) end function pretty_output(pp::PrettyPrinter, msg::Proto.Output) - flat1525 = try_flat(pp, msg, pretty_output) - if !isnothing(flat1525) - write(pp, flat1525) + flat1529 = try_flat(pp, msg, pretty_output) + if !isnothing(flat1529) + write(pp, flat1529) return nothing else _dollar_dollar = msg - fields1521 = (_dollar_dollar.name, _dollar_dollar.relation_id,) - unwrapped_fields1522 = fields1521 + fields1525 = (_dollar_dollar.name, _dollar_dollar.relation_id,) + unwrapped_fields1526 = fields1525 write(pp, "(output") indent_sexp!(pp) newline(pp) - field1523 = unwrapped_fields1522[1] - pretty_name(pp, field1523) + field1527 = unwrapped_fields1526[1] + pretty_name(pp, field1527) newline(pp) - field1524 = unwrapped_fields1522[2] - pretty_relation_id(pp, field1524) + field1528 = unwrapped_fields1526[2] + pretty_relation_id(pp, field1528) dedent!(pp) write(pp, ")") end @@ -4639,22 +4643,22 @@ function pretty_output(pp::PrettyPrinter, msg::Proto.Output) end function pretty_what_if(pp::PrettyPrinter, msg::Proto.WhatIf) - flat1530 = try_flat(pp, msg, pretty_what_if) - if !isnothing(flat1530) - write(pp, flat1530) + flat1534 = try_flat(pp, msg, pretty_what_if) + if !isnothing(flat1534) + write(pp, flat1534) return nothing else _dollar_dollar = msg - fields1526 = (_dollar_dollar.branch, _dollar_dollar.epoch,) - unwrapped_fields1527 = fields1526 + fields1530 = (_dollar_dollar.branch, _dollar_dollar.epoch,) + unwrapped_fields1531 = fields1530 write(pp, "(what_if") indent_sexp!(pp) newline(pp) - field1528 = unwrapped_fields1527[1] - pretty_name(pp, field1528) + field1532 = unwrapped_fields1531[1] + pretty_name(pp, field1532) newline(pp) - field1529 = unwrapped_fields1527[2] - pretty_epoch(pp, field1529) + field1533 = unwrapped_fields1531[2] + pretty_epoch(pp, field1533) dedent!(pp) write(pp, ")") end @@ -4662,30 +4666,30 @@ function pretty_what_if(pp::PrettyPrinter, msg::Proto.WhatIf) end function pretty_abort(pp::PrettyPrinter, msg::Proto.Abort) - flat1536 = try_flat(pp, msg, pretty_abort) - if !isnothing(flat1536) - write(pp, flat1536) + flat1540 = try_flat(pp, msg, pretty_abort) + if !isnothing(flat1540) + write(pp, flat1540) return nothing else _dollar_dollar = msg if _dollar_dollar.name != "abort" - _t1764 = _dollar_dollar.name + _t1768 = _dollar_dollar.name else - _t1764 = nothing + _t1768 = nothing end - fields1531 = (_t1764, _dollar_dollar.relation_id,) - unwrapped_fields1532 = fields1531 + fields1535 = (_t1768, _dollar_dollar.relation_id,) + unwrapped_fields1536 = fields1535 write(pp, "(abort") indent_sexp!(pp) - field1533 = unwrapped_fields1532[1] - if !isnothing(field1533) + field1537 = unwrapped_fields1536[1] + if !isnothing(field1537) newline(pp) - opt_val1534 = field1533 - pretty_name(pp, opt_val1534) + opt_val1538 = field1537 + pretty_name(pp, opt_val1538) end newline(pp) - field1535 = unwrapped_fields1532[2] - pretty_relation_id(pp, field1535) + field1539 = unwrapped_fields1536[2] + pretty_relation_id(pp, field1539) dedent!(pp) write(pp, ")") end @@ -4693,40 +4697,40 @@ function pretty_abort(pp::PrettyPrinter, msg::Proto.Abort) end function pretty_export(pp::PrettyPrinter, msg::Proto.Export) - flat1541 = try_flat(pp, msg, pretty_export) - if !isnothing(flat1541) - write(pp, flat1541) + flat1545 = try_flat(pp, msg, pretty_export) + if !isnothing(flat1545) + write(pp, flat1545) return nothing else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("csv_config")) - _t1765 = _get_oneof_field(_dollar_dollar, :csv_config) + _t1769 = _get_oneof_field(_dollar_dollar, :csv_config) else - _t1765 = nothing + _t1769 = nothing end - deconstruct_result1539 = _t1765 - if !isnothing(deconstruct_result1539) - unwrapped1540 = deconstruct_result1539 + deconstruct_result1543 = _t1769 + if !isnothing(deconstruct_result1543) + unwrapped1544 = deconstruct_result1543 write(pp, "(export") indent_sexp!(pp) newline(pp) - pretty_export_csv_config(pp, unwrapped1540) + pretty_export_csv_config(pp, unwrapped1544) dedent!(pp) write(pp, ")") else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("iceberg_config")) - _t1766 = _get_oneof_field(_dollar_dollar, :iceberg_config) + _t1770 = _get_oneof_field(_dollar_dollar, :iceberg_config) else - _t1766 = nothing + _t1770 = nothing end - deconstruct_result1537 = _t1766 - if !isnothing(deconstruct_result1537) - unwrapped1538 = deconstruct_result1537 + deconstruct_result1541 = _t1770 + if !isnothing(deconstruct_result1541) + unwrapped1542 = deconstruct_result1541 write(pp, "(export_iceberg") indent_sexp!(pp) newline(pp) - pretty_export_iceberg_config(pp, unwrapped1538) + pretty_export_iceberg_config(pp, unwrapped1542) dedent!(pp) write(pp, ")") else @@ -4738,55 +4742,55 @@ function pretty_export(pp::PrettyPrinter, msg::Proto.Export) end function pretty_export_csv_config(pp::PrettyPrinter, msg::Proto.ExportCSVConfig) - flat1552 = try_flat(pp, msg, pretty_export_csv_config) - if !isnothing(flat1552) - write(pp, flat1552) + flat1556 = try_flat(pp, msg, pretty_export_csv_config) + if !isnothing(flat1556) + write(pp, flat1556) return nothing else _dollar_dollar = msg if length(_dollar_dollar.data_columns) == 0 - _t1767 = (_dollar_dollar.path, _dollar_dollar.csv_source, _dollar_dollar.csv_config,) + _t1771 = (_dollar_dollar.path, _dollar_dollar.csv_source, _dollar_dollar.csv_config,) else - _t1767 = nothing + _t1771 = nothing end - deconstruct_result1547 = _t1767 - if !isnothing(deconstruct_result1547) - unwrapped1548 = deconstruct_result1547 + deconstruct_result1551 = _t1771 + if !isnothing(deconstruct_result1551) + unwrapped1552 = deconstruct_result1551 write(pp, "(export_csv_config_v2") indent_sexp!(pp) newline(pp) - field1549 = unwrapped1548[1] - pretty_export_csv_path(pp, field1549) + field1553 = unwrapped1552[1] + pretty_export_csv_path(pp, field1553) newline(pp) - field1550 = unwrapped1548[2] - pretty_export_csv_source(pp, field1550) + field1554 = unwrapped1552[2] + pretty_export_csv_source(pp, field1554) newline(pp) - field1551 = unwrapped1548[3] - pretty_csv_config(pp, field1551) + field1555 = unwrapped1552[3] + pretty_csv_config(pp, field1555) dedent!(pp) write(pp, ")") else _dollar_dollar = msg if length(_dollar_dollar.data_columns) != 0 - _t1769 = deconstruct_export_csv_config(pp, _dollar_dollar) - _t1768 = (_dollar_dollar.path, _dollar_dollar.data_columns, _t1769,) + _t1773 = deconstruct_export_csv_config(pp, _dollar_dollar) + _t1772 = (_dollar_dollar.path, _dollar_dollar.data_columns, _t1773,) else - _t1768 = nothing + _t1772 = nothing end - deconstruct_result1542 = _t1768 - if !isnothing(deconstruct_result1542) - unwrapped1543 = deconstruct_result1542 + deconstruct_result1546 = _t1772 + if !isnothing(deconstruct_result1546) + unwrapped1547 = deconstruct_result1546 write(pp, "(export_csv_config") indent_sexp!(pp) newline(pp) - field1544 = unwrapped1543[1] - pretty_export_csv_path(pp, field1544) + field1548 = unwrapped1547[1] + pretty_export_csv_path(pp, field1548) newline(pp) - field1545 = unwrapped1543[2] - pretty_export_csv_columns_list(pp, field1545) + field1549 = unwrapped1547[2] + pretty_export_csv_columns_list(pp, field1549) newline(pp) - field1546 = unwrapped1543[3] - pretty_config_dict(pp, field1546) + field1550 = unwrapped1547[3] + pretty_config_dict(pp, field1550) dedent!(pp) write(pp, ")") else @@ -4798,16 +4802,16 @@ function pretty_export_csv_config(pp::PrettyPrinter, msg::Proto.ExportCSVConfig) end function pretty_export_csv_path(pp::PrettyPrinter, msg::String) - flat1554 = try_flat(pp, msg, pretty_export_csv_path) - if !isnothing(flat1554) - write(pp, flat1554) + flat1558 = try_flat(pp, msg, pretty_export_csv_path) + if !isnothing(flat1558) + write(pp, flat1558) return nothing else - fields1553 = msg + fields1557 = msg write(pp, "(path") indent_sexp!(pp) newline(pp) - write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, fields1553)) + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, fields1557)) dedent!(pp) write(pp, ")") end @@ -4815,30 +4819,30 @@ function pretty_export_csv_path(pp::PrettyPrinter, msg::String) end function pretty_export_csv_source(pp::PrettyPrinter, msg::Proto.ExportCSVSource) - flat1561 = try_flat(pp, msg, pretty_export_csv_source) - if !isnothing(flat1561) - write(pp, flat1561) + flat1565 = try_flat(pp, msg, pretty_export_csv_source) + if !isnothing(flat1565) + write(pp, flat1565) return nothing else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("gnf_columns")) - _t1770 = _get_oneof_field(_dollar_dollar, :gnf_columns).columns + _t1774 = _get_oneof_field(_dollar_dollar, :gnf_columns).columns else - _t1770 = nothing + _t1774 = nothing end - deconstruct_result1557 = _t1770 - if !isnothing(deconstruct_result1557) - unwrapped1558 = deconstruct_result1557 + deconstruct_result1561 = _t1774 + if !isnothing(deconstruct_result1561) + unwrapped1562 = deconstruct_result1561 write(pp, "(gnf_columns") indent_sexp!(pp) - if !isempty(unwrapped1558) + if !isempty(unwrapped1562) newline(pp) - for (i1771, elem1559) in enumerate(unwrapped1558) - i1560 = i1771 - 1 - if (i1560 > 0) + for (i1775, elem1563) in enumerate(unwrapped1562) + i1564 = i1775 - 1 + if (i1564 > 0) newline(pp) end - pretty_export_csv_column(pp, elem1559) + pretty_export_csv_column(pp, elem1563) end end dedent!(pp) @@ -4846,17 +4850,17 @@ function pretty_export_csv_source(pp::PrettyPrinter, msg::Proto.ExportCSVSource) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("table_def")) - _t1772 = _get_oneof_field(_dollar_dollar, :table_def) + _t1776 = _get_oneof_field(_dollar_dollar, :table_def) else - _t1772 = nothing + _t1776 = nothing end - deconstruct_result1555 = _t1772 - if !isnothing(deconstruct_result1555) - unwrapped1556 = deconstruct_result1555 + deconstruct_result1559 = _t1776 + if !isnothing(deconstruct_result1559) + unwrapped1560 = deconstruct_result1559 write(pp, "(table_def") indent_sexp!(pp) newline(pp) - pretty_relation_id(pp, unwrapped1556) + pretty_relation_id(pp, unwrapped1560) dedent!(pp) write(pp, ")") else @@ -4868,22 +4872,22 @@ function pretty_export_csv_source(pp::PrettyPrinter, msg::Proto.ExportCSVSource) end function pretty_export_csv_column(pp::PrettyPrinter, msg::Proto.ExportCSVColumn) - flat1566 = try_flat(pp, msg, pretty_export_csv_column) - if !isnothing(flat1566) - write(pp, flat1566) + flat1570 = try_flat(pp, msg, pretty_export_csv_column) + if !isnothing(flat1570) + write(pp, flat1570) return nothing else _dollar_dollar = msg - fields1562 = (_dollar_dollar.column_name, _dollar_dollar.column_data,) - unwrapped_fields1563 = fields1562 + fields1566 = (_dollar_dollar.column_name, _dollar_dollar.column_data,) + unwrapped_fields1567 = fields1566 write(pp, "(column") indent_sexp!(pp) newline(pp) - field1564 = unwrapped_fields1563[1] - write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, field1564)) + field1568 = unwrapped_fields1567[1] + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, field1568)) newline(pp) - field1565 = unwrapped_fields1563[2] - pretty_relation_id(pp, field1565) + field1569 = unwrapped_fields1567[2] + pretty_relation_id(pp, field1569) dedent!(pp) write(pp, ")") end @@ -4891,22 +4895,22 @@ function pretty_export_csv_column(pp::PrettyPrinter, msg::Proto.ExportCSVColumn) end function pretty_export_csv_columns_list(pp::PrettyPrinter, msg::Vector{Proto.ExportCSVColumn}) - flat1570 = try_flat(pp, msg, pretty_export_csv_columns_list) - if !isnothing(flat1570) - write(pp, flat1570) + flat1574 = try_flat(pp, msg, pretty_export_csv_columns_list) + if !isnothing(flat1574) + write(pp, flat1574) return nothing else - fields1567 = msg + fields1571 = msg write(pp, "(columns") indent_sexp!(pp) - if !isempty(fields1567) + if !isempty(fields1571) newline(pp) - for (i1773, elem1568) in enumerate(fields1567) - i1569 = i1773 - 1 - if (i1569 > 0) + for (i1777, elem1572) in enumerate(fields1571) + i1573 = i1777 - 1 + if (i1573 > 0) newline(pp) end - pretty_export_csv_column(pp, elem1568) + pretty_export_csv_column(pp, elem1572) end end dedent!(pp) @@ -4916,37 +4920,37 @@ function pretty_export_csv_columns_list(pp::PrettyPrinter, msg::Vector{Proto.Exp end function pretty_export_iceberg_config(pp::PrettyPrinter, msg::Proto.ExportIcebergConfig) - flat1580 = try_flat(pp, msg, pretty_export_iceberg_config) - if !isnothing(flat1580) - write(pp, flat1580) + flat1584 = try_flat(pp, msg, pretty_export_iceberg_config) + if !isnothing(flat1584) + write(pp, flat1584) return nothing else _dollar_dollar = msg - _t1774 = deconstruct_export_iceberg_config_optional(pp, _dollar_dollar) - fields1571 = (_dollar_dollar.locator, _dollar_dollar.config, _dollar_dollar.table_def, _dollar_dollar.columns, sort([(k, v) for (k, v) in _dollar_dollar.table_properties]), _t1774,) - unwrapped_fields1572 = fields1571 + _t1778 = deconstruct_export_iceberg_config_optional(pp, _dollar_dollar) + fields1575 = (_dollar_dollar.locator, _dollar_dollar.config, _dollar_dollar.table_def, _dollar_dollar.columns, sort([(k, v) for (k, v) in _dollar_dollar.table_properties]), _t1778,) + unwrapped_fields1576 = fields1575 write(pp, "(export_iceberg_config") indent_sexp!(pp) newline(pp) - field1573 = unwrapped_fields1572[1] - pretty_iceberg_locator(pp, field1573) + field1577 = unwrapped_fields1576[1] + pretty_iceberg_locator(pp, field1577) newline(pp) - field1574 = unwrapped_fields1572[2] - pretty_iceberg_catalog_config(pp, field1574) + field1578 = unwrapped_fields1576[2] + pretty_iceberg_catalog_config(pp, field1578) newline(pp) - field1575 = unwrapped_fields1572[3] - pretty_export_iceberg_table_def(pp, field1575) + field1579 = unwrapped_fields1576[3] + pretty_export_iceberg_table_def(pp, field1579) newline(pp) - field1576 = unwrapped_fields1572[4] - pretty_export_iceberg_columns(pp, field1576) + field1580 = unwrapped_fields1576[4] + pretty_export_iceberg_columns(pp, field1580) newline(pp) - field1577 = unwrapped_fields1572[5] - pretty_iceberg_table_properties(pp, field1577) - field1578 = unwrapped_fields1572[6] - if !isnothing(field1578) + field1581 = unwrapped_fields1576[5] + pretty_iceberg_table_properties(pp, field1581) + field1582 = unwrapped_fields1576[6] + if !isnothing(field1582) newline(pp) - opt_val1579 = field1578 - pretty_config_dict(pp, opt_val1579) + opt_val1583 = field1582 + pretty_config_dict(pp, opt_val1583) end dedent!(pp) write(pp, ")") @@ -4955,16 +4959,16 @@ function pretty_export_iceberg_config(pp::PrettyPrinter, msg::Proto.ExportIceber end function pretty_export_iceberg_table_def(pp::PrettyPrinter, msg::Proto.RelationId) - flat1582 = try_flat(pp, msg, pretty_export_iceberg_table_def) - if !isnothing(flat1582) - write(pp, flat1582) + flat1586 = try_flat(pp, msg, pretty_export_iceberg_table_def) + if !isnothing(flat1586) + write(pp, flat1586) return nothing else - fields1581 = msg + fields1585 = msg write(pp, "(table_def") indent_sexp!(pp) newline(pp) - pretty_relation_id(pp, fields1581) + pretty_relation_id(pp, fields1585) dedent!(pp) write(pp, ")") end @@ -4972,22 +4976,22 @@ function pretty_export_iceberg_table_def(pp::PrettyPrinter, msg::Proto.RelationI end function pretty_export_iceberg_columns(pp::PrettyPrinter, msg::Vector{Proto.ExportColumn}) - flat1586 = try_flat(pp, msg, pretty_export_iceberg_columns) - if !isnothing(flat1586) - write(pp, flat1586) + flat1590 = try_flat(pp, msg, pretty_export_iceberg_columns) + if !isnothing(flat1590) + write(pp, flat1590) return nothing else - fields1583 = msg + fields1587 = msg write(pp, "(columns") indent_sexp!(pp) - if !isempty(fields1583) + if !isempty(fields1587) newline(pp) - for (i1775, elem1584) in enumerate(fields1583) - i1585 = i1775 - 1 - if (i1585 > 0) + for (i1779, elem1588) in enumerate(fields1587) + i1589 = i1779 - 1 + if (i1589 > 0) newline(pp) end - pretty_export_iceberg_column(pp, elem1584) + pretty_export_iceberg_column(pp, elem1588) end end dedent!(pp) @@ -4997,22 +5001,22 @@ function pretty_export_iceberg_columns(pp::PrettyPrinter, msg::Vector{Proto.Expo end function pretty_export_iceberg_column(pp::PrettyPrinter, msg::Proto.ExportColumn) - flat1591 = try_flat(pp, msg, pretty_export_iceberg_column) - if !isnothing(flat1591) - write(pp, flat1591) + flat1595 = try_flat(pp, msg, pretty_export_iceberg_column) + if !isnothing(flat1595) + write(pp, flat1595) return nothing else _dollar_dollar = msg - fields1587 = (_dollar_dollar.name, _dollar_dollar.nullable,) - unwrapped_fields1588 = fields1587 + fields1591 = (_dollar_dollar.name, _dollar_dollar.nullable,) + unwrapped_fields1592 = fields1591 write(pp, "(column") indent_sexp!(pp) newline(pp) - field1589 = unwrapped_fields1588[1] - write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, field1589)) + field1593 = unwrapped_fields1592[1] + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, field1593)) newline(pp) - field1590 = unwrapped_fields1588[2] - pretty_boolean_value(pp, field1590) + field1594 = unwrapped_fields1592[2] + pretty_boolean_value(pp, field1594) dedent!(pp) write(pp, ")") end @@ -5020,22 +5024,22 @@ function pretty_export_iceberg_column(pp::PrettyPrinter, msg::Proto.ExportColumn end function pretty_iceberg_table_properties(pp::PrettyPrinter, msg::Vector{Tuple{String, String}}) - flat1595 = try_flat(pp, msg, pretty_iceberg_table_properties) - if !isnothing(flat1595) - write(pp, flat1595) + flat1599 = try_flat(pp, msg, pretty_iceberg_table_properties) + if !isnothing(flat1599) + write(pp, flat1599) return nothing else - fields1592 = msg + fields1596 = msg write(pp, "(table_properties") indent_sexp!(pp) - if !isempty(fields1592) + if !isempty(fields1596) newline(pp) - for (i1776, elem1593) in enumerate(fields1592) - i1594 = i1776 - 1 - if (i1594 > 0) + for (i1780, elem1597) in enumerate(fields1596) + i1598 = i1780 - 1 + if (i1598 > 0) newline(pp) end - pretty_iceberg_property_entry(pp, elem1593) + pretty_iceberg_property_entry(pp, elem1597) end end dedent!(pp) @@ -5050,12 +5054,12 @@ end function pretty_debug_info(pp::PrettyPrinter, msg::Proto.DebugInfo) write(pp, "(debug_info") indent_sexp!(pp) - for (i1822, _rid) in enumerate(msg.ids) - _idx = i1822 - 1 + for (i1826, _rid) in enumerate(msg.ids) + _idx = i1826 - 1 newline(pp) write(pp, "(") - _t1823 = Proto.UInt128Value(low=_rid.id_low, high=_rid.id_high) - _pprint_dispatch(pp, _t1823) + _t1827 = Proto.UInt128Value(low=_rid.id_low, high=_rid.id_high) + _pprint_dispatch(pp, _t1827) write(pp, " ") write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, msg.orig_names[_idx + 1])) write(pp, ")") @@ -5127,8 +5131,8 @@ function pretty_functional_dependency(pp::PrettyPrinter, msg::Proto.FunctionalDe _pprint_dispatch(pp, msg.guard) newline(pp) write(pp, ":keys (") - for (i1824, _elem) in enumerate(msg.keys) - _idx = i1824 - 1 + for (i1828, _elem) in enumerate(msg.keys) + _idx = i1828 - 1 if (_idx > 0) write(pp, " ") end @@ -5137,8 +5141,8 @@ function pretty_functional_dependency(pp::PrettyPrinter, msg::Proto.FunctionalDe write(pp, ")") newline(pp) write(pp, ":values (") - for (i1825, _elem) in enumerate(msg.values) - _idx = i1825 - 1 + for (i1829, _elem) in enumerate(msg.values) + _idx = i1829 - 1 if (_idx > 0) write(pp, " ") end @@ -5169,8 +5173,8 @@ function pretty_export_csv_columns(pp::PrettyPrinter, msg::Proto.ExportCSVColumn indent_sexp!(pp) newline(pp) write(pp, ":columns (") - for (i1826, _elem) in enumerate(msg.columns) - _idx = i1826 - 1 + for (i1830, _elem) in enumerate(msg.columns) + _idx = i1830 - 1 if (_idx > 0) write(pp, " ") end diff --git a/sdks/julia/LogicalQueryProtocol.jl/test/equality_tests.jl b/sdks/julia/LogicalQueryProtocol.jl/test/equality_tests.jl index 4f375001..188724c7 100644 --- a/sdks/julia/LogicalQueryProtocol.jl/test/equality_tests.jl +++ b/sdks/julia/LogicalQueryProtocol.jl/test/equality_tests.jl @@ -1413,13 +1413,13 @@ end m1 = SnapshotMapping(destination_path=["my_edb"], source_relation=r1) m2 = SnapshotMapping(destination_path=["other_edb"], source_relation=r3) - s1 = Snapshot(mappings=[m1, m2]) - s2 = Snapshot(mappings=[ + s1 = Snapshot(prefix=["db"], mappings=[m1, m2]) + s2 = Snapshot(prefix=["db"], mappings=[ SnapshotMapping(destination_path=["my_edb"], source_relation=r2), SnapshotMapping(destination_path=["other_edb"], source_relation=r3), ]) - s3 = Snapshot(mappings=[m1]) - s4 = Snapshot(mappings=[m1, m2]) + s3 = Snapshot(prefix=["db"], mappings=[m1]) + s4 = Snapshot(prefix=["db"], mappings=[m1, m2]) # Equality and inequality @test s1 == s2 @@ -1438,6 +1438,12 @@ end # Transitivity @test s1 == s2 && s2 == s4 && s1 == s4 + + # Different prefix + s5 = Snapshot(prefix=["other"], mappings=[m1, m2]) + @test s1 != s5 + s6 = Snapshot(prefix=[], mappings=[m1, m2]) + @test s1 != s6 end @testitem "Equality for Configure" tags=[:ring1, :unit] begin diff --git a/sdks/python/src/lqp/gen/parser.py b/sdks/python/src/lqp/gen/parser.py index 9d349668..2c36fdd2 100644 --- a/sdks/python/src/lqp/gen/parser.py +++ b/sdks/python/src/lqp/gen/parser.py @@ -424,179 +424,179 @@ 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 - _t2092 = value.HasField("int32_value") + _t2095 = value.HasField("int32_value") else: - _t2092 = False - if _t2092: + _t2095 = False + if _t2095: assert value is not None return value.int32_value else: - _t2093 = None + _t2096 = 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 - _t2094 = value.HasField("int_value") + _t2097 = value.HasField("int_value") else: - _t2094 = False - if _t2094: + _t2097 = False + if _t2097: assert value is not None return value.int_value else: - _t2095 = None + _t2098 = 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 - _t2096 = value.HasField("string_value") + _t2099 = value.HasField("string_value") else: - _t2096 = False - if _t2096: + _t2099 = False + if _t2099: assert value is not None return value.string_value else: - _t2097 = None + _t2100 = 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 - _t2098 = value.HasField("boolean_value") + _t2101 = value.HasField("boolean_value") else: - _t2098 = False - if _t2098: + _t2101 = False + if _t2101: assert value is not None return value.boolean_value else: - _t2099 = None + _t2102 = 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 - _t2100 = value.HasField("string_value") + _t2103 = value.HasField("string_value") else: - _t2100 = False - if _t2100: + _t2103 = False + if _t2103: assert value is not None return [value.string_value] else: - _t2101 = None + _t2104 = 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 - _t2102 = value.HasField("int_value") + _t2105 = value.HasField("int_value") else: - _t2102 = False - if _t2102: + _t2105 = False + if _t2105: assert value is not None return value.int_value else: - _t2103 = None + _t2106 = 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 - _t2104 = value.HasField("float_value") + _t2107 = value.HasField("float_value") else: - _t2104 = False - if _t2104: + _t2107 = False + if _t2107: assert value is not None return value.float_value else: - _t2105 = None + _t2108 = 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 - _t2106 = value.HasField("string_value") + _t2109 = value.HasField("string_value") else: - _t2106 = False - if _t2106: + _t2109 = False + if _t2109: assert value is not None return value.string_value.encode() else: - _t2107 = None + _t2110 = 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 - _t2108 = value.HasField("uint128_value") + _t2111 = value.HasField("uint128_value") else: - _t2108 = False - if _t2108: + _t2111 = False + if _t2111: assert value is not None return value.uint128_value else: - _t2109 = None + _t2112 = None return None def construct_csv_config(self, config_dict: Sequence[tuple[str, logic_pb2.Value]]) -> logic_pb2.CSVConfig: config = dict(config_dict) - _t2110 = self._extract_value_int32(config.get("csv_header_row"), 1) - header_row = _t2110 - _t2111 = self._extract_value_int64(config.get("csv_skip"), 0) - skip = _t2111 - _t2112 = self._extract_value_string(config.get("csv_new_line"), "") - new_line = _t2112 - _t2113 = self._extract_value_string(config.get("csv_delimiter"), ",") - delimiter = _t2113 - _t2114 = self._extract_value_string(config.get("csv_quotechar"), '"') - quotechar = _t2114 - _t2115 = self._extract_value_string(config.get("csv_escapechar"), '"') - escapechar = _t2115 - _t2116 = self._extract_value_string(config.get("csv_comment"), "") - comment = _t2116 - _t2117 = self._extract_value_string_list(config.get("csv_missing_strings"), []) - missing_strings = _t2117 - _t2118 = self._extract_value_string(config.get("csv_decimal_separator"), ".") - decimal_separator = _t2118 - _t2119 = self._extract_value_string(config.get("csv_encoding"), "utf-8") - encoding = _t2119 - _t2120 = self._extract_value_string(config.get("csv_compression"), "auto") - compression = _t2120 - _t2121 = self._extract_value_int64(config.get("csv_partition_size_mb"), 0) - partition_size_mb = _t2121 - _t2122 = 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) - return _t2122 + _t2113 = self._extract_value_int32(config.get("csv_header_row"), 1) + header_row = _t2113 + _t2114 = self._extract_value_int64(config.get("csv_skip"), 0) + skip = _t2114 + _t2115 = self._extract_value_string(config.get("csv_new_line"), "") + new_line = _t2115 + _t2116 = self._extract_value_string(config.get("csv_delimiter"), ",") + delimiter = _t2116 + _t2117 = self._extract_value_string(config.get("csv_quotechar"), '"') + quotechar = _t2117 + _t2118 = self._extract_value_string(config.get("csv_escapechar"), '"') + escapechar = _t2118 + _t2119 = self._extract_value_string(config.get("csv_comment"), "") + comment = _t2119 + _t2120 = self._extract_value_string_list(config.get("csv_missing_strings"), []) + missing_strings = _t2120 + _t2121 = self._extract_value_string(config.get("csv_decimal_separator"), ".") + decimal_separator = _t2121 + _t2122 = self._extract_value_string(config.get("csv_encoding"), "utf-8") + encoding = _t2122 + _t2123 = self._extract_value_string(config.get("csv_compression"), "auto") + compression = _t2123 + _t2124 = self._extract_value_int64(config.get("csv_partition_size_mb"), 0) + partition_size_mb = _t2124 + _t2125 = 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) + return _t2125 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) - _t2123 = self._try_extract_value_float64(config.get("betree_config_epsilon")) - epsilon = _t2123 - _t2124 = self._try_extract_value_int64(config.get("betree_config_max_pivots")) - max_pivots = _t2124 - _t2125 = self._try_extract_value_int64(config.get("betree_config_max_deltas")) - max_deltas = _t2125 - _t2126 = self._try_extract_value_int64(config.get("betree_config_max_leaf")) - max_leaf = _t2126 - _t2127 = logic_pb2.BeTreeConfig(epsilon=epsilon, max_pivots=max_pivots, max_deltas=max_deltas, max_leaf=max_leaf) - storage_config = _t2127 - _t2128 = self._try_extract_value_uint128(config.get("betree_locator_root_pageid")) - root_pageid = _t2128 - _t2129 = self._try_extract_value_bytes(config.get("betree_locator_inline_data")) - inline_data = _t2129 - _t2130 = self._try_extract_value_int64(config.get("betree_locator_element_count")) - element_count = _t2130 - _t2131 = self._try_extract_value_int64(config.get("betree_locator_tree_height")) - tree_height = _t2131 - _t2132 = logic_pb2.BeTreeLocator(root_pageid=root_pageid, inline_data=inline_data, element_count=element_count, tree_height=tree_height) - relation_locator = _t2132 - _t2133 = logic_pb2.BeTreeInfo(key_types=key_types, value_types=value_types, storage_config=storage_config, relation_locator=relation_locator) - return _t2133 + _t2126 = self._try_extract_value_float64(config.get("betree_config_epsilon")) + epsilon = _t2126 + _t2127 = self._try_extract_value_int64(config.get("betree_config_max_pivots")) + max_pivots = _t2127 + _t2128 = self._try_extract_value_int64(config.get("betree_config_max_deltas")) + max_deltas = _t2128 + _t2129 = self._try_extract_value_int64(config.get("betree_config_max_leaf")) + max_leaf = _t2129 + _t2130 = logic_pb2.BeTreeConfig(epsilon=epsilon, max_pivots=max_pivots, max_deltas=max_deltas, max_leaf=max_leaf) + storage_config = _t2130 + _t2131 = self._try_extract_value_uint128(config.get("betree_locator_root_pageid")) + root_pageid = _t2131 + _t2132 = self._try_extract_value_bytes(config.get("betree_locator_inline_data")) + inline_data = _t2132 + _t2133 = self._try_extract_value_int64(config.get("betree_locator_element_count")) + element_count = _t2133 + _t2134 = self._try_extract_value_int64(config.get("betree_locator_tree_height")) + tree_height = _t2134 + _t2135 = logic_pb2.BeTreeLocator(root_pageid=root_pageid, inline_data=inline_data, element_count=element_count, tree_height=tree_height) + relation_locator = _t2135 + _t2136 = logic_pb2.BeTreeInfo(key_types=key_types, value_types=value_types, storage_config=storage_config, relation_locator=relation_locator) + return _t2136 def default_configure(self) -> transactions_pb2.Configure: - _t2134 = transactions_pb2.IVMConfig(level=transactions_pb2.MaintenanceLevel.MAINTENANCE_LEVEL_OFF) - ivm_config = _t2134 - _t2135 = transactions_pb2.Configure(semantics_version=0, ivm_config=ivm_config) - return _t2135 + _t2137 = transactions_pb2.IVMConfig(level=transactions_pb2.MaintenanceLevel.MAINTENANCE_LEVEL_OFF) + ivm_config = _t2137 + _t2138 = transactions_pb2.Configure(semantics_version=0, ivm_config=ivm_config) + return _t2138 def construct_configure(self, config_dict: Sequence[tuple[str, logic_pb2.Value]]) -> transactions_pb2.Configure: config = dict(config_dict) @@ -613,3377 +613,3379 @@ 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 - _t2136 = transactions_pb2.IVMConfig(level=maintenance_level) - ivm_config = _t2136 - _t2137 = self._extract_value_int64(config.get("semantics_version"), 0) - semantics_version = _t2137 - _t2138 = transactions_pb2.Configure(semantics_version=semantics_version, ivm_config=ivm_config) - return _t2138 + _t2139 = transactions_pb2.IVMConfig(level=maintenance_level) + ivm_config = _t2139 + _t2140 = self._extract_value_int64(config.get("semantics_version"), 0) + semantics_version = _t2140 + _t2141 = transactions_pb2.Configure(semantics_version=semantics_version, ivm_config=ivm_config) + return _t2141 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) - _t2139 = self._extract_value_int64(config.get("partition_size"), 0) - partition_size = _t2139 - _t2140 = self._extract_value_string(config.get("compression"), "") - compression = _t2140 - _t2141 = self._extract_value_boolean(config.get("syntax_header_row"), True) - syntax_header_row = _t2141 - _t2142 = self._extract_value_string(config.get("syntax_missing_string"), "") - syntax_missing_string = _t2142 - _t2143 = self._extract_value_string(config.get("syntax_delim"), ",") - syntax_delim = _t2143 - _t2144 = self._extract_value_string(config.get("syntax_quotechar"), '"') - syntax_quotechar = _t2144 - _t2145 = self._extract_value_string(config.get("syntax_escapechar"), "\\") - syntax_escapechar = _t2145 - _t2146 = 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 _t2146 + _t2142 = self._extract_value_int64(config.get("partition_size"), 0) + partition_size = _t2142 + _t2143 = self._extract_value_string(config.get("compression"), "") + compression = _t2143 + _t2144 = self._extract_value_boolean(config.get("syntax_header_row"), True) + syntax_header_row = _t2144 + _t2145 = self._extract_value_string(config.get("syntax_missing_string"), "") + syntax_missing_string = _t2145 + _t2146 = self._extract_value_string(config.get("syntax_delim"), ",") + syntax_delim = _t2146 + _t2147 = self._extract_value_string(config.get("syntax_quotechar"), '"') + syntax_quotechar = _t2147 + _t2148 = self._extract_value_string(config.get("syntax_escapechar"), "\\") + syntax_escapechar = _t2148 + _t2149 = 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 _t2149 def construct_export_csv_config_with_source(self, path: str, csv_source: transactions_pb2.ExportCSVSource, csv_config: logic_pb2.CSVConfig) -> transactions_pb2.ExportCSVConfig: - _t2147 = transactions_pb2.ExportCSVConfig(path=path, csv_source=csv_source, csv_config=csv_config) - return _t2147 + _t2150 = transactions_pb2.ExportCSVConfig(path=path, csv_source=csv_source, csv_config=csv_config) + return _t2150 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) - _t2148 = logic_pb2.IcebergCatalogConfig(catalog_uri=catalog_uri, scope=(scope_opt if scope_opt is not None else ""), properties=props, auth_properties=auth_props) - return _t2148 + _t2151 = logic_pb2.IcebergCatalogConfig(catalog_uri=catalog_uri, scope=(scope_opt if scope_opt is not None else ""), properties=props, auth_properties=auth_props) + return _t2151 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: - _t2149 = 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 _t2149 + _t2152 = 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 _t2152 def construct_export_iceberg_config_full(self, locator: logic_pb2.IcebergLocator, config: logic_pb2.IcebergCatalogConfig, table_def: logic_pb2.RelationId, columns: Sequence[transactions_pb2.ExportColumn], 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 [])) - _t2150 = self._extract_value_string(cfg.get("prefix"), "") - prefix = _t2150 - _t2151 = self._extract_value_int64(cfg.get("target_file_size_bytes"), 0) - target_file_size_bytes = _t2151 - _t2152 = self._extract_value_string(cfg.get("compression"), "") - compression = _t2152 + _t2153 = self._extract_value_string(cfg.get("prefix"), "") + prefix = _t2153 + _t2154 = self._extract_value_int64(cfg.get("target_file_size_bytes"), 0) + target_file_size_bytes = _t2154 + _t2155 = self._extract_value_string(cfg.get("compression"), "") + compression = _t2155 table_props = dict(table_property_pairs) - _t2153 = transactions_pb2.ExportIcebergConfig(locator=locator, config=config, table_def=table_def, columns=columns, prefix=prefix, target_file_size_bytes=target_file_size_bytes, compression=compression, table_properties=table_props) - return _t2153 + _t2156 = transactions_pb2.ExportIcebergConfig(locator=locator, config=config, table_def=table_def, columns=columns, prefix=prefix, target_file_size_bytes=target_file_size_bytes, compression=compression, table_properties=table_props) + return _t2156 # --- Parse methods --- def parse_transaction(self) -> transactions_pb2.Transaction: - span_start677 = self.span_start() + span_start678 = self.span_start() self.consume_literal("(") self.consume_literal("transaction") if (self.match_lookahead_literal("(", 0) and self.match_lookahead_literal("configure", 1)): - _t1343 = self.parse_configure() - _t1342 = _t1343 - else: - _t1342 = None - configure671 = _t1342 - if (self.match_lookahead_literal("(", 0) and self.match_lookahead_literal("sync", 1)): - _t1345 = self.parse_sync() + _t1345 = self.parse_configure() _t1344 = _t1345 else: _t1344 = None - sync672 = _t1344 - xs673 = [] - cond674 = self.match_lookahead_literal("(", 0) - while cond674: - _t1346 = self.parse_epoch() - item675 = _t1346 - xs673.append(item675) - cond674 = self.match_lookahead_literal("(", 0) - epochs676 = xs673 - self.consume_literal(")") - _t1347 = self.default_configure() - _t1348 = transactions_pb2.Transaction(epochs=epochs676, configure=(configure671 if configure671 is not None else _t1347), sync=sync672) - result678 = _t1348 - self.record_span(span_start677, "Transaction") - return result678 + configure672 = _t1344 + if (self.match_lookahead_literal("(", 0) and self.match_lookahead_literal("sync", 1)): + _t1347 = self.parse_sync() + _t1346 = _t1347 + else: + _t1346 = None + sync673 = _t1346 + xs674 = [] + cond675 = self.match_lookahead_literal("(", 0) + while cond675: + _t1348 = self.parse_epoch() + item676 = _t1348 + xs674.append(item676) + cond675 = self.match_lookahead_literal("(", 0) + epochs677 = xs674 + self.consume_literal(")") + _t1349 = self.default_configure() + _t1350 = transactions_pb2.Transaction(epochs=epochs677, configure=(configure672 if configure672 is not None else _t1349), sync=sync673) + result679 = _t1350 + self.record_span(span_start678, "Transaction") + return result679 def parse_configure(self) -> transactions_pb2.Configure: - span_start680 = self.span_start() + span_start681 = self.span_start() self.consume_literal("(") self.consume_literal("configure") - _t1349 = self.parse_config_dict() - config_dict679 = _t1349 + _t1351 = self.parse_config_dict() + config_dict680 = _t1351 self.consume_literal(")") - _t1350 = self.construct_configure(config_dict679) - result681 = _t1350 - self.record_span(span_start680, "Configure") - return result681 + _t1352 = self.construct_configure(config_dict680) + result682 = _t1352 + self.record_span(span_start681, "Configure") + return result682 def parse_config_dict(self) -> Sequence[tuple[str, logic_pb2.Value]]: self.consume_literal("{") - xs682 = [] - cond683 = self.match_lookahead_literal(":", 0) - while cond683: - _t1351 = self.parse_config_key_value() - item684 = _t1351 - xs682.append(item684) - cond683 = self.match_lookahead_literal(":", 0) - config_key_values685 = xs682 + xs683 = [] + cond684 = self.match_lookahead_literal(":", 0) + while cond684: + _t1353 = self.parse_config_key_value() + item685 = _t1353 + xs683.append(item685) + cond684 = self.match_lookahead_literal(":", 0) + config_key_values686 = xs683 self.consume_literal("}") - return config_key_values685 + return config_key_values686 def parse_config_key_value(self) -> tuple[str, logic_pb2.Value]: self.consume_literal(":") - symbol686 = self.consume_terminal("SYMBOL") - _t1352 = self.parse_raw_value() - raw_value687 = _t1352 - return (symbol686, raw_value687,) + symbol687 = self.consume_terminal("SYMBOL") + _t1354 = self.parse_raw_value() + raw_value688 = _t1354 + return (symbol687, raw_value688,) def parse_raw_value(self) -> logic_pb2.Value: - span_start701 = self.span_start() + span_start702 = self.span_start() if self.match_lookahead_literal("true", 0): - _t1353 = 12 + _t1355 = 12 else: if self.match_lookahead_literal("missing", 0): - _t1354 = 11 + _t1356 = 11 else: if self.match_lookahead_literal("false", 0): - _t1355 = 12 + _t1357 = 12 else: if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("datetime", 1): - _t1357 = 1 + _t1359 = 1 else: if self.match_lookahead_literal("date", 1): - _t1358 = 0 + _t1360 = 0 else: - _t1358 = -1 - _t1357 = _t1358 - _t1356 = _t1357 + _t1360 = -1 + _t1359 = _t1360 + _t1358 = _t1359 else: if self.match_lookahead_terminal("UINT32", 0): - _t1359 = 7 + _t1361 = 7 else: if self.match_lookahead_terminal("UINT128", 0): - _t1360 = 8 + _t1362 = 8 else: if self.match_lookahead_terminal("STRING", 0): - _t1361 = 2 + _t1363 = 2 else: if self.match_lookahead_terminal("INT32", 0): - _t1362 = 3 + _t1364 = 3 else: if self.match_lookahead_terminal("INT128", 0): - _t1363 = 9 + _t1365 = 9 else: if self.match_lookahead_terminal("INT", 0): - _t1364 = 4 + _t1366 = 4 else: if self.match_lookahead_terminal("FLOAT32", 0): - _t1365 = 5 + _t1367 = 5 else: if self.match_lookahead_terminal("FLOAT", 0): - _t1366 = 6 + _t1368 = 6 else: if self.match_lookahead_terminal("DECIMAL", 0): - _t1367 = 10 + _t1369 = 10 else: - _t1367 = -1 - _t1366 = _t1367 - _t1365 = _t1366 - _t1364 = _t1365 - _t1363 = _t1364 - _t1362 = _t1363 - _t1361 = _t1362 - _t1360 = _t1361 - _t1359 = _t1360 - _t1356 = _t1359 - _t1355 = _t1356 - _t1354 = _t1355 - _t1353 = _t1354 - prediction688 = _t1353 - if prediction688 == 12: - _t1369 = self.parse_boolean_value() - boolean_value700 = _t1369 - _t1370 = logic_pb2.Value(boolean_value=boolean_value700) - _t1368 = _t1370 - else: - if prediction688 == 11: + _t1369 = -1 + _t1368 = _t1369 + _t1367 = _t1368 + _t1366 = _t1367 + _t1365 = _t1366 + _t1364 = _t1365 + _t1363 = _t1364 + _t1362 = _t1363 + _t1361 = _t1362 + _t1358 = _t1361 + _t1357 = _t1358 + _t1356 = _t1357 + _t1355 = _t1356 + prediction689 = _t1355 + if prediction689 == 12: + _t1371 = self.parse_boolean_value() + boolean_value701 = _t1371 + _t1372 = logic_pb2.Value(boolean_value=boolean_value701) + _t1370 = _t1372 + else: + if prediction689 == 11: self.consume_literal("missing") - _t1372 = logic_pb2.MissingValue() - _t1373 = logic_pb2.Value(missing_value=_t1372) - _t1371 = _t1373 + _t1374 = logic_pb2.MissingValue() + _t1375 = logic_pb2.Value(missing_value=_t1374) + _t1373 = _t1375 else: - if prediction688 == 10: - decimal699 = self.consume_terminal("DECIMAL") - _t1375 = logic_pb2.Value(decimal_value=decimal699) - _t1374 = _t1375 + if prediction689 == 10: + decimal700 = self.consume_terminal("DECIMAL") + _t1377 = logic_pb2.Value(decimal_value=decimal700) + _t1376 = _t1377 else: - if prediction688 == 9: - int128698 = self.consume_terminal("INT128") - _t1377 = logic_pb2.Value(int128_value=int128698) - _t1376 = _t1377 + if prediction689 == 9: + int128699 = self.consume_terminal("INT128") + _t1379 = logic_pb2.Value(int128_value=int128699) + _t1378 = _t1379 else: - if prediction688 == 8: - uint128697 = self.consume_terminal("UINT128") - _t1379 = logic_pb2.Value(uint128_value=uint128697) - _t1378 = _t1379 + if prediction689 == 8: + uint128698 = self.consume_terminal("UINT128") + _t1381 = logic_pb2.Value(uint128_value=uint128698) + _t1380 = _t1381 else: - if prediction688 == 7: - uint32696 = self.consume_terminal("UINT32") - _t1381 = logic_pb2.Value(uint32_value=uint32696) - _t1380 = _t1381 + if prediction689 == 7: + uint32697 = self.consume_terminal("UINT32") + _t1383 = logic_pb2.Value(uint32_value=uint32697) + _t1382 = _t1383 else: - if prediction688 == 6: - float695 = self.consume_terminal("FLOAT") - _t1383 = logic_pb2.Value(float_value=float695) - _t1382 = _t1383 + if prediction689 == 6: + float696 = self.consume_terminal("FLOAT") + _t1385 = logic_pb2.Value(float_value=float696) + _t1384 = _t1385 else: - if prediction688 == 5: - float32694 = self.consume_terminal("FLOAT32") - _t1385 = logic_pb2.Value(float32_value=float32694) - _t1384 = _t1385 + if prediction689 == 5: + float32695 = self.consume_terminal("FLOAT32") + _t1387 = logic_pb2.Value(float32_value=float32695) + _t1386 = _t1387 else: - if prediction688 == 4: - int693 = self.consume_terminal("INT") - _t1387 = logic_pb2.Value(int_value=int693) - _t1386 = _t1387 + if prediction689 == 4: + int694 = self.consume_terminal("INT") + _t1389 = logic_pb2.Value(int_value=int694) + _t1388 = _t1389 else: - if prediction688 == 3: - int32692 = self.consume_terminal("INT32") - _t1389 = logic_pb2.Value(int32_value=int32692) - _t1388 = _t1389 + if prediction689 == 3: + int32693 = self.consume_terminal("INT32") + _t1391 = logic_pb2.Value(int32_value=int32693) + _t1390 = _t1391 else: - if prediction688 == 2: - string691 = self.consume_terminal("STRING") - _t1391 = logic_pb2.Value(string_value=string691) - _t1390 = _t1391 + if prediction689 == 2: + string692 = self.consume_terminal("STRING") + _t1393 = logic_pb2.Value(string_value=string692) + _t1392 = _t1393 else: - if prediction688 == 1: - _t1393 = self.parse_raw_datetime() - raw_datetime690 = _t1393 - _t1394 = logic_pb2.Value(datetime_value=raw_datetime690) - _t1392 = _t1394 + if prediction689 == 1: + _t1395 = self.parse_raw_datetime() + raw_datetime691 = _t1395 + _t1396 = logic_pb2.Value(datetime_value=raw_datetime691) + _t1394 = _t1396 else: - if prediction688 == 0: - _t1396 = self.parse_raw_date() - raw_date689 = _t1396 - _t1397 = logic_pb2.Value(date_value=raw_date689) - _t1395 = _t1397 + if prediction689 == 0: + _t1398 = self.parse_raw_date() + raw_date690 = _t1398 + _t1399 = logic_pb2.Value(date_value=raw_date690) + _t1397 = _t1399 else: raise ParseError("Unexpected token in raw_value" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1392 = _t1395 - _t1390 = _t1392 - _t1388 = _t1390 - _t1386 = _t1388 - _t1384 = _t1386 - _t1382 = _t1384 - _t1380 = _t1382 - _t1378 = _t1380 - _t1376 = _t1378 - _t1374 = _t1376 - _t1371 = _t1374 - _t1368 = _t1371 - result702 = _t1368 - self.record_span(span_start701, "Value") - return result702 + _t1394 = _t1397 + _t1392 = _t1394 + _t1390 = _t1392 + _t1388 = _t1390 + _t1386 = _t1388 + _t1384 = _t1386 + _t1382 = _t1384 + _t1380 = _t1382 + _t1378 = _t1380 + _t1376 = _t1378 + _t1373 = _t1376 + _t1370 = _t1373 + result703 = _t1370 + self.record_span(span_start702, "Value") + return result703 def parse_raw_date(self) -> logic_pb2.DateValue: - span_start706 = self.span_start() + span_start707 = self.span_start() self.consume_literal("(") self.consume_literal("date") - int703 = self.consume_terminal("INT") - int_3704 = self.consume_terminal("INT") - int_4705 = self.consume_terminal("INT") + int704 = self.consume_terminal("INT") + int_3705 = self.consume_terminal("INT") + int_4706 = self.consume_terminal("INT") self.consume_literal(")") - _t1398 = logic_pb2.DateValue(year=int(int703), month=int(int_3704), day=int(int_4705)) - result707 = _t1398 - self.record_span(span_start706, "DateValue") - return result707 + _t1400 = logic_pb2.DateValue(year=int(int704), month=int(int_3705), day=int(int_4706)) + result708 = _t1400 + self.record_span(span_start707, "DateValue") + return result708 def parse_raw_datetime(self) -> logic_pb2.DateTimeValue: - span_start715 = self.span_start() + span_start716 = self.span_start() self.consume_literal("(") self.consume_literal("datetime") - int708 = self.consume_terminal("INT") - int_3709 = self.consume_terminal("INT") - int_4710 = self.consume_terminal("INT") - int_5711 = self.consume_terminal("INT") - int_6712 = self.consume_terminal("INT") - int_7713 = self.consume_terminal("INT") + int709 = self.consume_terminal("INT") + int_3710 = self.consume_terminal("INT") + int_4711 = self.consume_terminal("INT") + int_5712 = self.consume_terminal("INT") + int_6713 = self.consume_terminal("INT") + int_7714 = self.consume_terminal("INT") if self.match_lookahead_terminal("INT", 0): - _t1399 = self.consume_terminal("INT") + _t1401 = self.consume_terminal("INT") else: - _t1399 = None - int_8714 = _t1399 + _t1401 = None + int_8715 = _t1401 self.consume_literal(")") - _t1400 = logic_pb2.DateTimeValue(year=int(int708), month=int(int_3709), day=int(int_4710), hour=int(int_5711), minute=int(int_6712), second=int(int_7713), microsecond=int((int_8714 if int_8714 is not None else 0))) - result716 = _t1400 - self.record_span(span_start715, "DateTimeValue") - return result716 + _t1402 = logic_pb2.DateTimeValue(year=int(int709), month=int(int_3710), day=int(int_4711), hour=int(int_5712), minute=int(int_6713), second=int(int_7714), microsecond=int((int_8715 if int_8715 is not None else 0))) + result717 = _t1402 + self.record_span(span_start716, "DateTimeValue") + return result717 def parse_boolean_value(self) -> bool: if self.match_lookahead_literal("true", 0): - _t1401 = 0 + _t1403 = 0 else: if self.match_lookahead_literal("false", 0): - _t1402 = 1 + _t1404 = 1 else: - _t1402 = -1 - _t1401 = _t1402 - prediction717 = _t1401 - if prediction717 == 1: + _t1404 = -1 + _t1403 = _t1404 + prediction718 = _t1403 + if prediction718 == 1: self.consume_literal("false") - _t1403 = False + _t1405 = False else: - if prediction717 == 0: + if prediction718 == 0: self.consume_literal("true") - _t1404 = True + _t1406 = True else: raise ParseError("Unexpected token in boolean_value" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1403 = _t1404 - return _t1403 + _t1405 = _t1406 + return _t1405 def parse_sync(self) -> transactions_pb2.Sync: - span_start722 = self.span_start() + span_start723 = self.span_start() self.consume_literal("(") self.consume_literal("sync") - xs718 = [] - cond719 = self.match_lookahead_literal(":", 0) - while cond719: - _t1405 = self.parse_fragment_id() - item720 = _t1405 - xs718.append(item720) - cond719 = self.match_lookahead_literal(":", 0) - fragment_ids721 = xs718 - self.consume_literal(")") - _t1406 = transactions_pb2.Sync(fragments=fragment_ids721) - result723 = _t1406 - self.record_span(span_start722, "Sync") - return result723 + xs719 = [] + cond720 = self.match_lookahead_literal(":", 0) + while cond720: + _t1407 = self.parse_fragment_id() + item721 = _t1407 + xs719.append(item721) + cond720 = self.match_lookahead_literal(":", 0) + fragment_ids722 = xs719 + self.consume_literal(")") + _t1408 = transactions_pb2.Sync(fragments=fragment_ids722) + result724 = _t1408 + self.record_span(span_start723, "Sync") + return result724 def parse_fragment_id(self) -> fragments_pb2.FragmentId: - span_start725 = self.span_start() + span_start726 = self.span_start() self.consume_literal(":") - symbol724 = self.consume_terminal("SYMBOL") - result726 = fragments_pb2.FragmentId(id=symbol724.encode()) - self.record_span(span_start725, "FragmentId") - return result726 + symbol725 = self.consume_terminal("SYMBOL") + result727 = fragments_pb2.FragmentId(id=symbol725.encode()) + self.record_span(span_start726, "FragmentId") + return result727 def parse_epoch(self) -> transactions_pb2.Epoch: - span_start729 = self.span_start() + span_start730 = self.span_start() self.consume_literal("(") self.consume_literal("epoch") if (self.match_lookahead_literal("(", 0) and self.match_lookahead_literal("writes", 1)): - _t1408 = self.parse_epoch_writes() - _t1407 = _t1408 - else: - _t1407 = None - epoch_writes727 = _t1407 - if self.match_lookahead_literal("(", 0): - _t1410 = self.parse_epoch_reads() + _t1410 = self.parse_epoch_writes() _t1409 = _t1410 else: _t1409 = None - epoch_reads728 = _t1409 + epoch_writes728 = _t1409 + if self.match_lookahead_literal("(", 0): + _t1412 = self.parse_epoch_reads() + _t1411 = _t1412 + else: + _t1411 = None + epoch_reads729 = _t1411 self.consume_literal(")") - _t1411 = transactions_pb2.Epoch(writes=(epoch_writes727 if epoch_writes727 is not None else []), reads=(epoch_reads728 if epoch_reads728 is not None else [])) - result730 = _t1411 - self.record_span(span_start729, "Epoch") - return result730 + _t1413 = transactions_pb2.Epoch(writes=(epoch_writes728 if epoch_writes728 is not None else []), reads=(epoch_reads729 if epoch_reads729 is not None else [])) + result731 = _t1413 + self.record_span(span_start730, "Epoch") + return result731 def parse_epoch_writes(self) -> Sequence[transactions_pb2.Write]: self.consume_literal("(") self.consume_literal("writes") - xs731 = [] - cond732 = self.match_lookahead_literal("(", 0) - while cond732: - _t1412 = self.parse_write() - item733 = _t1412 - xs731.append(item733) - cond732 = self.match_lookahead_literal("(", 0) - writes734 = xs731 + xs732 = [] + cond733 = self.match_lookahead_literal("(", 0) + while cond733: + _t1414 = self.parse_write() + item734 = _t1414 + xs732.append(item734) + cond733 = self.match_lookahead_literal("(", 0) + writes735 = xs732 self.consume_literal(")") - return writes734 + return writes735 def parse_write(self) -> transactions_pb2.Write: - span_start740 = self.span_start() + span_start741 = self.span_start() if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("undefine", 1): - _t1414 = 1 + _t1416 = 1 else: if self.match_lookahead_literal("snapshot", 1): - _t1415 = 3 + _t1417 = 3 else: if self.match_lookahead_literal("define", 1): - _t1416 = 0 + _t1418 = 0 else: if self.match_lookahead_literal("context", 1): - _t1417 = 2 + _t1419 = 2 else: - _t1417 = -1 - _t1416 = _t1417 - _t1415 = _t1416 - _t1414 = _t1415 - _t1413 = _t1414 - else: - _t1413 = -1 - prediction735 = _t1413 - if prediction735 == 3: - _t1419 = self.parse_snapshot() - snapshot739 = _t1419 - _t1420 = transactions_pb2.Write(snapshot=snapshot739) - _t1418 = _t1420 - else: - if prediction735 == 2: - _t1422 = self.parse_context() - context738 = _t1422 - _t1423 = transactions_pb2.Write(context=context738) - _t1421 = _t1423 + _t1419 = -1 + _t1418 = _t1419 + _t1417 = _t1418 + _t1416 = _t1417 + _t1415 = _t1416 + else: + _t1415 = -1 + prediction736 = _t1415 + if prediction736 == 3: + _t1421 = self.parse_snapshot() + snapshot740 = _t1421 + _t1422 = transactions_pb2.Write(snapshot=snapshot740) + _t1420 = _t1422 + else: + if prediction736 == 2: + _t1424 = self.parse_context() + context739 = _t1424 + _t1425 = transactions_pb2.Write(context=context739) + _t1423 = _t1425 else: - if prediction735 == 1: - _t1425 = self.parse_undefine() - undefine737 = _t1425 - _t1426 = transactions_pb2.Write(undefine=undefine737) - _t1424 = _t1426 + if prediction736 == 1: + _t1427 = self.parse_undefine() + undefine738 = _t1427 + _t1428 = transactions_pb2.Write(undefine=undefine738) + _t1426 = _t1428 else: - if prediction735 == 0: - _t1428 = self.parse_define() - define736 = _t1428 - _t1429 = transactions_pb2.Write(define=define736) - _t1427 = _t1429 + if prediction736 == 0: + _t1430 = self.parse_define() + define737 = _t1430 + _t1431 = transactions_pb2.Write(define=define737) + _t1429 = _t1431 else: raise ParseError("Unexpected token in write" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1424 = _t1427 - _t1421 = _t1424 - _t1418 = _t1421 - result741 = _t1418 - self.record_span(span_start740, "Write") - return result741 + _t1426 = _t1429 + _t1423 = _t1426 + _t1420 = _t1423 + result742 = _t1420 + self.record_span(span_start741, "Write") + return result742 def parse_define(self) -> transactions_pb2.Define: - span_start743 = self.span_start() + span_start744 = self.span_start() self.consume_literal("(") self.consume_literal("define") - _t1430 = self.parse_fragment() - fragment742 = _t1430 + _t1432 = self.parse_fragment() + fragment743 = _t1432 self.consume_literal(")") - _t1431 = transactions_pb2.Define(fragment=fragment742) - result744 = _t1431 - self.record_span(span_start743, "Define") - return result744 + _t1433 = transactions_pb2.Define(fragment=fragment743) + result745 = _t1433 + self.record_span(span_start744, "Define") + return result745 def parse_fragment(self) -> fragments_pb2.Fragment: - span_start750 = self.span_start() + span_start751 = self.span_start() self.consume_literal("(") self.consume_literal("fragment") - _t1432 = self.parse_new_fragment_id() - new_fragment_id745 = _t1432 - xs746 = [] - cond747 = self.match_lookahead_literal("(", 0) - while cond747: - _t1433 = self.parse_declaration() - item748 = _t1433 - xs746.append(item748) - cond747 = self.match_lookahead_literal("(", 0) - declarations749 = xs746 - self.consume_literal(")") - result751 = self.construct_fragment(new_fragment_id745, declarations749) - self.record_span(span_start750, "Fragment") - return result751 + _t1434 = self.parse_new_fragment_id() + new_fragment_id746 = _t1434 + xs747 = [] + cond748 = self.match_lookahead_literal("(", 0) + while cond748: + _t1435 = self.parse_declaration() + item749 = _t1435 + xs747.append(item749) + cond748 = self.match_lookahead_literal("(", 0) + declarations750 = xs747 + self.consume_literal(")") + result752 = self.construct_fragment(new_fragment_id746, declarations750) + self.record_span(span_start751, "Fragment") + return result752 def parse_new_fragment_id(self) -> fragments_pb2.FragmentId: - span_start753 = self.span_start() - _t1434 = self.parse_fragment_id() - fragment_id752 = _t1434 - self.start_fragment(fragment_id752) - result754 = fragment_id752 - self.record_span(span_start753, "FragmentId") - return result754 + span_start754 = self.span_start() + _t1436 = self.parse_fragment_id() + fragment_id753 = _t1436 + self.start_fragment(fragment_id753) + result755 = fragment_id753 + self.record_span(span_start754, "FragmentId") + return result755 def parse_declaration(self) -> logic_pb2.Declaration: - span_start760 = self.span_start() + span_start761 = self.span_start() if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("iceberg_data", 1): - _t1436 = 3 + _t1438 = 3 else: if self.match_lookahead_literal("functional_dependency", 1): - _t1437 = 2 + _t1439 = 2 else: if self.match_lookahead_literal("edb", 1): - _t1438 = 3 + _t1440 = 3 else: if self.match_lookahead_literal("def", 1): - _t1439 = 0 + _t1441 = 0 else: if self.match_lookahead_literal("csv_data", 1): - _t1440 = 3 + _t1442 = 3 else: if self.match_lookahead_literal("betree_relation", 1): - _t1441 = 3 + _t1443 = 3 else: if self.match_lookahead_literal("algorithm", 1): - _t1442 = 1 + _t1444 = 1 else: - _t1442 = -1 - _t1441 = _t1442 - _t1440 = _t1441 - _t1439 = _t1440 - _t1438 = _t1439 - _t1437 = _t1438 - _t1436 = _t1437 - _t1435 = _t1436 - else: - _t1435 = -1 - prediction755 = _t1435 - if prediction755 == 3: - _t1444 = self.parse_data() - data759 = _t1444 - _t1445 = logic_pb2.Declaration(data=data759) - _t1443 = _t1445 - else: - if prediction755 == 2: - _t1447 = self.parse_constraint() - constraint758 = _t1447 - _t1448 = logic_pb2.Declaration(constraint=constraint758) - _t1446 = _t1448 + _t1444 = -1 + _t1443 = _t1444 + _t1442 = _t1443 + _t1441 = _t1442 + _t1440 = _t1441 + _t1439 = _t1440 + _t1438 = _t1439 + _t1437 = _t1438 + else: + _t1437 = -1 + prediction756 = _t1437 + if prediction756 == 3: + _t1446 = self.parse_data() + data760 = _t1446 + _t1447 = logic_pb2.Declaration(data=data760) + _t1445 = _t1447 + else: + if prediction756 == 2: + _t1449 = self.parse_constraint() + constraint759 = _t1449 + _t1450 = logic_pb2.Declaration(constraint=constraint759) + _t1448 = _t1450 else: - if prediction755 == 1: - _t1450 = self.parse_algorithm() - algorithm757 = _t1450 - _t1451 = logic_pb2.Declaration(algorithm=algorithm757) - _t1449 = _t1451 + if prediction756 == 1: + _t1452 = self.parse_algorithm() + algorithm758 = _t1452 + _t1453 = logic_pb2.Declaration(algorithm=algorithm758) + _t1451 = _t1453 else: - if prediction755 == 0: - _t1453 = self.parse_def() - def756 = _t1453 - _t1454 = logic_pb2.Declaration() - getattr(_t1454, 'def').CopyFrom(def756) - _t1452 = _t1454 + if prediction756 == 0: + _t1455 = self.parse_def() + def757 = _t1455 + _t1456 = logic_pb2.Declaration() + getattr(_t1456, 'def').CopyFrom(def757) + _t1454 = _t1456 else: raise ParseError("Unexpected token in declaration" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1449 = _t1452 - _t1446 = _t1449 - _t1443 = _t1446 - result761 = _t1443 - self.record_span(span_start760, "Declaration") - return result761 + _t1451 = _t1454 + _t1448 = _t1451 + _t1445 = _t1448 + result762 = _t1445 + self.record_span(span_start761, "Declaration") + return result762 def parse_def(self) -> logic_pb2.Def: - span_start765 = self.span_start() + span_start766 = self.span_start() self.consume_literal("(") self.consume_literal("def") - _t1455 = self.parse_relation_id() - relation_id762 = _t1455 - _t1456 = self.parse_abstraction() - abstraction763 = _t1456 + _t1457 = self.parse_relation_id() + relation_id763 = _t1457 + _t1458 = self.parse_abstraction() + abstraction764 = _t1458 if self.match_lookahead_literal("(", 0): - _t1458 = self.parse_attrs() - _t1457 = _t1458 + _t1460 = self.parse_attrs() + _t1459 = _t1460 else: - _t1457 = None - attrs764 = _t1457 + _t1459 = None + attrs765 = _t1459 self.consume_literal(")") - _t1459 = logic_pb2.Def(name=relation_id762, body=abstraction763, attrs=(attrs764 if attrs764 is not None else [])) - result766 = _t1459 - self.record_span(span_start765, "Def") - return result766 + _t1461 = logic_pb2.Def(name=relation_id763, body=abstraction764, attrs=(attrs765 if attrs765 is not None else [])) + result767 = _t1461 + self.record_span(span_start766, "Def") + return result767 def parse_relation_id(self) -> logic_pb2.RelationId: - span_start770 = self.span_start() + span_start771 = self.span_start() if self.match_lookahead_literal(":", 0): - _t1460 = 0 + _t1462 = 0 else: if self.match_lookahead_terminal("UINT128", 0): - _t1461 = 1 + _t1463 = 1 else: - _t1461 = -1 - _t1460 = _t1461 - prediction767 = _t1460 - if prediction767 == 1: - uint128769 = self.consume_terminal("UINT128") - _t1462 = logic_pb2.RelationId(id_low=uint128769.low, id_high=uint128769.high) - else: - if prediction767 == 0: + _t1463 = -1 + _t1462 = _t1463 + prediction768 = _t1462 + if prediction768 == 1: + uint128770 = self.consume_terminal("UINT128") + _t1464 = logic_pb2.RelationId(id_low=uint128770.low, id_high=uint128770.high) + else: + if prediction768 == 0: self.consume_literal(":") - symbol768 = self.consume_terminal("SYMBOL") - _t1463 = self.relation_id_from_string(symbol768) + symbol769 = self.consume_terminal("SYMBOL") + _t1465 = self.relation_id_from_string(symbol769) else: raise ParseError("Unexpected token in relation_id" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1462 = _t1463 - result771 = _t1462 - self.record_span(span_start770, "RelationId") - return result771 + _t1464 = _t1465 + result772 = _t1464 + self.record_span(span_start771, "RelationId") + return result772 def parse_abstraction(self) -> logic_pb2.Abstraction: - span_start774 = self.span_start() + span_start775 = self.span_start() self.consume_literal("(") - _t1464 = self.parse_bindings() - bindings772 = _t1464 - _t1465 = self.parse_formula() - formula773 = _t1465 + _t1466 = self.parse_bindings() + bindings773 = _t1466 + _t1467 = self.parse_formula() + formula774 = _t1467 self.consume_literal(")") - _t1466 = logic_pb2.Abstraction(vars=(list(bindings772[0]) + list(bindings772[1] if bindings772[1] is not None else [])), value=formula773) - result775 = _t1466 - self.record_span(span_start774, "Abstraction") - return result775 + _t1468 = logic_pb2.Abstraction(vars=(list(bindings773[0]) + list(bindings773[1] if bindings773[1] is not None else [])), value=formula774) + result776 = _t1468 + self.record_span(span_start775, "Abstraction") + return result776 def parse_bindings(self) -> tuple[Sequence[logic_pb2.Binding], Sequence[logic_pb2.Binding]]: self.consume_literal("[") - xs776 = [] - cond777 = self.match_lookahead_terminal("SYMBOL", 0) - while cond777: - _t1467 = self.parse_binding() - item778 = _t1467 - xs776.append(item778) - cond777 = self.match_lookahead_terminal("SYMBOL", 0) - bindings779 = xs776 + xs777 = [] + cond778 = self.match_lookahead_terminal("SYMBOL", 0) + while cond778: + _t1469 = self.parse_binding() + item779 = _t1469 + xs777.append(item779) + cond778 = self.match_lookahead_terminal("SYMBOL", 0) + bindings780 = xs777 if self.match_lookahead_literal("|", 0): - _t1469 = self.parse_value_bindings() - _t1468 = _t1469 + _t1471 = self.parse_value_bindings() + _t1470 = _t1471 else: - _t1468 = None - value_bindings780 = _t1468 + _t1470 = None + value_bindings781 = _t1470 self.consume_literal("]") - return (bindings779, (value_bindings780 if value_bindings780 is not None else []),) + return (bindings780, (value_bindings781 if value_bindings781 is not None else []),) def parse_binding(self) -> logic_pb2.Binding: - span_start783 = self.span_start() - symbol781 = self.consume_terminal("SYMBOL") + span_start784 = self.span_start() + symbol782 = self.consume_terminal("SYMBOL") self.consume_literal("::") - _t1470 = self.parse_type() - type782 = _t1470 - _t1471 = logic_pb2.Var(name=symbol781) - _t1472 = logic_pb2.Binding(var=_t1471, type=type782) - result784 = _t1472 - self.record_span(span_start783, "Binding") - return result784 + _t1472 = self.parse_type() + type783 = _t1472 + _t1473 = logic_pb2.Var(name=symbol782) + _t1474 = logic_pb2.Binding(var=_t1473, type=type783) + result785 = _t1474 + self.record_span(span_start784, "Binding") + return result785 def parse_type(self) -> logic_pb2.Type: - span_start800 = self.span_start() + span_start801 = self.span_start() if self.match_lookahead_literal("UNKNOWN", 0): - _t1473 = 0 + _t1475 = 0 else: if self.match_lookahead_literal("UINT32", 0): - _t1474 = 13 + _t1476 = 13 else: if self.match_lookahead_literal("UINT128", 0): - _t1475 = 4 + _t1477 = 4 else: if self.match_lookahead_literal("STRING", 0): - _t1476 = 1 + _t1478 = 1 else: if self.match_lookahead_literal("MISSING", 0): - _t1477 = 8 + _t1479 = 8 else: if self.match_lookahead_literal("INT32", 0): - _t1478 = 11 + _t1480 = 11 else: if self.match_lookahead_literal("INT128", 0): - _t1479 = 5 + _t1481 = 5 else: if self.match_lookahead_literal("INT", 0): - _t1480 = 2 + _t1482 = 2 else: if self.match_lookahead_literal("FLOAT32", 0): - _t1481 = 12 + _t1483 = 12 else: if self.match_lookahead_literal("FLOAT", 0): - _t1482 = 3 + _t1484 = 3 else: if self.match_lookahead_literal("DATETIME", 0): - _t1483 = 7 + _t1485 = 7 else: if self.match_lookahead_literal("DATE", 0): - _t1484 = 6 + _t1486 = 6 else: if self.match_lookahead_literal("BOOLEAN", 0): - _t1485 = 10 + _t1487 = 10 else: if self.match_lookahead_literal("(", 0): - _t1486 = 9 + _t1488 = 9 else: - _t1486 = -1 - _t1485 = _t1486 - _t1484 = _t1485 - _t1483 = _t1484 - _t1482 = _t1483 - _t1481 = _t1482 - _t1480 = _t1481 - _t1479 = _t1480 - _t1478 = _t1479 - _t1477 = _t1478 - _t1476 = _t1477 - _t1475 = _t1476 - _t1474 = _t1475 - _t1473 = _t1474 - prediction785 = _t1473 - if prediction785 == 13: - _t1488 = self.parse_uint32_type() - uint32_type799 = _t1488 - _t1489 = logic_pb2.Type(uint32_type=uint32_type799) - _t1487 = _t1489 - else: - if prediction785 == 12: - _t1491 = self.parse_float32_type() - float32_type798 = _t1491 - _t1492 = logic_pb2.Type(float32_type=float32_type798) - _t1490 = _t1492 + _t1488 = -1 + _t1487 = _t1488 + _t1486 = _t1487 + _t1485 = _t1486 + _t1484 = _t1485 + _t1483 = _t1484 + _t1482 = _t1483 + _t1481 = _t1482 + _t1480 = _t1481 + _t1479 = _t1480 + _t1478 = _t1479 + _t1477 = _t1478 + _t1476 = _t1477 + _t1475 = _t1476 + prediction786 = _t1475 + if prediction786 == 13: + _t1490 = self.parse_uint32_type() + uint32_type800 = _t1490 + _t1491 = logic_pb2.Type(uint32_type=uint32_type800) + _t1489 = _t1491 + else: + if prediction786 == 12: + _t1493 = self.parse_float32_type() + float32_type799 = _t1493 + _t1494 = logic_pb2.Type(float32_type=float32_type799) + _t1492 = _t1494 else: - if prediction785 == 11: - _t1494 = self.parse_int32_type() - int32_type797 = _t1494 - _t1495 = logic_pb2.Type(int32_type=int32_type797) - _t1493 = _t1495 + if prediction786 == 11: + _t1496 = self.parse_int32_type() + int32_type798 = _t1496 + _t1497 = logic_pb2.Type(int32_type=int32_type798) + _t1495 = _t1497 else: - if prediction785 == 10: - _t1497 = self.parse_boolean_type() - boolean_type796 = _t1497 - _t1498 = logic_pb2.Type(boolean_type=boolean_type796) - _t1496 = _t1498 + if prediction786 == 10: + _t1499 = self.parse_boolean_type() + boolean_type797 = _t1499 + _t1500 = logic_pb2.Type(boolean_type=boolean_type797) + _t1498 = _t1500 else: - if prediction785 == 9: - _t1500 = self.parse_decimal_type() - decimal_type795 = _t1500 - _t1501 = logic_pb2.Type(decimal_type=decimal_type795) - _t1499 = _t1501 + if prediction786 == 9: + _t1502 = self.parse_decimal_type() + decimal_type796 = _t1502 + _t1503 = logic_pb2.Type(decimal_type=decimal_type796) + _t1501 = _t1503 else: - if prediction785 == 8: - _t1503 = self.parse_missing_type() - missing_type794 = _t1503 - _t1504 = logic_pb2.Type(missing_type=missing_type794) - _t1502 = _t1504 + if prediction786 == 8: + _t1505 = self.parse_missing_type() + missing_type795 = _t1505 + _t1506 = logic_pb2.Type(missing_type=missing_type795) + _t1504 = _t1506 else: - if prediction785 == 7: - _t1506 = self.parse_datetime_type() - datetime_type793 = _t1506 - _t1507 = logic_pb2.Type(datetime_type=datetime_type793) - _t1505 = _t1507 + if prediction786 == 7: + _t1508 = self.parse_datetime_type() + datetime_type794 = _t1508 + _t1509 = logic_pb2.Type(datetime_type=datetime_type794) + _t1507 = _t1509 else: - if prediction785 == 6: - _t1509 = self.parse_date_type() - date_type792 = _t1509 - _t1510 = logic_pb2.Type(date_type=date_type792) - _t1508 = _t1510 + if prediction786 == 6: + _t1511 = self.parse_date_type() + date_type793 = _t1511 + _t1512 = logic_pb2.Type(date_type=date_type793) + _t1510 = _t1512 else: - if prediction785 == 5: - _t1512 = self.parse_int128_type() - int128_type791 = _t1512 - _t1513 = logic_pb2.Type(int128_type=int128_type791) - _t1511 = _t1513 + if prediction786 == 5: + _t1514 = self.parse_int128_type() + int128_type792 = _t1514 + _t1515 = logic_pb2.Type(int128_type=int128_type792) + _t1513 = _t1515 else: - if prediction785 == 4: - _t1515 = self.parse_uint128_type() - uint128_type790 = _t1515 - _t1516 = logic_pb2.Type(uint128_type=uint128_type790) - _t1514 = _t1516 + if prediction786 == 4: + _t1517 = self.parse_uint128_type() + uint128_type791 = _t1517 + _t1518 = logic_pb2.Type(uint128_type=uint128_type791) + _t1516 = _t1518 else: - if prediction785 == 3: - _t1518 = self.parse_float_type() - float_type789 = _t1518 - _t1519 = logic_pb2.Type(float_type=float_type789) - _t1517 = _t1519 + if prediction786 == 3: + _t1520 = self.parse_float_type() + float_type790 = _t1520 + _t1521 = logic_pb2.Type(float_type=float_type790) + _t1519 = _t1521 else: - if prediction785 == 2: - _t1521 = self.parse_int_type() - int_type788 = _t1521 - _t1522 = logic_pb2.Type(int_type=int_type788) - _t1520 = _t1522 + if prediction786 == 2: + _t1523 = self.parse_int_type() + int_type789 = _t1523 + _t1524 = logic_pb2.Type(int_type=int_type789) + _t1522 = _t1524 else: - if prediction785 == 1: - _t1524 = self.parse_string_type() - string_type787 = _t1524 - _t1525 = logic_pb2.Type(string_type=string_type787) - _t1523 = _t1525 + if prediction786 == 1: + _t1526 = self.parse_string_type() + string_type788 = _t1526 + _t1527 = logic_pb2.Type(string_type=string_type788) + _t1525 = _t1527 else: - if prediction785 == 0: - _t1527 = self.parse_unspecified_type() - unspecified_type786 = _t1527 - _t1528 = logic_pb2.Type(unspecified_type=unspecified_type786) - _t1526 = _t1528 + if prediction786 == 0: + _t1529 = self.parse_unspecified_type() + unspecified_type787 = _t1529 + _t1530 = logic_pb2.Type(unspecified_type=unspecified_type787) + _t1528 = _t1530 else: raise ParseError("Unexpected token in type" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1523 = _t1526 - _t1520 = _t1523 - _t1517 = _t1520 - _t1514 = _t1517 - _t1511 = _t1514 - _t1508 = _t1511 - _t1505 = _t1508 - _t1502 = _t1505 - _t1499 = _t1502 - _t1496 = _t1499 - _t1493 = _t1496 - _t1490 = _t1493 - _t1487 = _t1490 - result801 = _t1487 - self.record_span(span_start800, "Type") - return result801 + _t1525 = _t1528 + _t1522 = _t1525 + _t1519 = _t1522 + _t1516 = _t1519 + _t1513 = _t1516 + _t1510 = _t1513 + _t1507 = _t1510 + _t1504 = _t1507 + _t1501 = _t1504 + _t1498 = _t1501 + _t1495 = _t1498 + _t1492 = _t1495 + _t1489 = _t1492 + result802 = _t1489 + self.record_span(span_start801, "Type") + return result802 def parse_unspecified_type(self) -> logic_pb2.UnspecifiedType: - span_start802 = self.span_start() + span_start803 = self.span_start() self.consume_literal("UNKNOWN") - _t1529 = logic_pb2.UnspecifiedType() - result803 = _t1529 - self.record_span(span_start802, "UnspecifiedType") - return result803 + _t1531 = logic_pb2.UnspecifiedType() + result804 = _t1531 + self.record_span(span_start803, "UnspecifiedType") + return result804 def parse_string_type(self) -> logic_pb2.StringType: - span_start804 = self.span_start() + span_start805 = self.span_start() self.consume_literal("STRING") - _t1530 = logic_pb2.StringType() - result805 = _t1530 - self.record_span(span_start804, "StringType") - return result805 + _t1532 = logic_pb2.StringType() + result806 = _t1532 + self.record_span(span_start805, "StringType") + return result806 def parse_int_type(self) -> logic_pb2.IntType: - span_start806 = self.span_start() + span_start807 = self.span_start() self.consume_literal("INT") - _t1531 = logic_pb2.IntType() - result807 = _t1531 - self.record_span(span_start806, "IntType") - return result807 + _t1533 = logic_pb2.IntType() + result808 = _t1533 + self.record_span(span_start807, "IntType") + return result808 def parse_float_type(self) -> logic_pb2.FloatType: - span_start808 = self.span_start() + span_start809 = self.span_start() self.consume_literal("FLOAT") - _t1532 = logic_pb2.FloatType() - result809 = _t1532 - self.record_span(span_start808, "FloatType") - return result809 + _t1534 = logic_pb2.FloatType() + result810 = _t1534 + self.record_span(span_start809, "FloatType") + return result810 def parse_uint128_type(self) -> logic_pb2.UInt128Type: - span_start810 = self.span_start() + span_start811 = self.span_start() self.consume_literal("UINT128") - _t1533 = logic_pb2.UInt128Type() - result811 = _t1533 - self.record_span(span_start810, "UInt128Type") - return result811 + _t1535 = logic_pb2.UInt128Type() + result812 = _t1535 + self.record_span(span_start811, "UInt128Type") + return result812 def parse_int128_type(self) -> logic_pb2.Int128Type: - span_start812 = self.span_start() + span_start813 = self.span_start() self.consume_literal("INT128") - _t1534 = logic_pb2.Int128Type() - result813 = _t1534 - self.record_span(span_start812, "Int128Type") - return result813 + _t1536 = logic_pb2.Int128Type() + result814 = _t1536 + self.record_span(span_start813, "Int128Type") + return result814 def parse_date_type(self) -> logic_pb2.DateType: - span_start814 = self.span_start() + span_start815 = self.span_start() self.consume_literal("DATE") - _t1535 = logic_pb2.DateType() - result815 = _t1535 - self.record_span(span_start814, "DateType") - return result815 + _t1537 = logic_pb2.DateType() + result816 = _t1537 + self.record_span(span_start815, "DateType") + return result816 def parse_datetime_type(self) -> logic_pb2.DateTimeType: - span_start816 = self.span_start() + span_start817 = self.span_start() self.consume_literal("DATETIME") - _t1536 = logic_pb2.DateTimeType() - result817 = _t1536 - self.record_span(span_start816, "DateTimeType") - return result817 + _t1538 = logic_pb2.DateTimeType() + result818 = _t1538 + self.record_span(span_start817, "DateTimeType") + return result818 def parse_missing_type(self) -> logic_pb2.MissingType: - span_start818 = self.span_start() + span_start819 = self.span_start() self.consume_literal("MISSING") - _t1537 = logic_pb2.MissingType() - result819 = _t1537 - self.record_span(span_start818, "MissingType") - return result819 + _t1539 = logic_pb2.MissingType() + result820 = _t1539 + self.record_span(span_start819, "MissingType") + return result820 def parse_decimal_type(self) -> logic_pb2.DecimalType: - span_start822 = self.span_start() + span_start823 = self.span_start() self.consume_literal("(") self.consume_literal("DECIMAL") - int820 = self.consume_terminal("INT") - int_3821 = self.consume_terminal("INT") + int821 = self.consume_terminal("INT") + int_3822 = self.consume_terminal("INT") self.consume_literal(")") - _t1538 = logic_pb2.DecimalType(precision=int(int820), scale=int(int_3821)) - result823 = _t1538 - self.record_span(span_start822, "DecimalType") - return result823 + _t1540 = logic_pb2.DecimalType(precision=int(int821), scale=int(int_3822)) + result824 = _t1540 + self.record_span(span_start823, "DecimalType") + return result824 def parse_boolean_type(self) -> logic_pb2.BooleanType: - span_start824 = self.span_start() + span_start825 = self.span_start() self.consume_literal("BOOLEAN") - _t1539 = logic_pb2.BooleanType() - result825 = _t1539 - self.record_span(span_start824, "BooleanType") - return result825 + _t1541 = logic_pb2.BooleanType() + result826 = _t1541 + self.record_span(span_start825, "BooleanType") + return result826 def parse_int32_type(self) -> logic_pb2.Int32Type: - span_start826 = self.span_start() + span_start827 = self.span_start() self.consume_literal("INT32") - _t1540 = logic_pb2.Int32Type() - result827 = _t1540 - self.record_span(span_start826, "Int32Type") - return result827 + _t1542 = logic_pb2.Int32Type() + result828 = _t1542 + self.record_span(span_start827, "Int32Type") + return result828 def parse_float32_type(self) -> logic_pb2.Float32Type: - span_start828 = self.span_start() + span_start829 = self.span_start() self.consume_literal("FLOAT32") - _t1541 = logic_pb2.Float32Type() - result829 = _t1541 - self.record_span(span_start828, "Float32Type") - return result829 + _t1543 = logic_pb2.Float32Type() + result830 = _t1543 + self.record_span(span_start829, "Float32Type") + return result830 def parse_uint32_type(self) -> logic_pb2.UInt32Type: - span_start830 = self.span_start() + span_start831 = self.span_start() self.consume_literal("UINT32") - _t1542 = logic_pb2.UInt32Type() - result831 = _t1542 - self.record_span(span_start830, "UInt32Type") - return result831 + _t1544 = logic_pb2.UInt32Type() + result832 = _t1544 + self.record_span(span_start831, "UInt32Type") + return result832 def parse_value_bindings(self) -> Sequence[logic_pb2.Binding]: self.consume_literal("|") - xs832 = [] - cond833 = self.match_lookahead_terminal("SYMBOL", 0) - while cond833: - _t1543 = self.parse_binding() - item834 = _t1543 - xs832.append(item834) - cond833 = self.match_lookahead_terminal("SYMBOL", 0) - bindings835 = xs832 - return bindings835 + xs833 = [] + cond834 = self.match_lookahead_terminal("SYMBOL", 0) + while cond834: + _t1545 = self.parse_binding() + item835 = _t1545 + xs833.append(item835) + cond834 = self.match_lookahead_terminal("SYMBOL", 0) + bindings836 = xs833 + return bindings836 def parse_formula(self) -> logic_pb2.Formula: - span_start850 = self.span_start() + span_start851 = self.span_start() if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("true", 1): - _t1545 = 0 + _t1547 = 0 else: if self.match_lookahead_literal("relatom", 1): - _t1546 = 11 + _t1548 = 11 else: if self.match_lookahead_literal("reduce", 1): - _t1547 = 3 + _t1549 = 3 else: if self.match_lookahead_literal("primitive", 1): - _t1548 = 10 + _t1550 = 10 else: if self.match_lookahead_literal("pragma", 1): - _t1549 = 9 + _t1551 = 9 else: if self.match_lookahead_literal("or", 1): - _t1550 = 5 + _t1552 = 5 else: if self.match_lookahead_literal("not", 1): - _t1551 = 6 + _t1553 = 6 else: if self.match_lookahead_literal("ffi", 1): - _t1552 = 7 + _t1554 = 7 else: if self.match_lookahead_literal("false", 1): - _t1553 = 1 + _t1555 = 1 else: if self.match_lookahead_literal("exists", 1): - _t1554 = 2 + _t1556 = 2 else: if self.match_lookahead_literal("cast", 1): - _t1555 = 12 + _t1557 = 12 else: if self.match_lookahead_literal("atom", 1): - _t1556 = 8 + _t1558 = 8 else: if self.match_lookahead_literal("and", 1): - _t1557 = 4 + _t1559 = 4 else: if self.match_lookahead_literal(">=", 1): - _t1558 = 10 + _t1560 = 10 else: if self.match_lookahead_literal(">", 1): - _t1559 = 10 + _t1561 = 10 else: if self.match_lookahead_literal("=", 1): - _t1560 = 10 + _t1562 = 10 else: if self.match_lookahead_literal("<=", 1): - _t1561 = 10 + _t1563 = 10 else: if self.match_lookahead_literal("<", 1): - _t1562 = 10 + _t1564 = 10 else: if self.match_lookahead_literal("/", 1): - _t1563 = 10 + _t1565 = 10 else: if self.match_lookahead_literal("-", 1): - _t1564 = 10 + _t1566 = 10 else: if self.match_lookahead_literal("+", 1): - _t1565 = 10 + _t1567 = 10 else: if self.match_lookahead_literal("*", 1): - _t1566 = 10 + _t1568 = 10 else: - _t1566 = -1 - _t1565 = _t1566 - _t1564 = _t1565 - _t1563 = _t1564 - _t1562 = _t1563 - _t1561 = _t1562 - _t1560 = _t1561 - _t1559 = _t1560 - _t1558 = _t1559 - _t1557 = _t1558 - _t1556 = _t1557 - _t1555 = _t1556 - _t1554 = _t1555 - _t1553 = _t1554 - _t1552 = _t1553 - _t1551 = _t1552 - _t1550 = _t1551 - _t1549 = _t1550 - _t1548 = _t1549 - _t1547 = _t1548 - _t1546 = _t1547 - _t1545 = _t1546 - _t1544 = _t1545 - else: - _t1544 = -1 - prediction836 = _t1544 - if prediction836 == 12: - _t1568 = self.parse_cast() - cast849 = _t1568 - _t1569 = logic_pb2.Formula(cast=cast849) - _t1567 = _t1569 - else: - if prediction836 == 11: - _t1571 = self.parse_rel_atom() - rel_atom848 = _t1571 - _t1572 = logic_pb2.Formula(rel_atom=rel_atom848) - _t1570 = _t1572 + _t1568 = -1 + _t1567 = _t1568 + _t1566 = _t1567 + _t1565 = _t1566 + _t1564 = _t1565 + _t1563 = _t1564 + _t1562 = _t1563 + _t1561 = _t1562 + _t1560 = _t1561 + _t1559 = _t1560 + _t1558 = _t1559 + _t1557 = _t1558 + _t1556 = _t1557 + _t1555 = _t1556 + _t1554 = _t1555 + _t1553 = _t1554 + _t1552 = _t1553 + _t1551 = _t1552 + _t1550 = _t1551 + _t1549 = _t1550 + _t1548 = _t1549 + _t1547 = _t1548 + _t1546 = _t1547 + else: + _t1546 = -1 + prediction837 = _t1546 + if prediction837 == 12: + _t1570 = self.parse_cast() + cast850 = _t1570 + _t1571 = logic_pb2.Formula(cast=cast850) + _t1569 = _t1571 + else: + if prediction837 == 11: + _t1573 = self.parse_rel_atom() + rel_atom849 = _t1573 + _t1574 = logic_pb2.Formula(rel_atom=rel_atom849) + _t1572 = _t1574 else: - if prediction836 == 10: - _t1574 = self.parse_primitive() - primitive847 = _t1574 - _t1575 = logic_pb2.Formula(primitive=primitive847) - _t1573 = _t1575 + if prediction837 == 10: + _t1576 = self.parse_primitive() + primitive848 = _t1576 + _t1577 = logic_pb2.Formula(primitive=primitive848) + _t1575 = _t1577 else: - if prediction836 == 9: - _t1577 = self.parse_pragma() - pragma846 = _t1577 - _t1578 = logic_pb2.Formula(pragma=pragma846) - _t1576 = _t1578 + if prediction837 == 9: + _t1579 = self.parse_pragma() + pragma847 = _t1579 + _t1580 = logic_pb2.Formula(pragma=pragma847) + _t1578 = _t1580 else: - if prediction836 == 8: - _t1580 = self.parse_atom() - atom845 = _t1580 - _t1581 = logic_pb2.Formula(atom=atom845) - _t1579 = _t1581 + if prediction837 == 8: + _t1582 = self.parse_atom() + atom846 = _t1582 + _t1583 = logic_pb2.Formula(atom=atom846) + _t1581 = _t1583 else: - if prediction836 == 7: - _t1583 = self.parse_ffi() - ffi844 = _t1583 - _t1584 = logic_pb2.Formula(ffi=ffi844) - _t1582 = _t1584 + if prediction837 == 7: + _t1585 = self.parse_ffi() + ffi845 = _t1585 + _t1586 = logic_pb2.Formula(ffi=ffi845) + _t1584 = _t1586 else: - if prediction836 == 6: - _t1586 = self.parse_not() - not843 = _t1586 - _t1587 = logic_pb2.Formula() - getattr(_t1587, 'not').CopyFrom(not843) - _t1585 = _t1587 + if prediction837 == 6: + _t1588 = self.parse_not() + not844 = _t1588 + _t1589 = logic_pb2.Formula() + getattr(_t1589, 'not').CopyFrom(not844) + _t1587 = _t1589 else: - if prediction836 == 5: - _t1589 = self.parse_disjunction() - disjunction842 = _t1589 - _t1590 = logic_pb2.Formula(disjunction=disjunction842) - _t1588 = _t1590 + if prediction837 == 5: + _t1591 = self.parse_disjunction() + disjunction843 = _t1591 + _t1592 = logic_pb2.Formula(disjunction=disjunction843) + _t1590 = _t1592 else: - if prediction836 == 4: - _t1592 = self.parse_conjunction() - conjunction841 = _t1592 - _t1593 = logic_pb2.Formula(conjunction=conjunction841) - _t1591 = _t1593 + if prediction837 == 4: + _t1594 = self.parse_conjunction() + conjunction842 = _t1594 + _t1595 = logic_pb2.Formula(conjunction=conjunction842) + _t1593 = _t1595 else: - if prediction836 == 3: - _t1595 = self.parse_reduce() - reduce840 = _t1595 - _t1596 = logic_pb2.Formula(reduce=reduce840) - _t1594 = _t1596 + if prediction837 == 3: + _t1597 = self.parse_reduce() + reduce841 = _t1597 + _t1598 = logic_pb2.Formula(reduce=reduce841) + _t1596 = _t1598 else: - if prediction836 == 2: - _t1598 = self.parse_exists() - exists839 = _t1598 - _t1599 = logic_pb2.Formula(exists=exists839) - _t1597 = _t1599 + if prediction837 == 2: + _t1600 = self.parse_exists() + exists840 = _t1600 + _t1601 = logic_pb2.Formula(exists=exists840) + _t1599 = _t1601 else: - if prediction836 == 1: - _t1601 = self.parse_false() - false838 = _t1601 - _t1602 = logic_pb2.Formula(disjunction=false838) - _t1600 = _t1602 + if prediction837 == 1: + _t1603 = self.parse_false() + false839 = _t1603 + _t1604 = logic_pb2.Formula(disjunction=false839) + _t1602 = _t1604 else: - if prediction836 == 0: - _t1604 = self.parse_true() - true837 = _t1604 - _t1605 = logic_pb2.Formula(conjunction=true837) - _t1603 = _t1605 + if prediction837 == 0: + _t1606 = self.parse_true() + true838 = _t1606 + _t1607 = logic_pb2.Formula(conjunction=true838) + _t1605 = _t1607 else: raise ParseError("Unexpected token in formula" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1600 = _t1603 - _t1597 = _t1600 - _t1594 = _t1597 - _t1591 = _t1594 - _t1588 = _t1591 - _t1585 = _t1588 - _t1582 = _t1585 - _t1579 = _t1582 - _t1576 = _t1579 - _t1573 = _t1576 - _t1570 = _t1573 - _t1567 = _t1570 - result851 = _t1567 - self.record_span(span_start850, "Formula") - return result851 + _t1602 = _t1605 + _t1599 = _t1602 + _t1596 = _t1599 + _t1593 = _t1596 + _t1590 = _t1593 + _t1587 = _t1590 + _t1584 = _t1587 + _t1581 = _t1584 + _t1578 = _t1581 + _t1575 = _t1578 + _t1572 = _t1575 + _t1569 = _t1572 + result852 = _t1569 + self.record_span(span_start851, "Formula") + return result852 def parse_true(self) -> logic_pb2.Conjunction: - span_start852 = self.span_start() + span_start853 = self.span_start() self.consume_literal("(") self.consume_literal("true") self.consume_literal(")") - _t1606 = logic_pb2.Conjunction(args=[]) - result853 = _t1606 - self.record_span(span_start852, "Conjunction") - return result853 + _t1608 = logic_pb2.Conjunction(args=[]) + result854 = _t1608 + self.record_span(span_start853, "Conjunction") + return result854 def parse_false(self) -> logic_pb2.Disjunction: - span_start854 = self.span_start() + span_start855 = self.span_start() self.consume_literal("(") self.consume_literal("false") self.consume_literal(")") - _t1607 = logic_pb2.Disjunction(args=[]) - result855 = _t1607 - self.record_span(span_start854, "Disjunction") - return result855 + _t1609 = logic_pb2.Disjunction(args=[]) + result856 = _t1609 + self.record_span(span_start855, "Disjunction") + return result856 def parse_exists(self) -> logic_pb2.Exists: - span_start858 = self.span_start() + span_start859 = self.span_start() self.consume_literal("(") self.consume_literal("exists") - _t1608 = self.parse_bindings() - bindings856 = _t1608 - _t1609 = self.parse_formula() - formula857 = _t1609 + _t1610 = self.parse_bindings() + bindings857 = _t1610 + _t1611 = self.parse_formula() + formula858 = _t1611 self.consume_literal(")") - _t1610 = logic_pb2.Abstraction(vars=(list(bindings856[0]) + list(bindings856[1] if bindings856[1] is not None else [])), value=formula857) - _t1611 = logic_pb2.Exists(body=_t1610) - result859 = _t1611 - self.record_span(span_start858, "Exists") - return result859 + _t1612 = logic_pb2.Abstraction(vars=(list(bindings857[0]) + list(bindings857[1] if bindings857[1] is not None else [])), value=formula858) + _t1613 = logic_pb2.Exists(body=_t1612) + result860 = _t1613 + self.record_span(span_start859, "Exists") + return result860 def parse_reduce(self) -> logic_pb2.Reduce: - span_start863 = self.span_start() + span_start864 = self.span_start() self.consume_literal("(") self.consume_literal("reduce") - _t1612 = self.parse_abstraction() - abstraction860 = _t1612 - _t1613 = self.parse_abstraction() - abstraction_3861 = _t1613 - _t1614 = self.parse_terms() - terms862 = _t1614 - self.consume_literal(")") - _t1615 = logic_pb2.Reduce(op=abstraction860, body=abstraction_3861, terms=terms862) - result864 = _t1615 - self.record_span(span_start863, "Reduce") - return result864 + _t1614 = self.parse_abstraction() + abstraction861 = _t1614 + _t1615 = self.parse_abstraction() + abstraction_3862 = _t1615 + _t1616 = self.parse_terms() + terms863 = _t1616 + self.consume_literal(")") + _t1617 = logic_pb2.Reduce(op=abstraction861, body=abstraction_3862, terms=terms863) + result865 = _t1617 + self.record_span(span_start864, "Reduce") + return result865 def parse_terms(self) -> Sequence[logic_pb2.Term]: self.consume_literal("(") self.consume_literal("terms") - xs865 = [] - cond866 = (((((((((((((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 cond866: - _t1616 = self.parse_term() - item867 = _t1616 - xs865.append(item867) - cond866 = (((((((((((((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)) - terms868 = xs865 + xs866 = [] + cond867 = (((((((((((((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 cond867: + _t1618 = self.parse_term() + item868 = _t1618 + xs866.append(item868) + cond867 = (((((((((((((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)) + terms869 = xs866 self.consume_literal(")") - return terms868 + return terms869 def parse_term(self) -> logic_pb2.Term: - span_start872 = self.span_start() + span_start873 = self.span_start() if self.match_lookahead_literal("true", 0): - _t1617 = 1 + _t1619 = 1 else: if self.match_lookahead_literal("missing", 0): - _t1618 = 1 + _t1620 = 1 else: if self.match_lookahead_literal("false", 0): - _t1619 = 1 + _t1621 = 1 else: if self.match_lookahead_literal("(", 0): - _t1620 = 1 + _t1622 = 1 else: if self.match_lookahead_terminal("SYMBOL", 0): - _t1621 = 0 + _t1623 = 0 else: if self.match_lookahead_terminal("UINT32", 0): - _t1622 = 1 + _t1624 = 1 else: if self.match_lookahead_terminal("UINT128", 0): - _t1623 = 1 + _t1625 = 1 else: if self.match_lookahead_terminal("STRING", 0): - _t1624 = 1 + _t1626 = 1 else: if self.match_lookahead_terminal("INT32", 0): - _t1625 = 1 + _t1627 = 1 else: if self.match_lookahead_terminal("INT128", 0): - _t1626 = 1 + _t1628 = 1 else: if self.match_lookahead_terminal("INT", 0): - _t1627 = 1 + _t1629 = 1 else: if self.match_lookahead_terminal("FLOAT32", 0): - _t1628 = 1 + _t1630 = 1 else: if self.match_lookahead_terminal("FLOAT", 0): - _t1629 = 1 + _t1631 = 1 else: if self.match_lookahead_terminal("DECIMAL", 0): - _t1630 = 1 + _t1632 = 1 else: - _t1630 = -1 - _t1629 = _t1630 - _t1628 = _t1629 - _t1627 = _t1628 - _t1626 = _t1627 - _t1625 = _t1626 - _t1624 = _t1625 - _t1623 = _t1624 - _t1622 = _t1623 - _t1621 = _t1622 - _t1620 = _t1621 - _t1619 = _t1620 - _t1618 = _t1619 - _t1617 = _t1618 - prediction869 = _t1617 - if prediction869 == 1: - _t1632 = self.parse_value() - value871 = _t1632 - _t1633 = logic_pb2.Term(constant=value871) - _t1631 = _t1633 - else: - if prediction869 == 0: - _t1635 = self.parse_var() - var870 = _t1635 - _t1636 = logic_pb2.Term(var=var870) - _t1634 = _t1636 + _t1632 = -1 + _t1631 = _t1632 + _t1630 = _t1631 + _t1629 = _t1630 + _t1628 = _t1629 + _t1627 = _t1628 + _t1626 = _t1627 + _t1625 = _t1626 + _t1624 = _t1625 + _t1623 = _t1624 + _t1622 = _t1623 + _t1621 = _t1622 + _t1620 = _t1621 + _t1619 = _t1620 + prediction870 = _t1619 + if prediction870 == 1: + _t1634 = self.parse_value() + value872 = _t1634 + _t1635 = logic_pb2.Term(constant=value872) + _t1633 = _t1635 + else: + if prediction870 == 0: + _t1637 = self.parse_var() + var871 = _t1637 + _t1638 = logic_pb2.Term(var=var871) + _t1636 = _t1638 else: raise ParseError("Unexpected token in term" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1631 = _t1634 - result873 = _t1631 - self.record_span(span_start872, "Term") - return result873 + _t1633 = _t1636 + result874 = _t1633 + self.record_span(span_start873, "Term") + return result874 def parse_var(self) -> logic_pb2.Var: - span_start875 = self.span_start() - symbol874 = self.consume_terminal("SYMBOL") - _t1637 = logic_pb2.Var(name=symbol874) - result876 = _t1637 - self.record_span(span_start875, "Var") - return result876 + span_start876 = self.span_start() + symbol875 = self.consume_terminal("SYMBOL") + _t1639 = logic_pb2.Var(name=symbol875) + result877 = _t1639 + self.record_span(span_start876, "Var") + return result877 def parse_value(self) -> logic_pb2.Value: - span_start890 = self.span_start() + span_start891 = self.span_start() if self.match_lookahead_literal("true", 0): - _t1638 = 12 + _t1640 = 12 else: if self.match_lookahead_literal("missing", 0): - _t1639 = 11 + _t1641 = 11 else: if self.match_lookahead_literal("false", 0): - _t1640 = 12 + _t1642 = 12 else: if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("datetime", 1): - _t1642 = 1 + _t1644 = 1 else: if self.match_lookahead_literal("date", 1): - _t1643 = 0 + _t1645 = 0 else: - _t1643 = -1 - _t1642 = _t1643 - _t1641 = _t1642 + _t1645 = -1 + _t1644 = _t1645 + _t1643 = _t1644 else: if self.match_lookahead_terminal("UINT32", 0): - _t1644 = 7 + _t1646 = 7 else: if self.match_lookahead_terminal("UINT128", 0): - _t1645 = 8 + _t1647 = 8 else: if self.match_lookahead_terminal("STRING", 0): - _t1646 = 2 + _t1648 = 2 else: if self.match_lookahead_terminal("INT32", 0): - _t1647 = 3 + _t1649 = 3 else: if self.match_lookahead_terminal("INT128", 0): - _t1648 = 9 + _t1650 = 9 else: if self.match_lookahead_terminal("INT", 0): - _t1649 = 4 + _t1651 = 4 else: if self.match_lookahead_terminal("FLOAT32", 0): - _t1650 = 5 + _t1652 = 5 else: if self.match_lookahead_terminal("FLOAT", 0): - _t1651 = 6 + _t1653 = 6 else: if self.match_lookahead_terminal("DECIMAL", 0): - _t1652 = 10 + _t1654 = 10 else: - _t1652 = -1 - _t1651 = _t1652 - _t1650 = _t1651 - _t1649 = _t1650 - _t1648 = _t1649 - _t1647 = _t1648 - _t1646 = _t1647 - _t1645 = _t1646 - _t1644 = _t1645 - _t1641 = _t1644 - _t1640 = _t1641 - _t1639 = _t1640 - _t1638 = _t1639 - prediction877 = _t1638 - if prediction877 == 12: - _t1654 = self.parse_boolean_value() - boolean_value889 = _t1654 - _t1655 = logic_pb2.Value(boolean_value=boolean_value889) - _t1653 = _t1655 - else: - if prediction877 == 11: + _t1654 = -1 + _t1653 = _t1654 + _t1652 = _t1653 + _t1651 = _t1652 + _t1650 = _t1651 + _t1649 = _t1650 + _t1648 = _t1649 + _t1647 = _t1648 + _t1646 = _t1647 + _t1643 = _t1646 + _t1642 = _t1643 + _t1641 = _t1642 + _t1640 = _t1641 + prediction878 = _t1640 + if prediction878 == 12: + _t1656 = self.parse_boolean_value() + boolean_value890 = _t1656 + _t1657 = logic_pb2.Value(boolean_value=boolean_value890) + _t1655 = _t1657 + else: + if prediction878 == 11: self.consume_literal("missing") - _t1657 = logic_pb2.MissingValue() - _t1658 = logic_pb2.Value(missing_value=_t1657) - _t1656 = _t1658 + _t1659 = logic_pb2.MissingValue() + _t1660 = logic_pb2.Value(missing_value=_t1659) + _t1658 = _t1660 else: - if prediction877 == 10: - formatted_decimal888 = self.consume_terminal("DECIMAL") - _t1660 = logic_pb2.Value(decimal_value=formatted_decimal888) - _t1659 = _t1660 + if prediction878 == 10: + formatted_decimal889 = self.consume_terminal("DECIMAL") + _t1662 = logic_pb2.Value(decimal_value=formatted_decimal889) + _t1661 = _t1662 else: - if prediction877 == 9: - formatted_int128887 = self.consume_terminal("INT128") - _t1662 = logic_pb2.Value(int128_value=formatted_int128887) - _t1661 = _t1662 + if prediction878 == 9: + formatted_int128888 = self.consume_terminal("INT128") + _t1664 = logic_pb2.Value(int128_value=formatted_int128888) + _t1663 = _t1664 else: - if prediction877 == 8: - formatted_uint128886 = self.consume_terminal("UINT128") - _t1664 = logic_pb2.Value(uint128_value=formatted_uint128886) - _t1663 = _t1664 + if prediction878 == 8: + formatted_uint128887 = self.consume_terminal("UINT128") + _t1666 = logic_pb2.Value(uint128_value=formatted_uint128887) + _t1665 = _t1666 else: - if prediction877 == 7: - formatted_uint32885 = self.consume_terminal("UINT32") - _t1666 = logic_pb2.Value(uint32_value=formatted_uint32885) - _t1665 = _t1666 + if prediction878 == 7: + formatted_uint32886 = self.consume_terminal("UINT32") + _t1668 = logic_pb2.Value(uint32_value=formatted_uint32886) + _t1667 = _t1668 else: - if prediction877 == 6: - formatted_float884 = self.consume_terminal("FLOAT") - _t1668 = logic_pb2.Value(float_value=formatted_float884) - _t1667 = _t1668 + if prediction878 == 6: + formatted_float885 = self.consume_terminal("FLOAT") + _t1670 = logic_pb2.Value(float_value=formatted_float885) + _t1669 = _t1670 else: - if prediction877 == 5: - formatted_float32883 = self.consume_terminal("FLOAT32") - _t1670 = logic_pb2.Value(float32_value=formatted_float32883) - _t1669 = _t1670 + if prediction878 == 5: + formatted_float32884 = self.consume_terminal("FLOAT32") + _t1672 = logic_pb2.Value(float32_value=formatted_float32884) + _t1671 = _t1672 else: - if prediction877 == 4: - formatted_int882 = self.consume_terminal("INT") - _t1672 = logic_pb2.Value(int_value=formatted_int882) - _t1671 = _t1672 + if prediction878 == 4: + formatted_int883 = self.consume_terminal("INT") + _t1674 = logic_pb2.Value(int_value=formatted_int883) + _t1673 = _t1674 else: - if prediction877 == 3: - formatted_int32881 = self.consume_terminal("INT32") - _t1674 = logic_pb2.Value(int32_value=formatted_int32881) - _t1673 = _t1674 + if prediction878 == 3: + formatted_int32882 = self.consume_terminal("INT32") + _t1676 = logic_pb2.Value(int32_value=formatted_int32882) + _t1675 = _t1676 else: - if prediction877 == 2: - formatted_string880 = self.consume_terminal("STRING") - _t1676 = logic_pb2.Value(string_value=formatted_string880) - _t1675 = _t1676 + if prediction878 == 2: + formatted_string881 = self.consume_terminal("STRING") + _t1678 = logic_pb2.Value(string_value=formatted_string881) + _t1677 = _t1678 else: - if prediction877 == 1: - _t1678 = self.parse_datetime() - datetime879 = _t1678 - _t1679 = logic_pb2.Value(datetime_value=datetime879) - _t1677 = _t1679 + if prediction878 == 1: + _t1680 = self.parse_datetime() + datetime880 = _t1680 + _t1681 = logic_pb2.Value(datetime_value=datetime880) + _t1679 = _t1681 else: - if prediction877 == 0: - _t1681 = self.parse_date() - date878 = _t1681 - _t1682 = logic_pb2.Value(date_value=date878) - _t1680 = _t1682 + if prediction878 == 0: + _t1683 = self.parse_date() + date879 = _t1683 + _t1684 = logic_pb2.Value(date_value=date879) + _t1682 = _t1684 else: raise ParseError("Unexpected token in value" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1677 = _t1680 - _t1675 = _t1677 - _t1673 = _t1675 - _t1671 = _t1673 - _t1669 = _t1671 - _t1667 = _t1669 - _t1665 = _t1667 - _t1663 = _t1665 - _t1661 = _t1663 - _t1659 = _t1661 - _t1656 = _t1659 - _t1653 = _t1656 - result891 = _t1653 - self.record_span(span_start890, "Value") - return result891 + _t1679 = _t1682 + _t1677 = _t1679 + _t1675 = _t1677 + _t1673 = _t1675 + _t1671 = _t1673 + _t1669 = _t1671 + _t1667 = _t1669 + _t1665 = _t1667 + _t1663 = _t1665 + _t1661 = _t1663 + _t1658 = _t1661 + _t1655 = _t1658 + result892 = _t1655 + self.record_span(span_start891, "Value") + return result892 def parse_date(self) -> logic_pb2.DateValue: - span_start895 = self.span_start() + span_start896 = self.span_start() self.consume_literal("(") self.consume_literal("date") - formatted_int892 = self.consume_terminal("INT") - formatted_int_3893 = self.consume_terminal("INT") - formatted_int_4894 = self.consume_terminal("INT") + formatted_int893 = self.consume_terminal("INT") + formatted_int_3894 = self.consume_terminal("INT") + formatted_int_4895 = self.consume_terminal("INT") self.consume_literal(")") - _t1683 = logic_pb2.DateValue(year=int(formatted_int892), month=int(formatted_int_3893), day=int(formatted_int_4894)) - result896 = _t1683 - self.record_span(span_start895, "DateValue") - return result896 + _t1685 = logic_pb2.DateValue(year=int(formatted_int893), month=int(formatted_int_3894), day=int(formatted_int_4895)) + result897 = _t1685 + self.record_span(span_start896, "DateValue") + return result897 def parse_datetime(self) -> logic_pb2.DateTimeValue: - span_start904 = self.span_start() + span_start905 = self.span_start() self.consume_literal("(") self.consume_literal("datetime") - formatted_int897 = self.consume_terminal("INT") - formatted_int_3898 = self.consume_terminal("INT") - formatted_int_4899 = self.consume_terminal("INT") - formatted_int_5900 = self.consume_terminal("INT") - formatted_int_6901 = self.consume_terminal("INT") - formatted_int_7902 = self.consume_terminal("INT") + formatted_int898 = self.consume_terminal("INT") + formatted_int_3899 = self.consume_terminal("INT") + formatted_int_4900 = self.consume_terminal("INT") + formatted_int_5901 = self.consume_terminal("INT") + formatted_int_6902 = self.consume_terminal("INT") + formatted_int_7903 = self.consume_terminal("INT") if self.match_lookahead_terminal("INT", 0): - _t1684 = self.consume_terminal("INT") + _t1686 = self.consume_terminal("INT") else: - _t1684 = None - formatted_int_8903 = _t1684 + _t1686 = None + formatted_int_8904 = _t1686 self.consume_literal(")") - _t1685 = logic_pb2.DateTimeValue(year=int(formatted_int897), month=int(formatted_int_3898), day=int(formatted_int_4899), hour=int(formatted_int_5900), minute=int(formatted_int_6901), second=int(formatted_int_7902), microsecond=int((formatted_int_8903 if formatted_int_8903 is not None else 0))) - result905 = _t1685 - self.record_span(span_start904, "DateTimeValue") - return result905 + _t1687 = logic_pb2.DateTimeValue(year=int(formatted_int898), month=int(formatted_int_3899), day=int(formatted_int_4900), hour=int(formatted_int_5901), minute=int(formatted_int_6902), second=int(formatted_int_7903), microsecond=int((formatted_int_8904 if formatted_int_8904 is not None else 0))) + result906 = _t1687 + self.record_span(span_start905, "DateTimeValue") + return result906 def parse_conjunction(self) -> logic_pb2.Conjunction: - span_start910 = self.span_start() + span_start911 = self.span_start() self.consume_literal("(") self.consume_literal("and") - xs906 = [] - cond907 = self.match_lookahead_literal("(", 0) - while cond907: - _t1686 = self.parse_formula() - item908 = _t1686 - xs906.append(item908) - cond907 = self.match_lookahead_literal("(", 0) - formulas909 = xs906 - self.consume_literal(")") - _t1687 = logic_pb2.Conjunction(args=formulas909) - result911 = _t1687 - self.record_span(span_start910, "Conjunction") - return result911 + xs907 = [] + cond908 = self.match_lookahead_literal("(", 0) + while cond908: + _t1688 = self.parse_formula() + item909 = _t1688 + xs907.append(item909) + cond908 = self.match_lookahead_literal("(", 0) + formulas910 = xs907 + self.consume_literal(")") + _t1689 = logic_pb2.Conjunction(args=formulas910) + result912 = _t1689 + self.record_span(span_start911, "Conjunction") + return result912 def parse_disjunction(self) -> logic_pb2.Disjunction: - span_start916 = self.span_start() + span_start917 = self.span_start() self.consume_literal("(") self.consume_literal("or") - xs912 = [] - cond913 = self.match_lookahead_literal("(", 0) - while cond913: - _t1688 = self.parse_formula() - item914 = _t1688 - xs912.append(item914) - cond913 = self.match_lookahead_literal("(", 0) - formulas915 = xs912 - self.consume_literal(")") - _t1689 = logic_pb2.Disjunction(args=formulas915) - result917 = _t1689 - self.record_span(span_start916, "Disjunction") - return result917 + xs913 = [] + cond914 = self.match_lookahead_literal("(", 0) + while cond914: + _t1690 = self.parse_formula() + item915 = _t1690 + xs913.append(item915) + cond914 = self.match_lookahead_literal("(", 0) + formulas916 = xs913 + self.consume_literal(")") + _t1691 = logic_pb2.Disjunction(args=formulas916) + result918 = _t1691 + self.record_span(span_start917, "Disjunction") + return result918 def parse_not(self) -> logic_pb2.Not: - span_start919 = self.span_start() + span_start920 = self.span_start() self.consume_literal("(") self.consume_literal("not") - _t1690 = self.parse_formula() - formula918 = _t1690 + _t1692 = self.parse_formula() + formula919 = _t1692 self.consume_literal(")") - _t1691 = logic_pb2.Not(arg=formula918) - result920 = _t1691 - self.record_span(span_start919, "Not") - return result920 + _t1693 = logic_pb2.Not(arg=formula919) + result921 = _t1693 + self.record_span(span_start920, "Not") + return result921 def parse_ffi(self) -> logic_pb2.FFI: - span_start924 = self.span_start() + span_start925 = self.span_start() self.consume_literal("(") self.consume_literal("ffi") - _t1692 = self.parse_name() - name921 = _t1692 - _t1693 = self.parse_ffi_args() - ffi_args922 = _t1693 - _t1694 = self.parse_terms() - terms923 = _t1694 - self.consume_literal(")") - _t1695 = logic_pb2.FFI(name=name921, args=ffi_args922, terms=terms923) - result925 = _t1695 - self.record_span(span_start924, "FFI") - return result925 + _t1694 = self.parse_name() + name922 = _t1694 + _t1695 = self.parse_ffi_args() + ffi_args923 = _t1695 + _t1696 = self.parse_terms() + terms924 = _t1696 + self.consume_literal(")") + _t1697 = logic_pb2.FFI(name=name922, args=ffi_args923, terms=terms924) + result926 = _t1697 + self.record_span(span_start925, "FFI") + return result926 def parse_name(self) -> str: self.consume_literal(":") - symbol926 = self.consume_terminal("SYMBOL") - return symbol926 + symbol927 = self.consume_terminal("SYMBOL") + return symbol927 def parse_ffi_args(self) -> Sequence[logic_pb2.Abstraction]: self.consume_literal("(") self.consume_literal("args") - xs927 = [] - cond928 = self.match_lookahead_literal("(", 0) - while cond928: - _t1696 = self.parse_abstraction() - item929 = _t1696 - xs927.append(item929) - cond928 = self.match_lookahead_literal("(", 0) - abstractions930 = xs927 + xs928 = [] + cond929 = self.match_lookahead_literal("(", 0) + while cond929: + _t1698 = self.parse_abstraction() + item930 = _t1698 + xs928.append(item930) + cond929 = self.match_lookahead_literal("(", 0) + abstractions931 = xs928 self.consume_literal(")") - return abstractions930 + return abstractions931 def parse_atom(self) -> logic_pb2.Atom: - span_start936 = self.span_start() + span_start937 = self.span_start() self.consume_literal("(") self.consume_literal("atom") - _t1697 = self.parse_relation_id() - relation_id931 = _t1697 - xs932 = [] - cond933 = (((((((((((((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 cond933: - _t1698 = self.parse_term() - item934 = _t1698 - xs932.append(item934) - cond933 = (((((((((((((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)) - terms935 = xs932 - self.consume_literal(")") - _t1699 = logic_pb2.Atom(name=relation_id931, terms=terms935) - result937 = _t1699 - self.record_span(span_start936, "Atom") - return result937 + _t1699 = self.parse_relation_id() + relation_id932 = _t1699 + xs933 = [] + cond934 = (((((((((((((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 cond934: + _t1700 = self.parse_term() + item935 = _t1700 + xs933.append(item935) + cond934 = (((((((((((((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)) + terms936 = xs933 + self.consume_literal(")") + _t1701 = logic_pb2.Atom(name=relation_id932, terms=terms936) + result938 = _t1701 + self.record_span(span_start937, "Atom") + return result938 def parse_pragma(self) -> logic_pb2.Pragma: - span_start943 = self.span_start() + span_start944 = self.span_start() self.consume_literal("(") self.consume_literal("pragma") - _t1700 = self.parse_name() - name938 = _t1700 - xs939 = [] - cond940 = (((((((((((((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 cond940: - _t1701 = self.parse_term() - item941 = _t1701 - xs939.append(item941) - cond940 = (((((((((((((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)) - terms942 = xs939 - self.consume_literal(")") - _t1702 = logic_pb2.Pragma(name=name938, terms=terms942) - result944 = _t1702 - self.record_span(span_start943, "Pragma") - return result944 + _t1702 = self.parse_name() + name939 = _t1702 + xs940 = [] + cond941 = (((((((((((((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 cond941: + _t1703 = self.parse_term() + item942 = _t1703 + xs940.append(item942) + cond941 = (((((((((((((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)) + terms943 = xs940 + self.consume_literal(")") + _t1704 = logic_pb2.Pragma(name=name939, terms=terms943) + result945 = _t1704 + self.record_span(span_start944, "Pragma") + return result945 def parse_primitive(self) -> logic_pb2.Primitive: - span_start960 = self.span_start() + span_start961 = self.span_start() if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("primitive", 1): - _t1704 = 9 + _t1706 = 9 else: if self.match_lookahead_literal(">=", 1): - _t1705 = 4 + _t1707 = 4 else: if self.match_lookahead_literal(">", 1): - _t1706 = 3 + _t1708 = 3 else: if self.match_lookahead_literal("=", 1): - _t1707 = 0 + _t1709 = 0 else: if self.match_lookahead_literal("<=", 1): - _t1708 = 2 + _t1710 = 2 else: if self.match_lookahead_literal("<", 1): - _t1709 = 1 + _t1711 = 1 else: if self.match_lookahead_literal("/", 1): - _t1710 = 8 + _t1712 = 8 else: if self.match_lookahead_literal("-", 1): - _t1711 = 6 + _t1713 = 6 else: if self.match_lookahead_literal("+", 1): - _t1712 = 5 + _t1714 = 5 else: if self.match_lookahead_literal("*", 1): - _t1713 = 7 + _t1715 = 7 else: - _t1713 = -1 - _t1712 = _t1713 - _t1711 = _t1712 - _t1710 = _t1711 - _t1709 = _t1710 - _t1708 = _t1709 - _t1707 = _t1708 - _t1706 = _t1707 - _t1705 = _t1706 - _t1704 = _t1705 - _t1703 = _t1704 - else: - _t1703 = -1 - prediction945 = _t1703 - if prediction945 == 9: + _t1715 = -1 + _t1714 = _t1715 + _t1713 = _t1714 + _t1712 = _t1713 + _t1711 = _t1712 + _t1710 = _t1711 + _t1709 = _t1710 + _t1708 = _t1709 + _t1707 = _t1708 + _t1706 = _t1707 + _t1705 = _t1706 + else: + _t1705 = -1 + prediction946 = _t1705 + if prediction946 == 9: self.consume_literal("(") self.consume_literal("primitive") - _t1715 = self.parse_name() - name955 = _t1715 - xs956 = [] - cond957 = ((((((((((((((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 cond957: - _t1716 = self.parse_rel_term() - item958 = _t1716 - xs956.append(item958) - cond957 = ((((((((((((((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_terms959 = xs956 + _t1717 = self.parse_name() + name956 = _t1717 + xs957 = [] + cond958 = ((((((((((((((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 cond958: + _t1718 = self.parse_rel_term() + item959 = _t1718 + xs957.append(item959) + cond958 = ((((((((((((((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_terms960 = xs957 self.consume_literal(")") - _t1717 = logic_pb2.Primitive(name=name955, terms=rel_terms959) - _t1714 = _t1717 + _t1719 = logic_pb2.Primitive(name=name956, terms=rel_terms960) + _t1716 = _t1719 else: - if prediction945 == 8: - _t1719 = self.parse_divide() - divide954 = _t1719 - _t1718 = divide954 + if prediction946 == 8: + _t1721 = self.parse_divide() + divide955 = _t1721 + _t1720 = divide955 else: - if prediction945 == 7: - _t1721 = self.parse_multiply() - multiply953 = _t1721 - _t1720 = multiply953 + if prediction946 == 7: + _t1723 = self.parse_multiply() + multiply954 = _t1723 + _t1722 = multiply954 else: - if prediction945 == 6: - _t1723 = self.parse_minus() - minus952 = _t1723 - _t1722 = minus952 + if prediction946 == 6: + _t1725 = self.parse_minus() + minus953 = _t1725 + _t1724 = minus953 else: - if prediction945 == 5: - _t1725 = self.parse_add() - add951 = _t1725 - _t1724 = add951 + if prediction946 == 5: + _t1727 = self.parse_add() + add952 = _t1727 + _t1726 = add952 else: - if prediction945 == 4: - _t1727 = self.parse_gt_eq() - gt_eq950 = _t1727 - _t1726 = gt_eq950 + if prediction946 == 4: + _t1729 = self.parse_gt_eq() + gt_eq951 = _t1729 + _t1728 = gt_eq951 else: - if prediction945 == 3: - _t1729 = self.parse_gt() - gt949 = _t1729 - _t1728 = gt949 + if prediction946 == 3: + _t1731 = self.parse_gt() + gt950 = _t1731 + _t1730 = gt950 else: - if prediction945 == 2: - _t1731 = self.parse_lt_eq() - lt_eq948 = _t1731 - _t1730 = lt_eq948 + if prediction946 == 2: + _t1733 = self.parse_lt_eq() + lt_eq949 = _t1733 + _t1732 = lt_eq949 else: - if prediction945 == 1: - _t1733 = self.parse_lt() - lt947 = _t1733 - _t1732 = lt947 + if prediction946 == 1: + _t1735 = self.parse_lt() + lt948 = _t1735 + _t1734 = lt948 else: - if prediction945 == 0: - _t1735 = self.parse_eq() - eq946 = _t1735 - _t1734 = eq946 + if prediction946 == 0: + _t1737 = self.parse_eq() + eq947 = _t1737 + _t1736 = eq947 else: raise ParseError("Unexpected token in primitive" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1732 = _t1734 - _t1730 = _t1732 - _t1728 = _t1730 - _t1726 = _t1728 - _t1724 = _t1726 - _t1722 = _t1724 - _t1720 = _t1722 - _t1718 = _t1720 - _t1714 = _t1718 - result961 = _t1714 - self.record_span(span_start960, "Primitive") - return result961 + _t1734 = _t1736 + _t1732 = _t1734 + _t1730 = _t1732 + _t1728 = _t1730 + _t1726 = _t1728 + _t1724 = _t1726 + _t1722 = _t1724 + _t1720 = _t1722 + _t1716 = _t1720 + result962 = _t1716 + self.record_span(span_start961, "Primitive") + return result962 def parse_eq(self) -> logic_pb2.Primitive: - span_start964 = self.span_start() + span_start965 = self.span_start() self.consume_literal("(") self.consume_literal("=") - _t1736 = self.parse_term() - term962 = _t1736 - _t1737 = self.parse_term() - term_3963 = _t1737 - self.consume_literal(")") - _t1738 = logic_pb2.RelTerm(term=term962) - _t1739 = logic_pb2.RelTerm(term=term_3963) - _t1740 = logic_pb2.Primitive(name="rel_primitive_eq", terms=[_t1738, _t1739]) - result965 = _t1740 - self.record_span(span_start964, "Primitive") - return result965 + _t1738 = self.parse_term() + term963 = _t1738 + _t1739 = self.parse_term() + term_3964 = _t1739 + self.consume_literal(")") + _t1740 = logic_pb2.RelTerm(term=term963) + _t1741 = logic_pb2.RelTerm(term=term_3964) + _t1742 = logic_pb2.Primitive(name="rel_primitive_eq", terms=[_t1740, _t1741]) + result966 = _t1742 + self.record_span(span_start965, "Primitive") + return result966 def parse_lt(self) -> logic_pb2.Primitive: - span_start968 = self.span_start() + span_start969 = self.span_start() self.consume_literal("(") self.consume_literal("<") - _t1741 = self.parse_term() - term966 = _t1741 - _t1742 = self.parse_term() - term_3967 = _t1742 - self.consume_literal(")") - _t1743 = logic_pb2.RelTerm(term=term966) - _t1744 = logic_pb2.RelTerm(term=term_3967) - _t1745 = logic_pb2.Primitive(name="rel_primitive_lt_monotype", terms=[_t1743, _t1744]) - result969 = _t1745 - self.record_span(span_start968, "Primitive") - return result969 + _t1743 = self.parse_term() + term967 = _t1743 + _t1744 = self.parse_term() + term_3968 = _t1744 + self.consume_literal(")") + _t1745 = logic_pb2.RelTerm(term=term967) + _t1746 = logic_pb2.RelTerm(term=term_3968) + _t1747 = logic_pb2.Primitive(name="rel_primitive_lt_monotype", terms=[_t1745, _t1746]) + result970 = _t1747 + self.record_span(span_start969, "Primitive") + return result970 def parse_lt_eq(self) -> logic_pb2.Primitive: - span_start972 = self.span_start() + span_start973 = self.span_start() self.consume_literal("(") self.consume_literal("<=") - _t1746 = self.parse_term() - term970 = _t1746 - _t1747 = self.parse_term() - term_3971 = _t1747 - self.consume_literal(")") - _t1748 = logic_pb2.RelTerm(term=term970) - _t1749 = logic_pb2.RelTerm(term=term_3971) - _t1750 = logic_pb2.Primitive(name="rel_primitive_lt_eq_monotype", terms=[_t1748, _t1749]) - result973 = _t1750 - self.record_span(span_start972, "Primitive") - return result973 + _t1748 = self.parse_term() + term971 = _t1748 + _t1749 = self.parse_term() + term_3972 = _t1749 + self.consume_literal(")") + _t1750 = logic_pb2.RelTerm(term=term971) + _t1751 = logic_pb2.RelTerm(term=term_3972) + _t1752 = logic_pb2.Primitive(name="rel_primitive_lt_eq_monotype", terms=[_t1750, _t1751]) + result974 = _t1752 + self.record_span(span_start973, "Primitive") + return result974 def parse_gt(self) -> logic_pb2.Primitive: - span_start976 = self.span_start() + span_start977 = self.span_start() self.consume_literal("(") self.consume_literal(">") - _t1751 = self.parse_term() - term974 = _t1751 - _t1752 = self.parse_term() - term_3975 = _t1752 - self.consume_literal(")") - _t1753 = logic_pb2.RelTerm(term=term974) - _t1754 = logic_pb2.RelTerm(term=term_3975) - _t1755 = logic_pb2.Primitive(name="rel_primitive_gt_monotype", terms=[_t1753, _t1754]) - result977 = _t1755 - self.record_span(span_start976, "Primitive") - return result977 + _t1753 = self.parse_term() + term975 = _t1753 + _t1754 = self.parse_term() + term_3976 = _t1754 + self.consume_literal(")") + _t1755 = logic_pb2.RelTerm(term=term975) + _t1756 = logic_pb2.RelTerm(term=term_3976) + _t1757 = logic_pb2.Primitive(name="rel_primitive_gt_monotype", terms=[_t1755, _t1756]) + result978 = _t1757 + self.record_span(span_start977, "Primitive") + return result978 def parse_gt_eq(self) -> logic_pb2.Primitive: - span_start980 = self.span_start() + span_start981 = self.span_start() self.consume_literal("(") self.consume_literal(">=") - _t1756 = self.parse_term() - term978 = _t1756 - _t1757 = self.parse_term() - term_3979 = _t1757 - self.consume_literal(")") - _t1758 = logic_pb2.RelTerm(term=term978) - _t1759 = logic_pb2.RelTerm(term=term_3979) - _t1760 = logic_pb2.Primitive(name="rel_primitive_gt_eq_monotype", terms=[_t1758, _t1759]) - result981 = _t1760 - self.record_span(span_start980, "Primitive") - return result981 + _t1758 = self.parse_term() + term979 = _t1758 + _t1759 = self.parse_term() + term_3980 = _t1759 + self.consume_literal(")") + _t1760 = logic_pb2.RelTerm(term=term979) + _t1761 = logic_pb2.RelTerm(term=term_3980) + _t1762 = logic_pb2.Primitive(name="rel_primitive_gt_eq_monotype", terms=[_t1760, _t1761]) + result982 = _t1762 + self.record_span(span_start981, "Primitive") + return result982 def parse_add(self) -> logic_pb2.Primitive: - span_start985 = self.span_start() + span_start986 = self.span_start() self.consume_literal("(") self.consume_literal("+") - _t1761 = self.parse_term() - term982 = _t1761 - _t1762 = self.parse_term() - term_3983 = _t1762 _t1763 = self.parse_term() - term_4984 = _t1763 - self.consume_literal(")") - _t1764 = logic_pb2.RelTerm(term=term982) - _t1765 = logic_pb2.RelTerm(term=term_3983) - _t1766 = logic_pb2.RelTerm(term=term_4984) - _t1767 = logic_pb2.Primitive(name="rel_primitive_add_monotype", terms=[_t1764, _t1765, _t1766]) - result986 = _t1767 - self.record_span(span_start985, "Primitive") - return result986 + term983 = _t1763 + _t1764 = self.parse_term() + term_3984 = _t1764 + _t1765 = self.parse_term() + term_4985 = _t1765 + self.consume_literal(")") + _t1766 = logic_pb2.RelTerm(term=term983) + _t1767 = logic_pb2.RelTerm(term=term_3984) + _t1768 = logic_pb2.RelTerm(term=term_4985) + _t1769 = logic_pb2.Primitive(name="rel_primitive_add_monotype", terms=[_t1766, _t1767, _t1768]) + result987 = _t1769 + self.record_span(span_start986, "Primitive") + return result987 def parse_minus(self) -> logic_pb2.Primitive: - span_start990 = self.span_start() + span_start991 = self.span_start() self.consume_literal("(") self.consume_literal("-") - _t1768 = self.parse_term() - term987 = _t1768 - _t1769 = self.parse_term() - term_3988 = _t1769 _t1770 = self.parse_term() - term_4989 = _t1770 - self.consume_literal(")") - _t1771 = logic_pb2.RelTerm(term=term987) - _t1772 = logic_pb2.RelTerm(term=term_3988) - _t1773 = logic_pb2.RelTerm(term=term_4989) - _t1774 = logic_pb2.Primitive(name="rel_primitive_subtract_monotype", terms=[_t1771, _t1772, _t1773]) - result991 = _t1774 - self.record_span(span_start990, "Primitive") - return result991 + term988 = _t1770 + _t1771 = self.parse_term() + term_3989 = _t1771 + _t1772 = self.parse_term() + term_4990 = _t1772 + self.consume_literal(")") + _t1773 = logic_pb2.RelTerm(term=term988) + _t1774 = logic_pb2.RelTerm(term=term_3989) + _t1775 = logic_pb2.RelTerm(term=term_4990) + _t1776 = logic_pb2.Primitive(name="rel_primitive_subtract_monotype", terms=[_t1773, _t1774, _t1775]) + result992 = _t1776 + self.record_span(span_start991, "Primitive") + return result992 def parse_multiply(self) -> logic_pb2.Primitive: - span_start995 = self.span_start() + span_start996 = self.span_start() self.consume_literal("(") self.consume_literal("*") - _t1775 = self.parse_term() - term992 = _t1775 - _t1776 = self.parse_term() - term_3993 = _t1776 _t1777 = self.parse_term() - term_4994 = _t1777 - self.consume_literal(")") - _t1778 = logic_pb2.RelTerm(term=term992) - _t1779 = logic_pb2.RelTerm(term=term_3993) - _t1780 = logic_pb2.RelTerm(term=term_4994) - _t1781 = logic_pb2.Primitive(name="rel_primitive_multiply_monotype", terms=[_t1778, _t1779, _t1780]) - result996 = _t1781 - self.record_span(span_start995, "Primitive") - return result996 + term993 = _t1777 + _t1778 = self.parse_term() + term_3994 = _t1778 + _t1779 = self.parse_term() + term_4995 = _t1779 + self.consume_literal(")") + _t1780 = logic_pb2.RelTerm(term=term993) + _t1781 = logic_pb2.RelTerm(term=term_3994) + _t1782 = logic_pb2.RelTerm(term=term_4995) + _t1783 = logic_pb2.Primitive(name="rel_primitive_multiply_monotype", terms=[_t1780, _t1781, _t1782]) + result997 = _t1783 + self.record_span(span_start996, "Primitive") + return result997 def parse_divide(self) -> logic_pb2.Primitive: - span_start1000 = self.span_start() + span_start1001 = self.span_start() self.consume_literal("(") self.consume_literal("/") - _t1782 = self.parse_term() - term997 = _t1782 - _t1783 = self.parse_term() - term_3998 = _t1783 _t1784 = self.parse_term() - term_4999 = _t1784 - self.consume_literal(")") - _t1785 = logic_pb2.RelTerm(term=term997) - _t1786 = logic_pb2.RelTerm(term=term_3998) - _t1787 = logic_pb2.RelTerm(term=term_4999) - _t1788 = logic_pb2.Primitive(name="rel_primitive_divide_monotype", terms=[_t1785, _t1786, _t1787]) - result1001 = _t1788 - self.record_span(span_start1000, "Primitive") - return result1001 + term998 = _t1784 + _t1785 = self.parse_term() + term_3999 = _t1785 + _t1786 = self.parse_term() + term_41000 = _t1786 + self.consume_literal(")") + _t1787 = logic_pb2.RelTerm(term=term998) + _t1788 = logic_pb2.RelTerm(term=term_3999) + _t1789 = logic_pb2.RelTerm(term=term_41000) + _t1790 = logic_pb2.Primitive(name="rel_primitive_divide_monotype", terms=[_t1787, _t1788, _t1789]) + result1002 = _t1790 + self.record_span(span_start1001, "Primitive") + return result1002 def parse_rel_term(self) -> logic_pb2.RelTerm: - span_start1005 = self.span_start() + span_start1006 = self.span_start() if self.match_lookahead_literal("true", 0): - _t1789 = 1 + _t1791 = 1 else: if self.match_lookahead_literal("missing", 0): - _t1790 = 1 + _t1792 = 1 else: if self.match_lookahead_literal("false", 0): - _t1791 = 1 + _t1793 = 1 else: if self.match_lookahead_literal("(", 0): - _t1792 = 1 + _t1794 = 1 else: if self.match_lookahead_literal("#", 0): - _t1793 = 0 + _t1795 = 0 else: if self.match_lookahead_terminal("SYMBOL", 0): - _t1794 = 1 + _t1796 = 1 else: if self.match_lookahead_terminal("UINT32", 0): - _t1795 = 1 + _t1797 = 1 else: if self.match_lookahead_terminal("UINT128", 0): - _t1796 = 1 + _t1798 = 1 else: if self.match_lookahead_terminal("STRING", 0): - _t1797 = 1 + _t1799 = 1 else: if self.match_lookahead_terminal("INT32", 0): - _t1798 = 1 + _t1800 = 1 else: if self.match_lookahead_terminal("INT128", 0): - _t1799 = 1 + _t1801 = 1 else: if self.match_lookahead_terminal("INT", 0): - _t1800 = 1 + _t1802 = 1 else: if self.match_lookahead_terminal("FLOAT32", 0): - _t1801 = 1 + _t1803 = 1 else: if self.match_lookahead_terminal("FLOAT", 0): - _t1802 = 1 + _t1804 = 1 else: if self.match_lookahead_terminal("DECIMAL", 0): - _t1803 = 1 + _t1805 = 1 else: - _t1803 = -1 - _t1802 = _t1803 - _t1801 = _t1802 - _t1800 = _t1801 - _t1799 = _t1800 - _t1798 = _t1799 - _t1797 = _t1798 - _t1796 = _t1797 - _t1795 = _t1796 - _t1794 = _t1795 - _t1793 = _t1794 - _t1792 = _t1793 - _t1791 = _t1792 - _t1790 = _t1791 - _t1789 = _t1790 - prediction1002 = _t1789 - if prediction1002 == 1: - _t1805 = self.parse_term() - term1004 = _t1805 - _t1806 = logic_pb2.RelTerm(term=term1004) - _t1804 = _t1806 - else: - if prediction1002 == 0: - _t1808 = self.parse_specialized_value() - specialized_value1003 = _t1808 - _t1809 = logic_pb2.RelTerm(specialized_value=specialized_value1003) - _t1807 = _t1809 + _t1805 = -1 + _t1804 = _t1805 + _t1803 = _t1804 + _t1802 = _t1803 + _t1801 = _t1802 + _t1800 = _t1801 + _t1799 = _t1800 + _t1798 = _t1799 + _t1797 = _t1798 + _t1796 = _t1797 + _t1795 = _t1796 + _t1794 = _t1795 + _t1793 = _t1794 + _t1792 = _t1793 + _t1791 = _t1792 + prediction1003 = _t1791 + if prediction1003 == 1: + _t1807 = self.parse_term() + term1005 = _t1807 + _t1808 = logic_pb2.RelTerm(term=term1005) + _t1806 = _t1808 + else: + if prediction1003 == 0: + _t1810 = self.parse_specialized_value() + specialized_value1004 = _t1810 + _t1811 = logic_pb2.RelTerm(specialized_value=specialized_value1004) + _t1809 = _t1811 else: raise ParseError("Unexpected token in rel_term" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1804 = _t1807 - result1006 = _t1804 - self.record_span(span_start1005, "RelTerm") - return result1006 + _t1806 = _t1809 + result1007 = _t1806 + self.record_span(span_start1006, "RelTerm") + return result1007 def parse_specialized_value(self) -> logic_pb2.Value: - span_start1008 = self.span_start() + span_start1009 = self.span_start() self.consume_literal("#") - _t1810 = self.parse_raw_value() - raw_value1007 = _t1810 - result1009 = raw_value1007 - self.record_span(span_start1008, "Value") - return result1009 + _t1812 = self.parse_raw_value() + raw_value1008 = _t1812 + result1010 = raw_value1008 + self.record_span(span_start1009, "Value") + return result1010 def parse_rel_atom(self) -> logic_pb2.RelAtom: - span_start1015 = self.span_start() + span_start1016 = self.span_start() self.consume_literal("(") self.consume_literal("relatom") - _t1811 = self.parse_name() - name1010 = _t1811 - xs1011 = [] - cond1012 = ((((((((((((((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 cond1012: - _t1812 = self.parse_rel_term() - item1013 = _t1812 - xs1011.append(item1013) - cond1012 = ((((((((((((((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_terms1014 = xs1011 - self.consume_literal(")") - _t1813 = logic_pb2.RelAtom(name=name1010, terms=rel_terms1014) - result1016 = _t1813 - self.record_span(span_start1015, "RelAtom") - return result1016 + _t1813 = self.parse_name() + name1011 = _t1813 + xs1012 = [] + cond1013 = ((((((((((((((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 cond1013: + _t1814 = self.parse_rel_term() + item1014 = _t1814 + xs1012.append(item1014) + cond1013 = ((((((((((((((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_terms1015 = xs1012 + self.consume_literal(")") + _t1815 = logic_pb2.RelAtom(name=name1011, terms=rel_terms1015) + result1017 = _t1815 + self.record_span(span_start1016, "RelAtom") + return result1017 def parse_cast(self) -> logic_pb2.Cast: - span_start1019 = self.span_start() + span_start1020 = self.span_start() self.consume_literal("(") self.consume_literal("cast") - _t1814 = self.parse_term() - term1017 = _t1814 - _t1815 = self.parse_term() - term_31018 = _t1815 + _t1816 = self.parse_term() + term1018 = _t1816 + _t1817 = self.parse_term() + term_31019 = _t1817 self.consume_literal(")") - _t1816 = logic_pb2.Cast(input=term1017, result=term_31018) - result1020 = _t1816 - self.record_span(span_start1019, "Cast") - return result1020 + _t1818 = logic_pb2.Cast(input=term1018, result=term_31019) + result1021 = _t1818 + self.record_span(span_start1020, "Cast") + return result1021 def parse_attrs(self) -> Sequence[logic_pb2.Attribute]: self.consume_literal("(") self.consume_literal("attrs") - xs1021 = [] - cond1022 = self.match_lookahead_literal("(", 0) - while cond1022: - _t1817 = self.parse_attribute() - item1023 = _t1817 - xs1021.append(item1023) - cond1022 = self.match_lookahead_literal("(", 0) - attributes1024 = xs1021 + xs1022 = [] + cond1023 = self.match_lookahead_literal("(", 0) + while cond1023: + _t1819 = self.parse_attribute() + item1024 = _t1819 + xs1022.append(item1024) + cond1023 = self.match_lookahead_literal("(", 0) + attributes1025 = xs1022 self.consume_literal(")") - return attributes1024 + return attributes1025 def parse_attribute(self) -> logic_pb2.Attribute: - span_start1030 = self.span_start() + span_start1031 = self.span_start() self.consume_literal("(") self.consume_literal("attribute") - _t1818 = self.parse_name() - name1025 = _t1818 - xs1026 = [] - cond1027 = ((((((((((((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 cond1027: - _t1819 = self.parse_raw_value() - item1028 = _t1819 - xs1026.append(item1028) - cond1027 = ((((((((((((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_values1029 = xs1026 - self.consume_literal(")") - _t1820 = logic_pb2.Attribute(name=name1025, args=raw_values1029) - result1031 = _t1820 - self.record_span(span_start1030, "Attribute") - return result1031 + _t1820 = self.parse_name() + name1026 = _t1820 + xs1027 = [] + cond1028 = ((((((((((((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 cond1028: + _t1821 = self.parse_raw_value() + item1029 = _t1821 + xs1027.append(item1029) + cond1028 = ((((((((((((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_values1030 = xs1027 + self.consume_literal(")") + _t1822 = logic_pb2.Attribute(name=name1026, args=raw_values1030) + result1032 = _t1822 + self.record_span(span_start1031, "Attribute") + return result1032 def parse_algorithm(self) -> logic_pb2.Algorithm: - span_start1037 = self.span_start() + span_start1038 = self.span_start() self.consume_literal("(") self.consume_literal("algorithm") - xs1032 = [] - cond1033 = (self.match_lookahead_literal(":", 0) or self.match_lookahead_terminal("UINT128", 0)) - while cond1033: - _t1821 = self.parse_relation_id() - item1034 = _t1821 - xs1032.append(item1034) - cond1033 = (self.match_lookahead_literal(":", 0) or self.match_lookahead_terminal("UINT128", 0)) - relation_ids1035 = xs1032 - _t1822 = self.parse_script() - script1036 = _t1822 - self.consume_literal(")") - _t1823 = logic_pb2.Algorithm(body=script1036) - getattr(_t1823, 'global').extend(relation_ids1035) - result1038 = _t1823 - self.record_span(span_start1037, "Algorithm") - return result1038 + xs1033 = [] + cond1034 = (self.match_lookahead_literal(":", 0) or self.match_lookahead_terminal("UINT128", 0)) + while cond1034: + _t1823 = self.parse_relation_id() + item1035 = _t1823 + xs1033.append(item1035) + cond1034 = (self.match_lookahead_literal(":", 0) or self.match_lookahead_terminal("UINT128", 0)) + relation_ids1036 = xs1033 + _t1824 = self.parse_script() + script1037 = _t1824 + self.consume_literal(")") + _t1825 = logic_pb2.Algorithm(body=script1037) + getattr(_t1825, 'global').extend(relation_ids1036) + result1039 = _t1825 + self.record_span(span_start1038, "Algorithm") + return result1039 def parse_script(self) -> logic_pb2.Script: - span_start1043 = self.span_start() + span_start1044 = self.span_start() self.consume_literal("(") self.consume_literal("script") - xs1039 = [] - cond1040 = self.match_lookahead_literal("(", 0) - while cond1040: - _t1824 = self.parse_construct() - item1041 = _t1824 - xs1039.append(item1041) - cond1040 = self.match_lookahead_literal("(", 0) - constructs1042 = xs1039 - self.consume_literal(")") - _t1825 = logic_pb2.Script(constructs=constructs1042) - result1044 = _t1825 - self.record_span(span_start1043, "Script") - return result1044 + xs1040 = [] + cond1041 = self.match_lookahead_literal("(", 0) + while cond1041: + _t1826 = self.parse_construct() + item1042 = _t1826 + xs1040.append(item1042) + cond1041 = self.match_lookahead_literal("(", 0) + constructs1043 = xs1040 + self.consume_literal(")") + _t1827 = logic_pb2.Script(constructs=constructs1043) + result1045 = _t1827 + self.record_span(span_start1044, "Script") + return result1045 def parse_construct(self) -> logic_pb2.Construct: - span_start1048 = self.span_start() + span_start1049 = self.span_start() if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("upsert", 1): - _t1827 = 1 + _t1829 = 1 else: if self.match_lookahead_literal("monus", 1): - _t1828 = 1 + _t1830 = 1 else: if self.match_lookahead_literal("monoid", 1): - _t1829 = 1 + _t1831 = 1 else: if self.match_lookahead_literal("loop", 1): - _t1830 = 0 + _t1832 = 0 else: if self.match_lookahead_literal("break", 1): - _t1831 = 1 + _t1833 = 1 else: if self.match_lookahead_literal("assign", 1): - _t1832 = 1 + _t1834 = 1 else: - _t1832 = -1 - _t1831 = _t1832 - _t1830 = _t1831 - _t1829 = _t1830 - _t1828 = _t1829 - _t1827 = _t1828 - _t1826 = _t1827 - else: - _t1826 = -1 - prediction1045 = _t1826 - if prediction1045 == 1: - _t1834 = self.parse_instruction() - instruction1047 = _t1834 - _t1835 = logic_pb2.Construct(instruction=instruction1047) - _t1833 = _t1835 - else: - if prediction1045 == 0: - _t1837 = self.parse_loop() - loop1046 = _t1837 - _t1838 = logic_pb2.Construct(loop=loop1046) - _t1836 = _t1838 + _t1834 = -1 + _t1833 = _t1834 + _t1832 = _t1833 + _t1831 = _t1832 + _t1830 = _t1831 + _t1829 = _t1830 + _t1828 = _t1829 + else: + _t1828 = -1 + prediction1046 = _t1828 + if prediction1046 == 1: + _t1836 = self.parse_instruction() + instruction1048 = _t1836 + _t1837 = logic_pb2.Construct(instruction=instruction1048) + _t1835 = _t1837 + else: + if prediction1046 == 0: + _t1839 = self.parse_loop() + loop1047 = _t1839 + _t1840 = logic_pb2.Construct(loop=loop1047) + _t1838 = _t1840 else: raise ParseError("Unexpected token in construct" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1833 = _t1836 - result1049 = _t1833 - self.record_span(span_start1048, "Construct") - return result1049 + _t1835 = _t1838 + result1050 = _t1835 + self.record_span(span_start1049, "Construct") + return result1050 def parse_loop(self) -> logic_pb2.Loop: - span_start1052 = self.span_start() + span_start1053 = self.span_start() self.consume_literal("(") self.consume_literal("loop") - _t1839 = self.parse_init() - init1050 = _t1839 - _t1840 = self.parse_script() - script1051 = _t1840 + _t1841 = self.parse_init() + init1051 = _t1841 + _t1842 = self.parse_script() + script1052 = _t1842 self.consume_literal(")") - _t1841 = logic_pb2.Loop(init=init1050, body=script1051) - result1053 = _t1841 - self.record_span(span_start1052, "Loop") - return result1053 + _t1843 = logic_pb2.Loop(init=init1051, body=script1052) + result1054 = _t1843 + self.record_span(span_start1053, "Loop") + return result1054 def parse_init(self) -> Sequence[logic_pb2.Instruction]: self.consume_literal("(") self.consume_literal("init") - xs1054 = [] - cond1055 = self.match_lookahead_literal("(", 0) - while cond1055: - _t1842 = self.parse_instruction() - item1056 = _t1842 - xs1054.append(item1056) - cond1055 = self.match_lookahead_literal("(", 0) - instructions1057 = xs1054 + xs1055 = [] + cond1056 = self.match_lookahead_literal("(", 0) + while cond1056: + _t1844 = self.parse_instruction() + item1057 = _t1844 + xs1055.append(item1057) + cond1056 = self.match_lookahead_literal("(", 0) + instructions1058 = xs1055 self.consume_literal(")") - return instructions1057 + return instructions1058 def parse_instruction(self) -> logic_pb2.Instruction: - span_start1064 = self.span_start() + span_start1065 = self.span_start() if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("upsert", 1): - _t1844 = 1 + _t1846 = 1 else: if self.match_lookahead_literal("monus", 1): - _t1845 = 4 + _t1847 = 4 else: if self.match_lookahead_literal("monoid", 1): - _t1846 = 3 + _t1848 = 3 else: if self.match_lookahead_literal("break", 1): - _t1847 = 2 + _t1849 = 2 else: if self.match_lookahead_literal("assign", 1): - _t1848 = 0 + _t1850 = 0 else: - _t1848 = -1 - _t1847 = _t1848 - _t1846 = _t1847 - _t1845 = _t1846 - _t1844 = _t1845 - _t1843 = _t1844 - else: - _t1843 = -1 - prediction1058 = _t1843 - if prediction1058 == 4: - _t1850 = self.parse_monus_def() - monus_def1063 = _t1850 - _t1851 = logic_pb2.Instruction(monus_def=monus_def1063) - _t1849 = _t1851 - else: - if prediction1058 == 3: - _t1853 = self.parse_monoid_def() - monoid_def1062 = _t1853 - _t1854 = logic_pb2.Instruction(monoid_def=monoid_def1062) - _t1852 = _t1854 + _t1850 = -1 + _t1849 = _t1850 + _t1848 = _t1849 + _t1847 = _t1848 + _t1846 = _t1847 + _t1845 = _t1846 + else: + _t1845 = -1 + prediction1059 = _t1845 + if prediction1059 == 4: + _t1852 = self.parse_monus_def() + monus_def1064 = _t1852 + _t1853 = logic_pb2.Instruction(monus_def=monus_def1064) + _t1851 = _t1853 + else: + if prediction1059 == 3: + _t1855 = self.parse_monoid_def() + monoid_def1063 = _t1855 + _t1856 = logic_pb2.Instruction(monoid_def=monoid_def1063) + _t1854 = _t1856 else: - if prediction1058 == 2: - _t1856 = self.parse_break() - break1061 = _t1856 - _t1857 = logic_pb2.Instruction() - getattr(_t1857, 'break').CopyFrom(break1061) - _t1855 = _t1857 + if prediction1059 == 2: + _t1858 = self.parse_break() + break1062 = _t1858 + _t1859 = logic_pb2.Instruction() + getattr(_t1859, 'break').CopyFrom(break1062) + _t1857 = _t1859 else: - if prediction1058 == 1: - _t1859 = self.parse_upsert() - upsert1060 = _t1859 - _t1860 = logic_pb2.Instruction(upsert=upsert1060) - _t1858 = _t1860 + if prediction1059 == 1: + _t1861 = self.parse_upsert() + upsert1061 = _t1861 + _t1862 = logic_pb2.Instruction(upsert=upsert1061) + _t1860 = _t1862 else: - if prediction1058 == 0: - _t1862 = self.parse_assign() - assign1059 = _t1862 - _t1863 = logic_pb2.Instruction(assign=assign1059) - _t1861 = _t1863 + if prediction1059 == 0: + _t1864 = self.parse_assign() + assign1060 = _t1864 + _t1865 = logic_pb2.Instruction(assign=assign1060) + _t1863 = _t1865 else: raise ParseError("Unexpected token in instruction" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1858 = _t1861 - _t1855 = _t1858 - _t1852 = _t1855 - _t1849 = _t1852 - result1065 = _t1849 - self.record_span(span_start1064, "Instruction") - return result1065 + _t1860 = _t1863 + _t1857 = _t1860 + _t1854 = _t1857 + _t1851 = _t1854 + result1066 = _t1851 + self.record_span(span_start1065, "Instruction") + return result1066 def parse_assign(self) -> logic_pb2.Assign: - span_start1069 = self.span_start() + span_start1070 = self.span_start() self.consume_literal("(") self.consume_literal("assign") - _t1864 = self.parse_relation_id() - relation_id1066 = _t1864 - _t1865 = self.parse_abstraction() - abstraction1067 = _t1865 + _t1866 = self.parse_relation_id() + relation_id1067 = _t1866 + _t1867 = self.parse_abstraction() + abstraction1068 = _t1867 if self.match_lookahead_literal("(", 0): - _t1867 = self.parse_attrs() - _t1866 = _t1867 + _t1869 = self.parse_attrs() + _t1868 = _t1869 else: - _t1866 = None - attrs1068 = _t1866 + _t1868 = None + attrs1069 = _t1868 self.consume_literal(")") - _t1868 = logic_pb2.Assign(name=relation_id1066, body=abstraction1067, attrs=(attrs1068 if attrs1068 is not None else [])) - result1070 = _t1868 - self.record_span(span_start1069, "Assign") - return result1070 + _t1870 = logic_pb2.Assign(name=relation_id1067, body=abstraction1068, attrs=(attrs1069 if attrs1069 is not None else [])) + result1071 = _t1870 + self.record_span(span_start1070, "Assign") + return result1071 def parse_upsert(self) -> logic_pb2.Upsert: - span_start1074 = self.span_start() + span_start1075 = self.span_start() self.consume_literal("(") self.consume_literal("upsert") - _t1869 = self.parse_relation_id() - relation_id1071 = _t1869 - _t1870 = self.parse_abstraction_with_arity() - abstraction_with_arity1072 = _t1870 + _t1871 = self.parse_relation_id() + relation_id1072 = _t1871 + _t1872 = self.parse_abstraction_with_arity() + abstraction_with_arity1073 = _t1872 if self.match_lookahead_literal("(", 0): - _t1872 = self.parse_attrs() - _t1871 = _t1872 + _t1874 = self.parse_attrs() + _t1873 = _t1874 else: - _t1871 = None - attrs1073 = _t1871 + _t1873 = None + attrs1074 = _t1873 self.consume_literal(")") - _t1873 = logic_pb2.Upsert(name=relation_id1071, body=abstraction_with_arity1072[0], attrs=(attrs1073 if attrs1073 is not None else []), value_arity=abstraction_with_arity1072[1]) - result1075 = _t1873 - self.record_span(span_start1074, "Upsert") - return result1075 + _t1875 = logic_pb2.Upsert(name=relation_id1072, body=abstraction_with_arity1073[0], attrs=(attrs1074 if attrs1074 is not None else []), value_arity=abstraction_with_arity1073[1]) + result1076 = _t1875 + self.record_span(span_start1075, "Upsert") + return result1076 def parse_abstraction_with_arity(self) -> tuple[logic_pb2.Abstraction, int]: self.consume_literal("(") - _t1874 = self.parse_bindings() - bindings1076 = _t1874 - _t1875 = self.parse_formula() - formula1077 = _t1875 + _t1876 = self.parse_bindings() + bindings1077 = _t1876 + _t1877 = self.parse_formula() + formula1078 = _t1877 self.consume_literal(")") - _t1876 = logic_pb2.Abstraction(vars=(list(bindings1076[0]) + list(bindings1076[1] if bindings1076[1] is not None else [])), value=formula1077) - return (_t1876, len(bindings1076[1]),) + _t1878 = logic_pb2.Abstraction(vars=(list(bindings1077[0]) + list(bindings1077[1] if bindings1077[1] is not None else [])), value=formula1078) + return (_t1878, len(bindings1077[1]),) def parse_break(self) -> logic_pb2.Break: - span_start1081 = self.span_start() + span_start1082 = self.span_start() self.consume_literal("(") self.consume_literal("break") - _t1877 = self.parse_relation_id() - relation_id1078 = _t1877 - _t1878 = self.parse_abstraction() - abstraction1079 = _t1878 + _t1879 = self.parse_relation_id() + relation_id1079 = _t1879 + _t1880 = self.parse_abstraction() + abstraction1080 = _t1880 if self.match_lookahead_literal("(", 0): - _t1880 = self.parse_attrs() - _t1879 = _t1880 + _t1882 = self.parse_attrs() + _t1881 = _t1882 else: - _t1879 = None - attrs1080 = _t1879 + _t1881 = None + attrs1081 = _t1881 self.consume_literal(")") - _t1881 = logic_pb2.Break(name=relation_id1078, body=abstraction1079, attrs=(attrs1080 if attrs1080 is not None else [])) - result1082 = _t1881 - self.record_span(span_start1081, "Break") - return result1082 + _t1883 = logic_pb2.Break(name=relation_id1079, body=abstraction1080, attrs=(attrs1081 if attrs1081 is not None else [])) + result1083 = _t1883 + self.record_span(span_start1082, "Break") + return result1083 def parse_monoid_def(self) -> logic_pb2.MonoidDef: - span_start1087 = self.span_start() + span_start1088 = self.span_start() self.consume_literal("(") self.consume_literal("monoid") - _t1882 = self.parse_monoid() - monoid1083 = _t1882 - _t1883 = self.parse_relation_id() - relation_id1084 = _t1883 - _t1884 = self.parse_abstraction_with_arity() - abstraction_with_arity1085 = _t1884 + _t1884 = self.parse_monoid() + monoid1084 = _t1884 + _t1885 = self.parse_relation_id() + relation_id1085 = _t1885 + _t1886 = self.parse_abstraction_with_arity() + abstraction_with_arity1086 = _t1886 if self.match_lookahead_literal("(", 0): - _t1886 = self.parse_attrs() - _t1885 = _t1886 + _t1888 = self.parse_attrs() + _t1887 = _t1888 else: - _t1885 = None - attrs1086 = _t1885 + _t1887 = None + attrs1087 = _t1887 self.consume_literal(")") - _t1887 = logic_pb2.MonoidDef(monoid=monoid1083, name=relation_id1084, body=abstraction_with_arity1085[0], attrs=(attrs1086 if attrs1086 is not None else []), value_arity=abstraction_with_arity1085[1]) - result1088 = _t1887 - self.record_span(span_start1087, "MonoidDef") - return result1088 + _t1889 = logic_pb2.MonoidDef(monoid=monoid1084, name=relation_id1085, body=abstraction_with_arity1086[0], attrs=(attrs1087 if attrs1087 is not None else []), value_arity=abstraction_with_arity1086[1]) + result1089 = _t1889 + self.record_span(span_start1088, "MonoidDef") + return result1089 def parse_monoid(self) -> logic_pb2.Monoid: - span_start1094 = self.span_start() + span_start1095 = self.span_start() if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("sum", 1): - _t1889 = 3 + _t1891 = 3 else: if self.match_lookahead_literal("or", 1): - _t1890 = 0 + _t1892 = 0 else: if self.match_lookahead_literal("min", 1): - _t1891 = 1 + _t1893 = 1 else: if self.match_lookahead_literal("max", 1): - _t1892 = 2 + _t1894 = 2 else: - _t1892 = -1 - _t1891 = _t1892 - _t1890 = _t1891 - _t1889 = _t1890 - _t1888 = _t1889 - else: - _t1888 = -1 - prediction1089 = _t1888 - if prediction1089 == 3: - _t1894 = self.parse_sum_monoid() - sum_monoid1093 = _t1894 - _t1895 = logic_pb2.Monoid(sum_monoid=sum_monoid1093) - _t1893 = _t1895 - else: - if prediction1089 == 2: - _t1897 = self.parse_max_monoid() - max_monoid1092 = _t1897 - _t1898 = logic_pb2.Monoid(max_monoid=max_monoid1092) - _t1896 = _t1898 + _t1894 = -1 + _t1893 = _t1894 + _t1892 = _t1893 + _t1891 = _t1892 + _t1890 = _t1891 + else: + _t1890 = -1 + prediction1090 = _t1890 + if prediction1090 == 3: + _t1896 = self.parse_sum_monoid() + sum_monoid1094 = _t1896 + _t1897 = logic_pb2.Monoid(sum_monoid=sum_monoid1094) + _t1895 = _t1897 + else: + if prediction1090 == 2: + _t1899 = self.parse_max_monoid() + max_monoid1093 = _t1899 + _t1900 = logic_pb2.Monoid(max_monoid=max_monoid1093) + _t1898 = _t1900 else: - if prediction1089 == 1: - _t1900 = self.parse_min_monoid() - min_monoid1091 = _t1900 - _t1901 = logic_pb2.Monoid(min_monoid=min_monoid1091) - _t1899 = _t1901 + if prediction1090 == 1: + _t1902 = self.parse_min_monoid() + min_monoid1092 = _t1902 + _t1903 = logic_pb2.Monoid(min_monoid=min_monoid1092) + _t1901 = _t1903 else: - if prediction1089 == 0: - _t1903 = self.parse_or_monoid() - or_monoid1090 = _t1903 - _t1904 = logic_pb2.Monoid(or_monoid=or_monoid1090) - _t1902 = _t1904 + if prediction1090 == 0: + _t1905 = self.parse_or_monoid() + or_monoid1091 = _t1905 + _t1906 = logic_pb2.Monoid(or_monoid=or_monoid1091) + _t1904 = _t1906 else: raise ParseError("Unexpected token in monoid" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1899 = _t1902 - _t1896 = _t1899 - _t1893 = _t1896 - result1095 = _t1893 - self.record_span(span_start1094, "Monoid") - return result1095 + _t1901 = _t1904 + _t1898 = _t1901 + _t1895 = _t1898 + result1096 = _t1895 + self.record_span(span_start1095, "Monoid") + return result1096 def parse_or_monoid(self) -> logic_pb2.OrMonoid: - span_start1096 = self.span_start() + span_start1097 = self.span_start() self.consume_literal("(") self.consume_literal("or") self.consume_literal(")") - _t1905 = logic_pb2.OrMonoid() - result1097 = _t1905 - self.record_span(span_start1096, "OrMonoid") - return result1097 + _t1907 = logic_pb2.OrMonoid() + result1098 = _t1907 + self.record_span(span_start1097, "OrMonoid") + return result1098 def parse_min_monoid(self) -> logic_pb2.MinMonoid: - span_start1099 = self.span_start() + span_start1100 = self.span_start() self.consume_literal("(") self.consume_literal("min") - _t1906 = self.parse_type() - type1098 = _t1906 + _t1908 = self.parse_type() + type1099 = _t1908 self.consume_literal(")") - _t1907 = logic_pb2.MinMonoid(type=type1098) - result1100 = _t1907 - self.record_span(span_start1099, "MinMonoid") - return result1100 + _t1909 = logic_pb2.MinMonoid(type=type1099) + result1101 = _t1909 + self.record_span(span_start1100, "MinMonoid") + return result1101 def parse_max_monoid(self) -> logic_pb2.MaxMonoid: - span_start1102 = self.span_start() + span_start1103 = self.span_start() self.consume_literal("(") self.consume_literal("max") - _t1908 = self.parse_type() - type1101 = _t1908 + _t1910 = self.parse_type() + type1102 = _t1910 self.consume_literal(")") - _t1909 = logic_pb2.MaxMonoid(type=type1101) - result1103 = _t1909 - self.record_span(span_start1102, "MaxMonoid") - return result1103 + _t1911 = logic_pb2.MaxMonoid(type=type1102) + result1104 = _t1911 + self.record_span(span_start1103, "MaxMonoid") + return result1104 def parse_sum_monoid(self) -> logic_pb2.SumMonoid: - span_start1105 = self.span_start() + span_start1106 = self.span_start() self.consume_literal("(") self.consume_literal("sum") - _t1910 = self.parse_type() - type1104 = _t1910 + _t1912 = self.parse_type() + type1105 = _t1912 self.consume_literal(")") - _t1911 = logic_pb2.SumMonoid(type=type1104) - result1106 = _t1911 - self.record_span(span_start1105, "SumMonoid") - return result1106 + _t1913 = logic_pb2.SumMonoid(type=type1105) + result1107 = _t1913 + self.record_span(span_start1106, "SumMonoid") + return result1107 def parse_monus_def(self) -> logic_pb2.MonusDef: - span_start1111 = self.span_start() + span_start1112 = self.span_start() self.consume_literal("(") self.consume_literal("monus") - _t1912 = self.parse_monoid() - monoid1107 = _t1912 - _t1913 = self.parse_relation_id() - relation_id1108 = _t1913 - _t1914 = self.parse_abstraction_with_arity() - abstraction_with_arity1109 = _t1914 + _t1914 = self.parse_monoid() + monoid1108 = _t1914 + _t1915 = self.parse_relation_id() + relation_id1109 = _t1915 + _t1916 = self.parse_abstraction_with_arity() + abstraction_with_arity1110 = _t1916 if self.match_lookahead_literal("(", 0): - _t1916 = self.parse_attrs() - _t1915 = _t1916 + _t1918 = self.parse_attrs() + _t1917 = _t1918 else: - _t1915 = None - attrs1110 = _t1915 + _t1917 = None + attrs1111 = _t1917 self.consume_literal(")") - _t1917 = logic_pb2.MonusDef(monoid=monoid1107, name=relation_id1108, body=abstraction_with_arity1109[0], attrs=(attrs1110 if attrs1110 is not None else []), value_arity=abstraction_with_arity1109[1]) - result1112 = _t1917 - self.record_span(span_start1111, "MonusDef") - return result1112 + _t1919 = logic_pb2.MonusDef(monoid=monoid1108, name=relation_id1109, body=abstraction_with_arity1110[0], attrs=(attrs1111 if attrs1111 is not None else []), value_arity=abstraction_with_arity1110[1]) + result1113 = _t1919 + self.record_span(span_start1112, "MonusDef") + return result1113 def parse_constraint(self) -> logic_pb2.Constraint: - span_start1117 = self.span_start() + span_start1118 = self.span_start() self.consume_literal("(") self.consume_literal("functional_dependency") - _t1918 = self.parse_relation_id() - relation_id1113 = _t1918 - _t1919 = self.parse_abstraction() - abstraction1114 = _t1919 - _t1920 = self.parse_functional_dependency_keys() - functional_dependency_keys1115 = _t1920 - _t1921 = self.parse_functional_dependency_values() - functional_dependency_values1116 = _t1921 - self.consume_literal(")") - _t1922 = logic_pb2.FunctionalDependency(guard=abstraction1114, keys=functional_dependency_keys1115, values=functional_dependency_values1116) - _t1923 = logic_pb2.Constraint(name=relation_id1113, functional_dependency=_t1922) - result1118 = _t1923 - self.record_span(span_start1117, "Constraint") - return result1118 + _t1920 = self.parse_relation_id() + relation_id1114 = _t1920 + _t1921 = self.parse_abstraction() + abstraction1115 = _t1921 + _t1922 = self.parse_functional_dependency_keys() + functional_dependency_keys1116 = _t1922 + _t1923 = self.parse_functional_dependency_values() + functional_dependency_values1117 = _t1923 + self.consume_literal(")") + _t1924 = logic_pb2.FunctionalDependency(guard=abstraction1115, keys=functional_dependency_keys1116, values=functional_dependency_values1117) + _t1925 = logic_pb2.Constraint(name=relation_id1114, functional_dependency=_t1924) + result1119 = _t1925 + self.record_span(span_start1118, "Constraint") + return result1119 def parse_functional_dependency_keys(self) -> Sequence[logic_pb2.Var]: self.consume_literal("(") self.consume_literal("keys") - xs1119 = [] - cond1120 = self.match_lookahead_terminal("SYMBOL", 0) - while cond1120: - _t1924 = self.parse_var() - item1121 = _t1924 - xs1119.append(item1121) - cond1120 = self.match_lookahead_terminal("SYMBOL", 0) - vars1122 = xs1119 + xs1120 = [] + cond1121 = self.match_lookahead_terminal("SYMBOL", 0) + while cond1121: + _t1926 = self.parse_var() + item1122 = _t1926 + xs1120.append(item1122) + cond1121 = self.match_lookahead_terminal("SYMBOL", 0) + vars1123 = xs1120 self.consume_literal(")") - return vars1122 + return vars1123 def parse_functional_dependency_values(self) -> Sequence[logic_pb2.Var]: self.consume_literal("(") self.consume_literal("values") - xs1123 = [] - cond1124 = self.match_lookahead_terminal("SYMBOL", 0) - while cond1124: - _t1925 = self.parse_var() - item1125 = _t1925 - xs1123.append(item1125) - cond1124 = self.match_lookahead_terminal("SYMBOL", 0) - vars1126 = xs1123 + xs1124 = [] + cond1125 = self.match_lookahead_terminal("SYMBOL", 0) + while cond1125: + _t1927 = self.parse_var() + item1126 = _t1927 + xs1124.append(item1126) + cond1125 = self.match_lookahead_terminal("SYMBOL", 0) + vars1127 = xs1124 self.consume_literal(")") - return vars1126 + return vars1127 def parse_data(self) -> logic_pb2.Data: - span_start1132 = self.span_start() + span_start1133 = self.span_start() if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("iceberg_data", 1): - _t1927 = 3 + _t1929 = 3 else: if self.match_lookahead_literal("edb", 1): - _t1928 = 0 + _t1930 = 0 else: if self.match_lookahead_literal("csv_data", 1): - _t1929 = 2 + _t1931 = 2 else: if self.match_lookahead_literal("betree_relation", 1): - _t1930 = 1 + _t1932 = 1 else: - _t1930 = -1 - _t1929 = _t1930 - _t1928 = _t1929 - _t1927 = _t1928 - _t1926 = _t1927 - else: - _t1926 = -1 - prediction1127 = _t1926 - if prediction1127 == 3: - _t1932 = self.parse_iceberg_data() - iceberg_data1131 = _t1932 - _t1933 = logic_pb2.Data(iceberg_data=iceberg_data1131) - _t1931 = _t1933 - else: - if prediction1127 == 2: - _t1935 = self.parse_csv_data() - csv_data1130 = _t1935 - _t1936 = logic_pb2.Data(csv_data=csv_data1130) - _t1934 = _t1936 + _t1932 = -1 + _t1931 = _t1932 + _t1930 = _t1931 + _t1929 = _t1930 + _t1928 = _t1929 + else: + _t1928 = -1 + prediction1128 = _t1928 + if prediction1128 == 3: + _t1934 = self.parse_iceberg_data() + iceberg_data1132 = _t1934 + _t1935 = logic_pb2.Data(iceberg_data=iceberg_data1132) + _t1933 = _t1935 + else: + if prediction1128 == 2: + _t1937 = self.parse_csv_data() + csv_data1131 = _t1937 + _t1938 = logic_pb2.Data(csv_data=csv_data1131) + _t1936 = _t1938 else: - if prediction1127 == 1: - _t1938 = self.parse_betree_relation() - betree_relation1129 = _t1938 - _t1939 = logic_pb2.Data(betree_relation=betree_relation1129) - _t1937 = _t1939 + if prediction1128 == 1: + _t1940 = self.parse_betree_relation() + betree_relation1130 = _t1940 + _t1941 = logic_pb2.Data(betree_relation=betree_relation1130) + _t1939 = _t1941 else: - if prediction1127 == 0: - _t1941 = self.parse_edb() - edb1128 = _t1941 - _t1942 = logic_pb2.Data(edb=edb1128) - _t1940 = _t1942 + if prediction1128 == 0: + _t1943 = self.parse_edb() + edb1129 = _t1943 + _t1944 = logic_pb2.Data(edb=edb1129) + _t1942 = _t1944 else: raise ParseError("Unexpected token in data" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1937 = _t1940 - _t1934 = _t1937 - _t1931 = _t1934 - result1133 = _t1931 - self.record_span(span_start1132, "Data") - return result1133 + _t1939 = _t1942 + _t1936 = _t1939 + _t1933 = _t1936 + result1134 = _t1933 + self.record_span(span_start1133, "Data") + return result1134 def parse_edb(self) -> logic_pb2.EDB: - span_start1137 = self.span_start() + span_start1138 = self.span_start() self.consume_literal("(") self.consume_literal("edb") - _t1943 = self.parse_relation_id() - relation_id1134 = _t1943 - _t1944 = self.parse_edb_path() - edb_path1135 = _t1944 - _t1945 = self.parse_edb_types() - edb_types1136 = _t1945 - self.consume_literal(")") - _t1946 = logic_pb2.EDB(target_id=relation_id1134, path=edb_path1135, types=edb_types1136) - result1138 = _t1946 - self.record_span(span_start1137, "EDB") - return result1138 + _t1945 = self.parse_relation_id() + relation_id1135 = _t1945 + _t1946 = self.parse_edb_path() + edb_path1136 = _t1946 + _t1947 = self.parse_edb_types() + edb_types1137 = _t1947 + self.consume_literal(")") + _t1948 = logic_pb2.EDB(target_id=relation_id1135, path=edb_path1136, types=edb_types1137) + result1139 = _t1948 + self.record_span(span_start1138, "EDB") + return result1139 def parse_edb_path(self) -> Sequence[str]: self.consume_literal("[") - xs1139 = [] - cond1140 = self.match_lookahead_terminal("STRING", 0) - while cond1140: - item1141 = self.consume_terminal("STRING") - xs1139.append(item1141) - cond1140 = self.match_lookahead_terminal("STRING", 0) - strings1142 = xs1139 + xs1140 = [] + cond1141 = self.match_lookahead_terminal("STRING", 0) + while cond1141: + item1142 = self.consume_terminal("STRING") + xs1140.append(item1142) + cond1141 = self.match_lookahead_terminal("STRING", 0) + strings1143 = xs1140 self.consume_literal("]") - return strings1142 + return strings1143 def parse_edb_types(self) -> Sequence[logic_pb2.Type]: self.consume_literal("[") - xs1143 = [] - cond1144 = (((((((((((((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 cond1144: - _t1947 = self.parse_type() - item1145 = _t1947 - xs1143.append(item1145) - cond1144 = (((((((((((((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)) - types1146 = xs1143 + xs1144 = [] + cond1145 = (((((((((((((self.match_lookahead_literal("(", 0) or self.match_lookahead_literal("BOOLEAN", 0)) or self.match_lookahead_literal("DATE", 0)) or self.match_lookahead_literal("DATETIME", 0)) or self.match_lookahead_literal("FLOAT", 0)) or self.match_lookahead_literal("FLOAT32", 0)) or self.match_lookahead_literal("INT", 0)) or self.match_lookahead_literal("INT128", 0)) or self.match_lookahead_literal("INT32", 0)) or self.match_lookahead_literal("MISSING", 0)) or self.match_lookahead_literal("STRING", 0)) or self.match_lookahead_literal("UINT128", 0)) or self.match_lookahead_literal("UINT32", 0)) or self.match_lookahead_literal("UNKNOWN", 0)) + while cond1145: + _t1949 = self.parse_type() + item1146 = _t1949 + xs1144.append(item1146) + cond1145 = (((((((((((((self.match_lookahead_literal("(", 0) or self.match_lookahead_literal("BOOLEAN", 0)) or self.match_lookahead_literal("DATE", 0)) or self.match_lookahead_literal("DATETIME", 0)) or self.match_lookahead_literal("FLOAT", 0)) or self.match_lookahead_literal("FLOAT32", 0)) or self.match_lookahead_literal("INT", 0)) or self.match_lookahead_literal("INT128", 0)) or self.match_lookahead_literal("INT32", 0)) or self.match_lookahead_literal("MISSING", 0)) or self.match_lookahead_literal("STRING", 0)) or self.match_lookahead_literal("UINT128", 0)) or self.match_lookahead_literal("UINT32", 0)) or self.match_lookahead_literal("UNKNOWN", 0)) + types1147 = xs1144 self.consume_literal("]") - return types1146 + return types1147 def parse_betree_relation(self) -> logic_pb2.BeTreeRelation: - span_start1149 = self.span_start() + span_start1150 = self.span_start() self.consume_literal("(") self.consume_literal("betree_relation") - _t1948 = self.parse_relation_id() - relation_id1147 = _t1948 - _t1949 = self.parse_betree_info() - betree_info1148 = _t1949 + _t1950 = self.parse_relation_id() + relation_id1148 = _t1950 + _t1951 = self.parse_betree_info() + betree_info1149 = _t1951 self.consume_literal(")") - _t1950 = logic_pb2.BeTreeRelation(name=relation_id1147, relation_info=betree_info1148) - result1150 = _t1950 - self.record_span(span_start1149, "BeTreeRelation") - return result1150 + _t1952 = logic_pb2.BeTreeRelation(name=relation_id1148, relation_info=betree_info1149) + result1151 = _t1952 + self.record_span(span_start1150, "BeTreeRelation") + return result1151 def parse_betree_info(self) -> logic_pb2.BeTreeInfo: - span_start1154 = self.span_start() + span_start1155 = self.span_start() self.consume_literal("(") self.consume_literal("betree_info") - _t1951 = self.parse_betree_info_key_types() - betree_info_key_types1151 = _t1951 - _t1952 = self.parse_betree_info_value_types() - betree_info_value_types1152 = _t1952 - _t1953 = self.parse_config_dict() - config_dict1153 = _t1953 - self.consume_literal(")") - _t1954 = self.construct_betree_info(betree_info_key_types1151, betree_info_value_types1152, config_dict1153) - result1155 = _t1954 - self.record_span(span_start1154, "BeTreeInfo") - return result1155 + _t1953 = self.parse_betree_info_key_types() + betree_info_key_types1152 = _t1953 + _t1954 = self.parse_betree_info_value_types() + betree_info_value_types1153 = _t1954 + _t1955 = self.parse_config_dict() + config_dict1154 = _t1955 + self.consume_literal(")") + _t1956 = self.construct_betree_info(betree_info_key_types1152, betree_info_value_types1153, config_dict1154) + result1156 = _t1956 + self.record_span(span_start1155, "BeTreeInfo") + return result1156 def parse_betree_info_key_types(self) -> Sequence[logic_pb2.Type]: self.consume_literal("(") self.consume_literal("key_types") - xs1156 = [] - cond1157 = (((((((((((((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 cond1157: - _t1955 = self.parse_type() - item1158 = _t1955 - xs1156.append(item1158) - cond1157 = (((((((((((((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)) - types1159 = xs1156 + xs1157 = [] + cond1158 = (((((((((((((self.match_lookahead_literal("(", 0) or self.match_lookahead_literal("BOOLEAN", 0)) or self.match_lookahead_literal("DATE", 0)) or self.match_lookahead_literal("DATETIME", 0)) or self.match_lookahead_literal("FLOAT", 0)) or self.match_lookahead_literal("FLOAT32", 0)) or self.match_lookahead_literal("INT", 0)) or self.match_lookahead_literal("INT128", 0)) or self.match_lookahead_literal("INT32", 0)) or self.match_lookahead_literal("MISSING", 0)) or self.match_lookahead_literal("STRING", 0)) or self.match_lookahead_literal("UINT128", 0)) or self.match_lookahead_literal("UINT32", 0)) or self.match_lookahead_literal("UNKNOWN", 0)) + while cond1158: + _t1957 = self.parse_type() + item1159 = _t1957 + xs1157.append(item1159) + cond1158 = (((((((((((((self.match_lookahead_literal("(", 0) or self.match_lookahead_literal("BOOLEAN", 0)) or self.match_lookahead_literal("DATE", 0)) or self.match_lookahead_literal("DATETIME", 0)) or self.match_lookahead_literal("FLOAT", 0)) or self.match_lookahead_literal("FLOAT32", 0)) or self.match_lookahead_literal("INT", 0)) or self.match_lookahead_literal("INT128", 0)) or self.match_lookahead_literal("INT32", 0)) or self.match_lookahead_literal("MISSING", 0)) or self.match_lookahead_literal("STRING", 0)) or self.match_lookahead_literal("UINT128", 0)) or self.match_lookahead_literal("UINT32", 0)) or self.match_lookahead_literal("UNKNOWN", 0)) + types1160 = xs1157 self.consume_literal(")") - return types1159 + return types1160 def parse_betree_info_value_types(self) -> Sequence[logic_pb2.Type]: self.consume_literal("(") self.consume_literal("value_types") - xs1160 = [] - cond1161 = (((((((((((((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 cond1161: - _t1956 = self.parse_type() - item1162 = _t1956 - xs1160.append(item1162) - cond1161 = (((((((((((((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)) - types1163 = xs1160 + xs1161 = [] + cond1162 = (((((((((((((self.match_lookahead_literal("(", 0) or self.match_lookahead_literal("BOOLEAN", 0)) or self.match_lookahead_literal("DATE", 0)) or self.match_lookahead_literal("DATETIME", 0)) or self.match_lookahead_literal("FLOAT", 0)) or self.match_lookahead_literal("FLOAT32", 0)) or self.match_lookahead_literal("INT", 0)) or self.match_lookahead_literal("INT128", 0)) or self.match_lookahead_literal("INT32", 0)) or self.match_lookahead_literal("MISSING", 0)) or self.match_lookahead_literal("STRING", 0)) or self.match_lookahead_literal("UINT128", 0)) or self.match_lookahead_literal("UINT32", 0)) or self.match_lookahead_literal("UNKNOWN", 0)) + while cond1162: + _t1958 = self.parse_type() + item1163 = _t1958 + xs1161.append(item1163) + cond1162 = (((((((((((((self.match_lookahead_literal("(", 0) or self.match_lookahead_literal("BOOLEAN", 0)) or self.match_lookahead_literal("DATE", 0)) or self.match_lookahead_literal("DATETIME", 0)) or self.match_lookahead_literal("FLOAT", 0)) or self.match_lookahead_literal("FLOAT32", 0)) or self.match_lookahead_literal("INT", 0)) or self.match_lookahead_literal("INT128", 0)) or self.match_lookahead_literal("INT32", 0)) or self.match_lookahead_literal("MISSING", 0)) or self.match_lookahead_literal("STRING", 0)) or self.match_lookahead_literal("UINT128", 0)) or self.match_lookahead_literal("UINT32", 0)) or self.match_lookahead_literal("UNKNOWN", 0)) + types1164 = xs1161 self.consume_literal(")") - return types1163 + return types1164 def parse_csv_data(self) -> logic_pb2.CSVData: - span_start1168 = self.span_start() + span_start1169 = self.span_start() self.consume_literal("(") self.consume_literal("csv_data") - _t1957 = self.parse_csvlocator() - csvlocator1164 = _t1957 - _t1958 = self.parse_csv_config() - csv_config1165 = _t1958 - _t1959 = self.parse_gnf_columns() - gnf_columns1166 = _t1959 - _t1960 = self.parse_csv_asof() - csv_asof1167 = _t1960 - self.consume_literal(")") - _t1961 = logic_pb2.CSVData(locator=csvlocator1164, config=csv_config1165, columns=gnf_columns1166, asof=csv_asof1167) - result1169 = _t1961 - self.record_span(span_start1168, "CSVData") - return result1169 + _t1959 = self.parse_csvlocator() + csvlocator1165 = _t1959 + _t1960 = self.parse_csv_config() + csv_config1166 = _t1960 + _t1961 = self.parse_gnf_columns() + gnf_columns1167 = _t1961 + _t1962 = self.parse_csv_asof() + csv_asof1168 = _t1962 + self.consume_literal(")") + _t1963 = logic_pb2.CSVData(locator=csvlocator1165, config=csv_config1166, columns=gnf_columns1167, asof=csv_asof1168) + result1170 = _t1963 + self.record_span(span_start1169, "CSVData") + return result1170 def parse_csvlocator(self) -> logic_pb2.CSVLocator: - span_start1172 = self.span_start() + span_start1173 = self.span_start() self.consume_literal("(") self.consume_literal("csv_locator") if (self.match_lookahead_literal("(", 0) and self.match_lookahead_literal("paths", 1)): - _t1963 = self.parse_csv_locator_paths() - _t1962 = _t1963 - else: - _t1962 = None - csv_locator_paths1170 = _t1962 - if self.match_lookahead_literal("(", 0): - _t1965 = self.parse_csv_locator_inline_data() + _t1965 = self.parse_csv_locator_paths() _t1964 = _t1965 else: _t1964 = None - csv_locator_inline_data1171 = _t1964 + csv_locator_paths1171 = _t1964 + if self.match_lookahead_literal("(", 0): + _t1967 = self.parse_csv_locator_inline_data() + _t1966 = _t1967 + else: + _t1966 = None + csv_locator_inline_data1172 = _t1966 self.consume_literal(")") - _t1966 = logic_pb2.CSVLocator(paths=(csv_locator_paths1170 if csv_locator_paths1170 is not None else []), inline_data=(csv_locator_inline_data1171 if csv_locator_inline_data1171 is not None else "").encode()) - result1173 = _t1966 - self.record_span(span_start1172, "CSVLocator") - return result1173 + _t1968 = logic_pb2.CSVLocator(paths=(csv_locator_paths1171 if csv_locator_paths1171 is not None else []), inline_data=(csv_locator_inline_data1172 if csv_locator_inline_data1172 is not None else "").encode()) + result1174 = _t1968 + self.record_span(span_start1173, "CSVLocator") + return result1174 def parse_csv_locator_paths(self) -> Sequence[str]: self.consume_literal("(") self.consume_literal("paths") - xs1174 = [] - cond1175 = self.match_lookahead_terminal("STRING", 0) - while cond1175: - item1176 = self.consume_terminal("STRING") - xs1174.append(item1176) - cond1175 = self.match_lookahead_terminal("STRING", 0) - strings1177 = xs1174 + xs1175 = [] + cond1176 = self.match_lookahead_terminal("STRING", 0) + while cond1176: + item1177 = self.consume_terminal("STRING") + xs1175.append(item1177) + cond1176 = self.match_lookahead_terminal("STRING", 0) + strings1178 = xs1175 self.consume_literal(")") - return strings1177 + return strings1178 def parse_csv_locator_inline_data(self) -> str: self.consume_literal("(") self.consume_literal("inline_data") - string1178 = self.consume_terminal("STRING") + string1179 = self.consume_terminal("STRING") self.consume_literal(")") - return string1178 + return string1179 def parse_csv_config(self) -> logic_pb2.CSVConfig: - span_start1180 = self.span_start() + span_start1181 = self.span_start() self.consume_literal("(") self.consume_literal("csv_config") - _t1967 = self.parse_config_dict() - config_dict1179 = _t1967 + _t1969 = self.parse_config_dict() + config_dict1180 = _t1969 self.consume_literal(")") - _t1968 = self.construct_csv_config(config_dict1179) - result1181 = _t1968 - self.record_span(span_start1180, "CSVConfig") - return result1181 + _t1970 = self.construct_csv_config(config_dict1180) + result1182 = _t1970 + self.record_span(span_start1181, "CSVConfig") + return result1182 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: - _t1969 = self.parse_gnf_column() - item1184 = _t1969 - xs1182.append(item1184) - cond1183 = self.match_lookahead_literal("(", 0) - gnf_columns1185 = xs1182 + xs1183 = [] + cond1184 = self.match_lookahead_literal("(", 0) + while cond1184: + _t1971 = self.parse_gnf_column() + item1185 = _t1971 + xs1183.append(item1185) + cond1184 = self.match_lookahead_literal("(", 0) + gnf_columns1186 = xs1183 self.consume_literal(")") - return gnf_columns1185 + return gnf_columns1186 def parse_gnf_column(self) -> logic_pb2.GNFColumn: - span_start1192 = self.span_start() + span_start1193 = self.span_start() self.consume_literal("(") self.consume_literal("column") - _t1970 = self.parse_gnf_column_path() - gnf_column_path1186 = _t1970 + _t1972 = self.parse_gnf_column_path() + gnf_column_path1187 = _t1972 if (self.match_lookahead_literal(":", 0) or self.match_lookahead_terminal("UINT128", 0)): - _t1972 = self.parse_relation_id() - _t1971 = _t1972 + _t1974 = self.parse_relation_id() + _t1973 = _t1974 else: - _t1971 = None - relation_id1187 = _t1971 + _t1973 = None + relation_id1188 = _t1973 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: - _t1973 = self.parse_type() - item1190 = _t1973 - 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 + xs1189 = [] + cond1190 = (((((((((((((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 cond1190: + _t1975 = self.parse_type() + item1191 = _t1975 + xs1189.append(item1191) + cond1190 = (((((((((((((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)) + types1192 = xs1189 self.consume_literal("]") self.consume_literal(")") - _t1974 = logic_pb2.GNFColumn(column_path=gnf_column_path1186, target_id=relation_id1187, types=types1191) - result1193 = _t1974 - self.record_span(span_start1192, "GNFColumn") - return result1193 + _t1976 = logic_pb2.GNFColumn(column_path=gnf_column_path1187, target_id=relation_id1188, types=types1192) + result1194 = _t1976 + self.record_span(span_start1193, "GNFColumn") + return result1194 def parse_gnf_column_path(self) -> Sequence[str]: if self.match_lookahead_literal("[", 0): - _t1975 = 1 + _t1977 = 1 else: if self.match_lookahead_terminal("STRING", 0): - _t1976 = 0 + _t1978 = 0 else: - _t1976 = -1 - _t1975 = _t1976 - prediction1194 = _t1975 - if prediction1194 == 1: + _t1978 = -1 + _t1977 = _t1978 + prediction1195 = _t1977 + if prediction1195 == 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 + xs1197 = [] + cond1198 = self.match_lookahead_terminal("STRING", 0) + while cond1198: + item1199 = self.consume_terminal("STRING") + xs1197.append(item1199) + cond1198 = self.match_lookahead_terminal("STRING", 0) + strings1200 = xs1197 self.consume_literal("]") - _t1977 = strings1199 + _t1979 = strings1200 else: - if prediction1194 == 0: - string1195 = self.consume_terminal("STRING") - _t1978 = [string1195] + if prediction1195 == 0: + string1196 = self.consume_terminal("STRING") + _t1980 = [string1196] else: raise ParseError("Unexpected token in gnf_column_path" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1977 = _t1978 - return _t1977 + _t1979 = _t1980 + return _t1979 def parse_csv_asof(self) -> str: self.consume_literal("(") self.consume_literal("asof") - string1200 = self.consume_terminal("STRING") + string1201 = self.consume_terminal("STRING") self.consume_literal(")") - return string1200 + return string1201 def parse_iceberg_data(self) -> logic_pb2.IcebergData: - span_start1207 = self.span_start() + span_start1208 = self.span_start() self.consume_literal("(") self.consume_literal("iceberg_data") - _t1979 = self.parse_iceberg_locator() - iceberg_locator1201 = _t1979 - _t1980 = self.parse_iceberg_catalog_config() - iceberg_catalog_config1202 = _t1980 - _t1981 = self.parse_gnf_columns() - gnf_columns1203 = _t1981 + _t1981 = self.parse_iceberg_locator() + iceberg_locator1202 = _t1981 + _t1982 = self.parse_iceberg_catalog_config() + iceberg_catalog_config1203 = _t1982 + _t1983 = self.parse_gnf_columns() + gnf_columns1204 = _t1983 if (self.match_lookahead_literal("(", 0) and self.match_lookahead_literal("from_snapshot", 1)): - _t1983 = self.parse_iceberg_from_snapshot() - _t1982 = _t1983 - else: - _t1982 = None - iceberg_from_snapshot1204 = _t1982 - if self.match_lookahead_literal("(", 0): - _t1985 = self.parse_iceberg_to_snapshot() + _t1985 = self.parse_iceberg_from_snapshot() _t1984 = _t1985 else: _t1984 = None - iceberg_to_snapshot1205 = _t1984 - _t1986 = self.parse_boolean_value() - boolean_value1206 = _t1986 + iceberg_from_snapshot1205 = _t1984 + if self.match_lookahead_literal("(", 0): + _t1987 = self.parse_iceberg_to_snapshot() + _t1986 = _t1987 + else: + _t1986 = None + iceberg_to_snapshot1206 = _t1986 + _t1988 = self.parse_boolean_value() + boolean_value1207 = _t1988 self.consume_literal(")") - _t1987 = self.construct_iceberg_data(iceberg_locator1201, iceberg_catalog_config1202, gnf_columns1203, iceberg_from_snapshot1204, iceberg_to_snapshot1205, boolean_value1206) - result1208 = _t1987 - self.record_span(span_start1207, "IcebergData") - return result1208 + _t1989 = self.construct_iceberg_data(iceberg_locator1202, iceberg_catalog_config1203, gnf_columns1204, iceberg_from_snapshot1205, iceberg_to_snapshot1206, boolean_value1207) + result1209 = _t1989 + self.record_span(span_start1208, "IcebergData") + return result1209 def parse_iceberg_locator(self) -> logic_pb2.IcebergLocator: - span_start1212 = self.span_start() + span_start1213 = self.span_start() self.consume_literal("(") self.consume_literal("iceberg_locator") - _t1988 = self.parse_iceberg_locator_table_name() - iceberg_locator_table_name1209 = _t1988 - _t1989 = self.parse_iceberg_locator_namespace() - iceberg_locator_namespace1210 = _t1989 - _t1990 = self.parse_iceberg_locator_warehouse() - iceberg_locator_warehouse1211 = _t1990 - self.consume_literal(")") - _t1991 = logic_pb2.IcebergLocator(table_name=iceberg_locator_table_name1209, namespace=iceberg_locator_namespace1210, warehouse=iceberg_locator_warehouse1211) - result1213 = _t1991 - self.record_span(span_start1212, "IcebergLocator") - return result1213 + _t1990 = self.parse_iceberg_locator_table_name() + iceberg_locator_table_name1210 = _t1990 + _t1991 = self.parse_iceberg_locator_namespace() + iceberg_locator_namespace1211 = _t1991 + _t1992 = self.parse_iceberg_locator_warehouse() + iceberg_locator_warehouse1212 = _t1992 + self.consume_literal(")") + _t1993 = logic_pb2.IcebergLocator(table_name=iceberg_locator_table_name1210, namespace=iceberg_locator_namespace1211, warehouse=iceberg_locator_warehouse1212) + result1214 = _t1993 + self.record_span(span_start1213, "IcebergLocator") + return result1214 def parse_iceberg_locator_table_name(self) -> str: self.consume_literal("(") self.consume_literal("table_name") - string1214 = self.consume_terminal("STRING") + string1215 = self.consume_terminal("STRING") self.consume_literal(")") - return string1214 + return string1215 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 + xs1216 = [] + cond1217 = self.match_lookahead_terminal("STRING", 0) + while cond1217: + item1218 = self.consume_terminal("STRING") + xs1216.append(item1218) + cond1217 = self.match_lookahead_terminal("STRING", 0) + strings1219 = xs1216 self.consume_literal(")") - return strings1218 + return strings1219 def parse_iceberg_locator_warehouse(self) -> str: self.consume_literal("(") self.consume_literal("warehouse") - string1219 = self.consume_terminal("STRING") + string1220 = self.consume_terminal("STRING") self.consume_literal(")") - return string1219 + return string1220 def parse_iceberg_catalog_config(self) -> logic_pb2.IcebergCatalogConfig: - span_start1224 = self.span_start() + span_start1225 = self.span_start() self.consume_literal("(") self.consume_literal("iceberg_catalog_config") - _t1992 = self.parse_iceberg_catalog_uri() - iceberg_catalog_uri1220 = _t1992 + _t1994 = self.parse_iceberg_catalog_uri() + iceberg_catalog_uri1221 = _t1994 if (self.match_lookahead_literal("(", 0) and self.match_lookahead_literal("scope", 1)): - _t1994 = self.parse_iceberg_catalog_config_scope() - _t1993 = _t1994 + _t1996 = self.parse_iceberg_catalog_config_scope() + _t1995 = _t1996 else: - _t1993 = None - iceberg_catalog_config_scope1221 = _t1993 - _t1995 = self.parse_iceberg_properties() - iceberg_properties1222 = _t1995 - _t1996 = self.parse_iceberg_auth_properties() - iceberg_auth_properties1223 = _t1996 + _t1995 = None + iceberg_catalog_config_scope1222 = _t1995 + _t1997 = self.parse_iceberg_properties() + iceberg_properties1223 = _t1997 + _t1998 = self.parse_iceberg_auth_properties() + iceberg_auth_properties1224 = _t1998 self.consume_literal(")") - _t1997 = self.construct_iceberg_catalog_config(iceberg_catalog_uri1220, iceberg_catalog_config_scope1221, iceberg_properties1222, iceberg_auth_properties1223) - result1225 = _t1997 - self.record_span(span_start1224, "IcebergCatalogConfig") - return result1225 + _t1999 = self.construct_iceberg_catalog_config(iceberg_catalog_uri1221, iceberg_catalog_config_scope1222, iceberg_properties1223, iceberg_auth_properties1224) + result1226 = _t1999 + self.record_span(span_start1225, "IcebergCatalogConfig") + return result1226 def parse_iceberg_catalog_uri(self) -> str: self.consume_literal("(") self.consume_literal("catalog_uri") - string1226 = self.consume_terminal("STRING") + string1227 = self.consume_terminal("STRING") self.consume_literal(")") - return string1226 + return string1227 def parse_iceberg_catalog_config_scope(self) -> str: self.consume_literal("(") self.consume_literal("scope") - string1227 = self.consume_terminal("STRING") + string1228 = self.consume_terminal("STRING") self.consume_literal(")") - return string1227 + return string1228 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: - _t1998 = self.parse_iceberg_property_entry() - item1230 = _t1998 - xs1228.append(item1230) - cond1229 = self.match_lookahead_literal("(", 0) - iceberg_property_entrys1231 = xs1228 + xs1229 = [] + cond1230 = self.match_lookahead_literal("(", 0) + while cond1230: + _t2000 = self.parse_iceberg_property_entry() + item1231 = _t2000 + xs1229.append(item1231) + cond1230 = self.match_lookahead_literal("(", 0) + iceberg_property_entrys1232 = xs1229 self.consume_literal(")") - return iceberg_property_entrys1231 + return iceberg_property_entrys1232 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") + string1233 = self.consume_terminal("STRING") + string_31234 = self.consume_terminal("STRING") self.consume_literal(")") - return (string1232, string_31233,) + return (string1233, string_31234,) 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: - _t1999 = self.parse_iceberg_masked_property_entry() - item1236 = _t1999 - xs1234.append(item1236) - cond1235 = self.match_lookahead_literal("(", 0) - iceberg_masked_property_entrys1237 = xs1234 + xs1235 = [] + cond1236 = self.match_lookahead_literal("(", 0) + while cond1236: + _t2001 = self.parse_iceberg_masked_property_entry() + item1237 = _t2001 + xs1235.append(item1237) + cond1236 = self.match_lookahead_literal("(", 0) + iceberg_masked_property_entrys1238 = xs1235 self.consume_literal(")") - return iceberg_masked_property_entrys1237 + return iceberg_masked_property_entrys1238 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") + string1239 = self.consume_terminal("STRING") + string_31240 = self.consume_terminal("STRING") self.consume_literal(")") - return (string1238, string_31239,) + return (string1239, string_31240,) def parse_iceberg_from_snapshot(self) -> str: self.consume_literal("(") self.consume_literal("from_snapshot") - string1240 = self.consume_terminal("STRING") + string1241 = self.consume_terminal("STRING") self.consume_literal(")") - return string1240 + return string1241 def parse_iceberg_to_snapshot(self) -> str: self.consume_literal("(") self.consume_literal("to_snapshot") - string1241 = self.consume_terminal("STRING") + string1242 = self.consume_terminal("STRING") self.consume_literal(")") - return string1241 + return string1242 def parse_undefine(self) -> transactions_pb2.Undefine: - span_start1243 = self.span_start() + span_start1244 = self.span_start() self.consume_literal("(") self.consume_literal("undefine") - _t2000 = self.parse_fragment_id() - fragment_id1242 = _t2000 + _t2002 = self.parse_fragment_id() + fragment_id1243 = _t2002 self.consume_literal(")") - _t2001 = transactions_pb2.Undefine(fragment_id=fragment_id1242) - result1244 = _t2001 - self.record_span(span_start1243, "Undefine") - return result1244 + _t2003 = transactions_pb2.Undefine(fragment_id=fragment_id1243) + result1245 = _t2003 + self.record_span(span_start1244, "Undefine") + return result1245 def parse_context(self) -> transactions_pb2.Context: - span_start1249 = self.span_start() + span_start1250 = 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: - _t2002 = self.parse_relation_id() - item1247 = _t2002 - xs1245.append(item1247) - cond1246 = (self.match_lookahead_literal(":", 0) or self.match_lookahead_terminal("UINT128", 0)) - relation_ids1248 = xs1245 - self.consume_literal(")") - _t2003 = transactions_pb2.Context(relations=relation_ids1248) - result1250 = _t2003 - self.record_span(span_start1249, "Context") - return result1250 + xs1246 = [] + cond1247 = (self.match_lookahead_literal(":", 0) or self.match_lookahead_terminal("UINT128", 0)) + while cond1247: + _t2004 = self.parse_relation_id() + item1248 = _t2004 + xs1246.append(item1248) + cond1247 = (self.match_lookahead_literal(":", 0) or self.match_lookahead_terminal("UINT128", 0)) + relation_ids1249 = xs1246 + self.consume_literal(")") + _t2005 = transactions_pb2.Context(relations=relation_ids1249) + result1251 = _t2005 + self.record_span(span_start1250, "Context") + return result1251 def parse_snapshot(self) -> transactions_pb2.Snapshot: - span_start1255 = self.span_start() + span_start1257 = self.span_start() self.consume_literal("(") self.consume_literal("snapshot") - xs1251 = [] - cond1252 = self.match_lookahead_literal("[", 0) - while cond1252: - _t2004 = self.parse_snapshot_mapping() - item1253 = _t2004 - xs1251.append(item1253) - cond1252 = self.match_lookahead_literal("[", 0) - snapshot_mappings1254 = xs1251 - self.consume_literal(")") - _t2005 = transactions_pb2.Snapshot(mappings=snapshot_mappings1254) - result1256 = _t2005 - self.record_span(span_start1255, "Snapshot") - return result1256 + _t2006 = self.parse_edb_path() + edb_path1252 = _t2006 + xs1253 = [] + cond1254 = self.match_lookahead_literal("[", 0) + while cond1254: + _t2007 = self.parse_snapshot_mapping() + item1255 = _t2007 + xs1253.append(item1255) + cond1254 = self.match_lookahead_literal("[", 0) + snapshot_mappings1256 = xs1253 + self.consume_literal(")") + _t2008 = transactions_pb2.Snapshot(prefix=edb_path1252, mappings=snapshot_mappings1256) + result1258 = _t2008 + self.record_span(span_start1257, "Snapshot") + return result1258 def parse_snapshot_mapping(self) -> transactions_pb2.SnapshotMapping: - span_start1259 = self.span_start() - _t2006 = self.parse_edb_path() - edb_path1257 = _t2006 - _t2007 = self.parse_relation_id() - relation_id1258 = _t2007 - _t2008 = transactions_pb2.SnapshotMapping(destination_path=edb_path1257, source_relation=relation_id1258) - result1260 = _t2008 - self.record_span(span_start1259, "SnapshotMapping") - return result1260 + span_start1261 = self.span_start() + _t2009 = self.parse_edb_path() + edb_path1259 = _t2009 + _t2010 = self.parse_relation_id() + relation_id1260 = _t2010 + _t2011 = transactions_pb2.SnapshotMapping(destination_path=edb_path1259, source_relation=relation_id1260) + result1262 = _t2011 + self.record_span(span_start1261, "SnapshotMapping") + return result1262 def parse_epoch_reads(self) -> Sequence[transactions_pb2.Read]: self.consume_literal("(") self.consume_literal("reads") - xs1261 = [] - cond1262 = self.match_lookahead_literal("(", 0) - while cond1262: - _t2009 = self.parse_read() - item1263 = _t2009 - xs1261.append(item1263) - cond1262 = self.match_lookahead_literal("(", 0) - reads1264 = xs1261 + xs1263 = [] + cond1264 = self.match_lookahead_literal("(", 0) + while cond1264: + _t2012 = self.parse_read() + item1265 = _t2012 + xs1263.append(item1265) + cond1264 = self.match_lookahead_literal("(", 0) + reads1266 = xs1263 self.consume_literal(")") - return reads1264 + return reads1266 def parse_read(self) -> transactions_pb2.Read: - span_start1271 = self.span_start() + span_start1273 = self.span_start() if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("what_if", 1): - _t2011 = 2 + _t2014 = 2 else: if self.match_lookahead_literal("output", 1): - _t2012 = 1 + _t2015 = 1 else: if self.match_lookahead_literal("export_iceberg", 1): - _t2013 = 4 + _t2016 = 4 else: if self.match_lookahead_literal("export", 1): - _t2014 = 4 + _t2017 = 4 else: if self.match_lookahead_literal("demand", 1): - _t2015 = 0 + _t2018 = 0 else: if self.match_lookahead_literal("abort", 1): - _t2016 = 3 + _t2019 = 3 else: - _t2016 = -1 - _t2015 = _t2016 - _t2014 = _t2015 - _t2013 = _t2014 - _t2012 = _t2013 - _t2011 = _t2012 - _t2010 = _t2011 - else: - _t2010 = -1 - prediction1265 = _t2010 - if prediction1265 == 4: - _t2018 = self.parse_export() - export1270 = _t2018 - _t2019 = transactions_pb2.Read(export=export1270) - _t2017 = _t2019 - else: - if prediction1265 == 3: - _t2021 = self.parse_abort() - abort1269 = _t2021 - _t2022 = transactions_pb2.Read(abort=abort1269) - _t2020 = _t2022 + _t2019 = -1 + _t2018 = _t2019 + _t2017 = _t2018 + _t2016 = _t2017 + _t2015 = _t2016 + _t2014 = _t2015 + _t2013 = _t2014 + else: + _t2013 = -1 + prediction1267 = _t2013 + if prediction1267 == 4: + _t2021 = self.parse_export() + export1272 = _t2021 + _t2022 = transactions_pb2.Read(export=export1272) + _t2020 = _t2022 + else: + if prediction1267 == 3: + _t2024 = self.parse_abort() + abort1271 = _t2024 + _t2025 = transactions_pb2.Read(abort=abort1271) + _t2023 = _t2025 else: - if prediction1265 == 2: - _t2024 = self.parse_what_if() - what_if1268 = _t2024 - _t2025 = transactions_pb2.Read(what_if=what_if1268) - _t2023 = _t2025 + if prediction1267 == 2: + _t2027 = self.parse_what_if() + what_if1270 = _t2027 + _t2028 = transactions_pb2.Read(what_if=what_if1270) + _t2026 = _t2028 else: - if prediction1265 == 1: - _t2027 = self.parse_output() - output1267 = _t2027 - _t2028 = transactions_pb2.Read(output=output1267) - _t2026 = _t2028 + if prediction1267 == 1: + _t2030 = self.parse_output() + output1269 = _t2030 + _t2031 = transactions_pb2.Read(output=output1269) + _t2029 = _t2031 else: - if prediction1265 == 0: - _t2030 = self.parse_demand() - demand1266 = _t2030 - _t2031 = transactions_pb2.Read(demand=demand1266) - _t2029 = _t2031 + if prediction1267 == 0: + _t2033 = self.parse_demand() + demand1268 = _t2033 + _t2034 = transactions_pb2.Read(demand=demand1268) + _t2032 = _t2034 else: raise ParseError("Unexpected token in read" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t2026 = _t2029 - _t2023 = _t2026 - _t2020 = _t2023 - _t2017 = _t2020 - result1272 = _t2017 - self.record_span(span_start1271, "Read") - return result1272 + _t2029 = _t2032 + _t2026 = _t2029 + _t2023 = _t2026 + _t2020 = _t2023 + result1274 = _t2020 + self.record_span(span_start1273, "Read") + return result1274 def parse_demand(self) -> transactions_pb2.Demand: - span_start1274 = self.span_start() + span_start1276 = self.span_start() self.consume_literal("(") self.consume_literal("demand") - _t2032 = self.parse_relation_id() - relation_id1273 = _t2032 + _t2035 = self.parse_relation_id() + relation_id1275 = _t2035 self.consume_literal(")") - _t2033 = transactions_pb2.Demand(relation_id=relation_id1273) - result1275 = _t2033 - self.record_span(span_start1274, "Demand") - return result1275 + _t2036 = transactions_pb2.Demand(relation_id=relation_id1275) + result1277 = _t2036 + self.record_span(span_start1276, "Demand") + return result1277 def parse_output(self) -> transactions_pb2.Output: - span_start1278 = self.span_start() + span_start1280 = self.span_start() self.consume_literal("(") self.consume_literal("output") - _t2034 = self.parse_name() - name1276 = _t2034 - _t2035 = self.parse_relation_id() - relation_id1277 = _t2035 + _t2037 = self.parse_name() + name1278 = _t2037 + _t2038 = self.parse_relation_id() + relation_id1279 = _t2038 self.consume_literal(")") - _t2036 = transactions_pb2.Output(name=name1276, relation_id=relation_id1277) - result1279 = _t2036 - self.record_span(span_start1278, "Output") - return result1279 + _t2039 = transactions_pb2.Output(name=name1278, relation_id=relation_id1279) + result1281 = _t2039 + self.record_span(span_start1280, "Output") + return result1281 def parse_what_if(self) -> transactions_pb2.WhatIf: - span_start1282 = self.span_start() + span_start1284 = self.span_start() self.consume_literal("(") self.consume_literal("what_if") - _t2037 = self.parse_name() - name1280 = _t2037 - _t2038 = self.parse_epoch() - epoch1281 = _t2038 + _t2040 = self.parse_name() + name1282 = _t2040 + _t2041 = self.parse_epoch() + epoch1283 = _t2041 self.consume_literal(")") - _t2039 = transactions_pb2.WhatIf(branch=name1280, epoch=epoch1281) - result1283 = _t2039 - self.record_span(span_start1282, "WhatIf") - return result1283 + _t2042 = transactions_pb2.WhatIf(branch=name1282, epoch=epoch1283) + result1285 = _t2042 + self.record_span(span_start1284, "WhatIf") + return result1285 def parse_abort(self) -> transactions_pb2.Abort: - span_start1286 = self.span_start() + span_start1288 = 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 + _t2044 = self.parse_name() + _t2043 = _t2044 else: - _t2040 = None - name1284 = _t2040 - _t2042 = self.parse_relation_id() - relation_id1285 = _t2042 + _t2043 = None + name1286 = _t2043 + _t2045 = self.parse_relation_id() + relation_id1287 = _t2045 self.consume_literal(")") - _t2043 = transactions_pb2.Abort(name=(name1284 if name1284 is not None else "abort"), relation_id=relation_id1285) - result1287 = _t2043 - self.record_span(span_start1286, "Abort") - return result1287 + _t2046 = transactions_pb2.Abort(name=(name1286 if name1286 is not None else "abort"), relation_id=relation_id1287) + result1289 = _t2046 + self.record_span(span_start1288, "Abort") + return result1289 def parse_export(self) -> transactions_pb2.Export: - span_start1291 = self.span_start() + span_start1293 = self.span_start() if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("export_iceberg", 1): - _t2045 = 1 + _t2048 = 1 else: if self.match_lookahead_literal("export", 1): - _t2046 = 0 + _t2049 = 0 else: - _t2046 = -1 - _t2045 = _t2046 - _t2044 = _t2045 + _t2049 = -1 + _t2048 = _t2049 + _t2047 = _t2048 else: - _t2044 = -1 - prediction1288 = _t2044 - if prediction1288 == 1: + _t2047 = -1 + prediction1290 = _t2047 + if prediction1290 == 1: self.consume_literal("(") self.consume_literal("export_iceberg") - _t2048 = self.parse_export_iceberg_config() - export_iceberg_config1290 = _t2048 + _t2051 = self.parse_export_iceberg_config() + export_iceberg_config1292 = _t2051 self.consume_literal(")") - _t2049 = transactions_pb2.Export(iceberg_config=export_iceberg_config1290) - _t2047 = _t2049 + _t2052 = transactions_pb2.Export(iceberg_config=export_iceberg_config1292) + _t2050 = _t2052 else: - if prediction1288 == 0: + if prediction1290 == 0: self.consume_literal("(") self.consume_literal("export") - _t2051 = self.parse_export_csv_config() - export_csv_config1289 = _t2051 + _t2054 = self.parse_export_csv_config() + export_csv_config1291 = _t2054 self.consume_literal(")") - _t2052 = transactions_pb2.Export(csv_config=export_csv_config1289) - _t2050 = _t2052 + _t2055 = transactions_pb2.Export(csv_config=export_csv_config1291) + _t2053 = _t2055 else: raise ParseError("Unexpected token in export" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t2047 = _t2050 - result1292 = _t2047 - self.record_span(span_start1291, "Export") - return result1292 + _t2050 = _t2053 + result1294 = _t2050 + self.record_span(span_start1293, "Export") + return result1294 def parse_export_csv_config(self) -> transactions_pb2.ExportCSVConfig: - span_start1300 = self.span_start() + span_start1302 = self.span_start() if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("export_csv_config_v2", 1): - _t2054 = 0 + _t2057 = 0 else: if self.match_lookahead_literal("export_csv_config", 1): - _t2055 = 1 + _t2058 = 1 else: - _t2055 = -1 - _t2054 = _t2055 - _t2053 = _t2054 + _t2058 = -1 + _t2057 = _t2058 + _t2056 = _t2057 else: - _t2053 = -1 - prediction1293 = _t2053 - if prediction1293 == 1: + _t2056 = -1 + prediction1295 = _t2056 + if prediction1295 == 1: self.consume_literal("(") self.consume_literal("export_csv_config") - _t2057 = self.parse_export_csv_path() - export_csv_path1297 = _t2057 - _t2058 = self.parse_export_csv_columns_list() - export_csv_columns_list1298 = _t2058 - _t2059 = self.parse_config_dict() - config_dict1299 = _t2059 + _t2060 = self.parse_export_csv_path() + export_csv_path1299 = _t2060 + _t2061 = self.parse_export_csv_columns_list() + export_csv_columns_list1300 = _t2061 + _t2062 = self.parse_config_dict() + config_dict1301 = _t2062 self.consume_literal(")") - _t2060 = self.construct_export_csv_config(export_csv_path1297, export_csv_columns_list1298, config_dict1299) - _t2056 = _t2060 + _t2063 = self.construct_export_csv_config(export_csv_path1299, export_csv_columns_list1300, config_dict1301) + _t2059 = _t2063 else: - if prediction1293 == 0: + if prediction1295 == 0: self.consume_literal("(") self.consume_literal("export_csv_config_v2") - _t2062 = self.parse_export_csv_path() - export_csv_path1294 = _t2062 - _t2063 = self.parse_export_csv_source() - export_csv_source1295 = _t2063 - _t2064 = self.parse_csv_config() - csv_config1296 = _t2064 + _t2065 = self.parse_export_csv_path() + export_csv_path1296 = _t2065 + _t2066 = self.parse_export_csv_source() + export_csv_source1297 = _t2066 + _t2067 = self.parse_csv_config() + csv_config1298 = _t2067 self.consume_literal(")") - _t2065 = self.construct_export_csv_config_with_source(export_csv_path1294, export_csv_source1295, csv_config1296) - _t2061 = _t2065 + _t2068 = self.construct_export_csv_config_with_source(export_csv_path1296, export_csv_source1297, csv_config1298) + _t2064 = _t2068 else: raise ParseError("Unexpected token in export_csv_config" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t2056 = _t2061 - result1301 = _t2056 - self.record_span(span_start1300, "ExportCSVConfig") - return result1301 + _t2059 = _t2064 + result1303 = _t2059 + self.record_span(span_start1302, "ExportCSVConfig") + return result1303 def parse_export_csv_path(self) -> str: self.consume_literal("(") self.consume_literal("path") - string1302 = self.consume_terminal("STRING") + string1304 = self.consume_terminal("STRING") self.consume_literal(")") - return string1302 + return string1304 def parse_export_csv_source(self) -> transactions_pb2.ExportCSVSource: - span_start1309 = self.span_start() + span_start1311 = self.span_start() if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("table_def", 1): - _t2067 = 1 + _t2070 = 1 else: if self.match_lookahead_literal("gnf_columns", 1): - _t2068 = 0 + _t2071 = 0 else: - _t2068 = -1 - _t2067 = _t2068 - _t2066 = _t2067 + _t2071 = -1 + _t2070 = _t2071 + _t2069 = _t2070 else: - _t2066 = -1 - prediction1303 = _t2066 - if prediction1303 == 1: + _t2069 = -1 + prediction1305 = _t2069 + if prediction1305 == 1: self.consume_literal("(") self.consume_literal("table_def") - _t2070 = self.parse_relation_id() - relation_id1308 = _t2070 + _t2073 = self.parse_relation_id() + relation_id1310 = _t2073 self.consume_literal(")") - _t2071 = transactions_pb2.ExportCSVSource(table_def=relation_id1308) - _t2069 = _t2071 + _t2074 = transactions_pb2.ExportCSVSource(table_def=relation_id1310) + _t2072 = _t2074 else: - if prediction1303 == 0: + if prediction1305 == 0: self.consume_literal("(") self.consume_literal("gnf_columns") - xs1304 = [] - cond1305 = self.match_lookahead_literal("(", 0) - while cond1305: - _t2073 = self.parse_export_csv_column() - item1306 = _t2073 - xs1304.append(item1306) - cond1305 = self.match_lookahead_literal("(", 0) - export_csv_columns1307 = xs1304 + xs1306 = [] + cond1307 = self.match_lookahead_literal("(", 0) + while cond1307: + _t2076 = self.parse_export_csv_column() + item1308 = _t2076 + xs1306.append(item1308) + cond1307 = self.match_lookahead_literal("(", 0) + export_csv_columns1309 = xs1306 self.consume_literal(")") - _t2074 = transactions_pb2.ExportCSVColumns(columns=export_csv_columns1307) - _t2075 = transactions_pb2.ExportCSVSource(gnf_columns=_t2074) - _t2072 = _t2075 + _t2077 = transactions_pb2.ExportCSVColumns(columns=export_csv_columns1309) + _t2078 = transactions_pb2.ExportCSVSource(gnf_columns=_t2077) + _t2075 = _t2078 else: raise ParseError("Unexpected token in export_csv_source" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t2069 = _t2072 - result1310 = _t2069 - self.record_span(span_start1309, "ExportCSVSource") - return result1310 + _t2072 = _t2075 + result1312 = _t2072 + self.record_span(span_start1311, "ExportCSVSource") + return result1312 def parse_export_csv_column(self) -> transactions_pb2.ExportCSVColumn: - span_start1313 = self.span_start() + span_start1315 = self.span_start() self.consume_literal("(") self.consume_literal("column") - string1311 = self.consume_terminal("STRING") - _t2076 = self.parse_relation_id() - relation_id1312 = _t2076 + string1313 = self.consume_terminal("STRING") + _t2079 = self.parse_relation_id() + relation_id1314 = _t2079 self.consume_literal(")") - _t2077 = transactions_pb2.ExportCSVColumn(column_name=string1311, column_data=relation_id1312) - result1314 = _t2077 - self.record_span(span_start1313, "ExportCSVColumn") - return result1314 + _t2080 = transactions_pb2.ExportCSVColumn(column_name=string1313, column_data=relation_id1314) + result1316 = _t2080 + self.record_span(span_start1315, "ExportCSVColumn") + return result1316 def parse_export_csv_columns_list(self) -> Sequence[transactions_pb2.ExportCSVColumn]: self.consume_literal("(") self.consume_literal("columns") - xs1315 = [] - cond1316 = self.match_lookahead_literal("(", 0) - while cond1316: - _t2078 = self.parse_export_csv_column() - item1317 = _t2078 - xs1315.append(item1317) - cond1316 = self.match_lookahead_literal("(", 0) - export_csv_columns1318 = xs1315 + xs1317 = [] + cond1318 = self.match_lookahead_literal("(", 0) + while cond1318: + _t2081 = self.parse_export_csv_column() + item1319 = _t2081 + xs1317.append(item1319) + cond1318 = self.match_lookahead_literal("(", 0) + export_csv_columns1320 = xs1317 self.consume_literal(")") - return export_csv_columns1318 + return export_csv_columns1320 def parse_export_iceberg_config(self) -> transactions_pb2.ExportIcebergConfig: - span_start1325 = self.span_start() + span_start1327 = self.span_start() self.consume_literal("(") self.consume_literal("export_iceberg_config") - _t2079 = self.parse_iceberg_locator() - iceberg_locator1319 = _t2079 - _t2080 = self.parse_iceberg_catalog_config() - iceberg_catalog_config1320 = _t2080 - _t2081 = self.parse_export_iceberg_table_def() - export_iceberg_table_def1321 = _t2081 - _t2082 = self.parse_export_iceberg_columns() - export_iceberg_columns1322 = _t2082 - _t2083 = self.parse_iceberg_table_properties() - iceberg_table_properties1323 = _t2083 + _t2082 = self.parse_iceberg_locator() + iceberg_locator1321 = _t2082 + _t2083 = self.parse_iceberg_catalog_config() + iceberg_catalog_config1322 = _t2083 + _t2084 = self.parse_export_iceberg_table_def() + export_iceberg_table_def1323 = _t2084 + _t2085 = self.parse_export_iceberg_columns() + export_iceberg_columns1324 = _t2085 + _t2086 = self.parse_iceberg_table_properties() + iceberg_table_properties1325 = _t2086 if self.match_lookahead_literal("{", 0): - _t2085 = self.parse_config_dict() - _t2084 = _t2085 + _t2088 = self.parse_config_dict() + _t2087 = _t2088 else: - _t2084 = None - config_dict1324 = _t2084 + _t2087 = None + config_dict1326 = _t2087 self.consume_literal(")") - _t2086 = self.construct_export_iceberg_config_full(iceberg_locator1319, iceberg_catalog_config1320, export_iceberg_table_def1321, export_iceberg_columns1322, iceberg_table_properties1323, config_dict1324) - result1326 = _t2086 - self.record_span(span_start1325, "ExportIcebergConfig") - return result1326 + _t2089 = self.construct_export_iceberg_config_full(iceberg_locator1321, iceberg_catalog_config1322, export_iceberg_table_def1323, export_iceberg_columns1324, iceberg_table_properties1325, config_dict1326) + result1328 = _t2089 + self.record_span(span_start1327, "ExportIcebergConfig") + return result1328 def parse_export_iceberg_table_def(self) -> logic_pb2.RelationId: - span_start1328 = self.span_start() + span_start1330 = self.span_start() self.consume_literal("(") self.consume_literal("table_def") - _t2087 = self.parse_relation_id() - relation_id1327 = _t2087 + _t2090 = self.parse_relation_id() + relation_id1329 = _t2090 self.consume_literal(")") - result1329 = relation_id1327 - self.record_span(span_start1328, "RelationId") - return result1329 + result1331 = relation_id1329 + self.record_span(span_start1330, "RelationId") + return result1331 def parse_export_iceberg_columns(self) -> Sequence[transactions_pb2.ExportColumn]: self.consume_literal("(") self.consume_literal("columns") - xs1330 = [] - cond1331 = self.match_lookahead_literal("(", 0) - while cond1331: - _t2088 = self.parse_export_iceberg_column() - item1332 = _t2088 - xs1330.append(item1332) - cond1331 = self.match_lookahead_literal("(", 0) - export_iceberg_columns1333 = xs1330 + xs1332 = [] + cond1333 = self.match_lookahead_literal("(", 0) + while cond1333: + _t2091 = self.parse_export_iceberg_column() + item1334 = _t2091 + xs1332.append(item1334) + cond1333 = self.match_lookahead_literal("(", 0) + export_iceberg_columns1335 = xs1332 self.consume_literal(")") - return export_iceberg_columns1333 + return export_iceberg_columns1335 def parse_export_iceberg_column(self) -> transactions_pb2.ExportColumn: - span_start1336 = self.span_start() + span_start1338 = self.span_start() self.consume_literal("(") self.consume_literal("column") - string1334 = self.consume_terminal("STRING") - _t2089 = self.parse_boolean_value() - boolean_value1335 = _t2089 + string1336 = self.consume_terminal("STRING") + _t2092 = self.parse_boolean_value() + boolean_value1337 = _t2092 self.consume_literal(")") - _t2090 = transactions_pb2.ExportColumn(name=string1334, nullable=boolean_value1335) - result1337 = _t2090 - self.record_span(span_start1336, "ExportColumn") - return result1337 + _t2093 = transactions_pb2.ExportColumn(name=string1336, nullable=boolean_value1337) + result1339 = _t2093 + self.record_span(span_start1338, "ExportColumn") + return result1339 def parse_iceberg_table_properties(self) -> Sequence[tuple[str, str]]: self.consume_literal("(") self.consume_literal("table_properties") - xs1338 = [] - cond1339 = self.match_lookahead_literal("(", 0) - while cond1339: - _t2091 = self.parse_iceberg_property_entry() - item1340 = _t2091 - xs1338.append(item1340) - cond1339 = self.match_lookahead_literal("(", 0) - iceberg_property_entrys1341 = xs1338 - self.consume_literal(")") - return iceberg_property_entrys1341 + xs1340 = [] + cond1341 = self.match_lookahead_literal("(", 0) + while cond1341: + _t2094 = self.parse_iceberg_property_entry() + item1342 = _t2094 + xs1340.append(item1342) + cond1341 = self.match_lookahead_literal("(", 0) + iceberg_property_entrys1343 = xs1340 + self.consume_literal(")") + return iceberg_property_entrys1343 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 9ca70b48..7895b67e 100644 --- a/sdks/python/src/lqp/gen/pretty.py +++ b/sdks/python/src/lqp/gen/pretty.py @@ -217,134 +217,134 @@ def write_debug_info(self) -> None: # --- Helper functions --- def _make_value_int32(self, v: int) -> logic_pb2.Value: - _t1737 = logic_pb2.Value(int32_value=v) - return _t1737 + _t1741 = logic_pb2.Value(int32_value=v) + return _t1741 def _make_value_int64(self, v: int) -> logic_pb2.Value: - _t1738 = logic_pb2.Value(int_value=v) - return _t1738 + _t1742 = logic_pb2.Value(int_value=v) + return _t1742 def _make_value_float64(self, v: float) -> logic_pb2.Value: - _t1739 = logic_pb2.Value(float_value=v) - return _t1739 + _t1743 = logic_pb2.Value(float_value=v) + return _t1743 def _make_value_string(self, v: str) -> logic_pb2.Value: - _t1740 = logic_pb2.Value(string_value=v) - return _t1740 + _t1744 = logic_pb2.Value(string_value=v) + return _t1744 def _make_value_boolean(self, v: bool) -> logic_pb2.Value: - _t1741 = logic_pb2.Value(boolean_value=v) - return _t1741 + _t1745 = logic_pb2.Value(boolean_value=v) + return _t1745 def _make_value_uint128(self, v: logic_pb2.UInt128Value) -> logic_pb2.Value: - _t1742 = logic_pb2.Value(uint128_value=v) - return _t1742 + _t1746 = logic_pb2.Value(uint128_value=v) + return _t1746 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: - _t1743 = self._make_value_string("auto") - result.append(("ivm.maintenance_level", _t1743,)) + _t1747 = self._make_value_string("auto") + result.append(("ivm.maintenance_level", _t1747,)) else: if msg.ivm_config.level == transactions_pb2.MaintenanceLevel.MAINTENANCE_LEVEL_ALL: - _t1744 = self._make_value_string("all") - result.append(("ivm.maintenance_level", _t1744,)) + _t1748 = self._make_value_string("all") + result.append(("ivm.maintenance_level", _t1748,)) else: if msg.ivm_config.level == transactions_pb2.MaintenanceLevel.MAINTENANCE_LEVEL_OFF: - _t1745 = self._make_value_string("off") - result.append(("ivm.maintenance_level", _t1745,)) - _t1746 = self._make_value_int64(msg.semantics_version) - result.append(("semantics_version", _t1746,)) + _t1749 = self._make_value_string("off") + result.append(("ivm.maintenance_level", _t1749,)) + _t1750 = self._make_value_int64(msg.semantics_version) + result.append(("semantics_version", _t1750,)) return sorted(result) def deconstruct_csv_config(self, msg: logic_pb2.CSVConfig) -> list[tuple[str, logic_pb2.Value]]: result = [] - _t1747 = self._make_value_int32(msg.header_row) - result.append(("csv_header_row", _t1747,)) - _t1748 = self._make_value_int64(msg.skip) - result.append(("csv_skip", _t1748,)) + _t1751 = self._make_value_int32(msg.header_row) + result.append(("csv_header_row", _t1751,)) + _t1752 = self._make_value_int64(msg.skip) + result.append(("csv_skip", _t1752,)) if msg.new_line != "": - _t1749 = self._make_value_string(msg.new_line) - result.append(("csv_new_line", _t1749,)) - _t1750 = self._make_value_string(msg.delimiter) - result.append(("csv_delimiter", _t1750,)) - _t1751 = self._make_value_string(msg.quotechar) - result.append(("csv_quotechar", _t1751,)) - _t1752 = self._make_value_string(msg.escapechar) - result.append(("csv_escapechar", _t1752,)) + _t1753 = self._make_value_string(msg.new_line) + result.append(("csv_new_line", _t1753,)) + _t1754 = self._make_value_string(msg.delimiter) + result.append(("csv_delimiter", _t1754,)) + _t1755 = self._make_value_string(msg.quotechar) + result.append(("csv_quotechar", _t1755,)) + _t1756 = self._make_value_string(msg.escapechar) + result.append(("csv_escapechar", _t1756,)) if msg.comment != "": - _t1753 = self._make_value_string(msg.comment) - result.append(("csv_comment", _t1753,)) + _t1757 = self._make_value_string(msg.comment) + result.append(("csv_comment", _t1757,)) for missing_string in msg.missing_strings: - _t1754 = self._make_value_string(missing_string) - result.append(("csv_missing_strings", _t1754,)) - _t1755 = self._make_value_string(msg.decimal_separator) - result.append(("csv_decimal_separator", _t1755,)) - _t1756 = self._make_value_string(msg.encoding) - result.append(("csv_encoding", _t1756,)) - _t1757 = self._make_value_string(msg.compression) - result.append(("csv_compression", _t1757,)) + _t1758 = self._make_value_string(missing_string) + result.append(("csv_missing_strings", _t1758,)) + _t1759 = self._make_value_string(msg.decimal_separator) + result.append(("csv_decimal_separator", _t1759,)) + _t1760 = self._make_value_string(msg.encoding) + result.append(("csv_encoding", _t1760,)) + _t1761 = self._make_value_string(msg.compression) + result.append(("csv_compression", _t1761,)) if msg.partition_size_mb != 0: - _t1758 = self._make_value_int64(msg.partition_size_mb) - result.append(("csv_partition_size_mb", _t1758,)) + _t1762 = self._make_value_int64(msg.partition_size_mb) + result.append(("csv_partition_size_mb", _t1762,)) return sorted(result) def deconstruct_betree_info_config(self, msg: logic_pb2.BeTreeInfo) -> list[tuple[str, logic_pb2.Value]]: result = [] - _t1759 = self._make_value_float64(msg.storage_config.epsilon) - result.append(("betree_config_epsilon", _t1759,)) - _t1760 = self._make_value_int64(msg.storage_config.max_pivots) - result.append(("betree_config_max_pivots", _t1760,)) - _t1761 = self._make_value_int64(msg.storage_config.max_deltas) - result.append(("betree_config_max_deltas", _t1761,)) - _t1762 = self._make_value_int64(msg.storage_config.max_leaf) - result.append(("betree_config_max_leaf", _t1762,)) + _t1763 = self._make_value_float64(msg.storage_config.epsilon) + result.append(("betree_config_epsilon", _t1763,)) + _t1764 = self._make_value_int64(msg.storage_config.max_pivots) + result.append(("betree_config_max_pivots", _t1764,)) + _t1765 = self._make_value_int64(msg.storage_config.max_deltas) + result.append(("betree_config_max_deltas", _t1765,)) + _t1766 = self._make_value_int64(msg.storage_config.max_leaf) + result.append(("betree_config_max_leaf", _t1766,)) 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 - _t1763 = self._make_value_uint128(msg.relation_locator.root_pageid) - result.append(("betree_locator_root_pageid", _t1763,)) + _t1767 = self._make_value_uint128(msg.relation_locator.root_pageid) + result.append(("betree_locator_root_pageid", _t1767,)) 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 - _t1764 = self._make_value_string(msg.relation_locator.inline_data.decode('utf-8')) - result.append(("betree_locator_inline_data", _t1764,)) - _t1765 = self._make_value_int64(msg.relation_locator.element_count) - result.append(("betree_locator_element_count", _t1765,)) - _t1766 = self._make_value_int64(msg.relation_locator.tree_height) - result.append(("betree_locator_tree_height", _t1766,)) + _t1768 = self._make_value_string(msg.relation_locator.inline_data.decode('utf-8')) + result.append(("betree_locator_inline_data", _t1768,)) + _t1769 = self._make_value_int64(msg.relation_locator.element_count) + result.append(("betree_locator_element_count", _t1769,)) + _t1770 = self._make_value_int64(msg.relation_locator.tree_height) + result.append(("betree_locator_tree_height", _t1770,)) 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 - _t1767 = self._make_value_int64(msg.partition_size) - result.append(("partition_size", _t1767,)) + _t1771 = self._make_value_int64(msg.partition_size) + result.append(("partition_size", _t1771,)) if msg.compression is not None: assert msg.compression is not None - _t1768 = self._make_value_string(msg.compression) - result.append(("compression", _t1768,)) + _t1772 = self._make_value_string(msg.compression) + result.append(("compression", _t1772,)) if msg.syntax_header_row is not None: assert msg.syntax_header_row is not None - _t1769 = self._make_value_boolean(msg.syntax_header_row) - result.append(("syntax_header_row", _t1769,)) + _t1773 = self._make_value_boolean(msg.syntax_header_row) + result.append(("syntax_header_row", _t1773,)) if msg.syntax_missing_string is not None: assert msg.syntax_missing_string is not None - _t1770 = self._make_value_string(msg.syntax_missing_string) - result.append(("syntax_missing_string", _t1770,)) + _t1774 = self._make_value_string(msg.syntax_missing_string) + result.append(("syntax_missing_string", _t1774,)) if msg.syntax_delim is not None: assert msg.syntax_delim is not None - _t1771 = self._make_value_string(msg.syntax_delim) - result.append(("syntax_delim", _t1771,)) + _t1775 = self._make_value_string(msg.syntax_delim) + result.append(("syntax_delim", _t1775,)) if msg.syntax_quotechar is not None: assert msg.syntax_quotechar is not None - _t1772 = self._make_value_string(msg.syntax_quotechar) - result.append(("syntax_quotechar", _t1772,)) + _t1776 = self._make_value_string(msg.syntax_quotechar) + result.append(("syntax_quotechar", _t1776,)) if msg.syntax_escapechar is not None: assert msg.syntax_escapechar is not None - _t1773 = self._make_value_string(msg.syntax_escapechar) - result.append(("syntax_escapechar", _t1773,)) + _t1777 = self._make_value_string(msg.syntax_escapechar) + result.append(("syntax_escapechar", _t1777,)) return sorted(result) def mask_secret_value(self, pair: tuple[str, str]) -> str: @@ -356,7 +356,7 @@ def deconstruct_iceberg_catalog_config_scope_optional(self, msg: logic_pb2.Icebe assert msg.scope is not None return msg.scope else: - _t1774 = None + _t1778 = None return None def deconstruct_iceberg_data_from_snapshot_optional(self, msg: logic_pb2.IcebergData) -> str | None: @@ -365,7 +365,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: - _t1775 = None + _t1779 = None return None def deconstruct_iceberg_data_to_snapshot_optional(self, msg: logic_pb2.IcebergData) -> str | None: @@ -374,7 +374,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: - _t1776 = None + _t1780 = None return None def deconstruct_export_iceberg_config_optional(self, msg: transactions_pb2.ExportIcebergConfig) -> Sequence[tuple[str, logic_pb2.Value]] | None: @@ -382,20 +382,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 - _t1777 = self._make_value_string(msg.prefix) - result.append(("prefix", _t1777,)) + _t1781 = self._make_value_string(msg.prefix) + result.append(("prefix", _t1781,)) 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 - _t1778 = self._make_value_int64(msg.target_file_size_bytes) - result.append(("target_file_size_bytes", _t1778,)) + _t1782 = self._make_value_int64(msg.target_file_size_bytes) + result.append(("target_file_size_bytes", _t1782,)) if msg.compression != "": - _t1779 = self._make_value_string(msg.compression) - result.append(("compression", _t1779,)) + _t1783 = self._make_value_string(msg.compression) + result.append(("compression", _t1783,)) if len(result) == 0: return None else: - _t1780 = None + _t1784 = None return sorted(result) def deconstruct_relation_id_string(self, msg: logic_pb2.RelationId) -> str: @@ -408,7 +408,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: - _t1781 = None + _t1785 = None return None def deconstruct_bindings(self, abs: logic_pb2.Abstraction) -> tuple[Sequence[logic_pb2.Binding], Sequence[logic_pb2.Binding]]: @@ -423,3933 +423,3937 @@ def deconstruct_bindings_with_arity(self, abs: logic_pb2.Abstraction, value_arit # --- Pretty-print methods --- def pretty_transaction(self, msg: transactions_pb2.Transaction): - flat807 = self._try_flat(msg, self.pretty_transaction) - if flat807 is not None: - assert flat807 is not None - self.write(flat807) + flat809 = self._try_flat(msg, self.pretty_transaction) + if flat809 is not None: + assert flat809 is not None + self.write(flat809) return None else: _dollar_dollar = msg if _dollar_dollar.HasField("configure"): - _t1596 = _dollar_dollar.configure + _t1600 = _dollar_dollar.configure else: - _t1596 = None + _t1600 = None if _dollar_dollar.HasField("sync"): - _t1597 = _dollar_dollar.sync + _t1601 = _dollar_dollar.sync else: - _t1597 = None - fields798 = (_t1596, _t1597, _dollar_dollar.epochs,) - assert fields798 is not None - unwrapped_fields799 = fields798 + _t1601 = None + fields800 = (_t1600, _t1601, _dollar_dollar.epochs,) + assert fields800 is not None + unwrapped_fields801 = fields800 self.write("(transaction") self.indent_sexp() - field800 = unwrapped_fields799[0] - if field800 is not None: - self.newline() - assert field800 is not None - opt_val801 = field800 - self.pretty_configure(opt_val801) - field802 = unwrapped_fields799[1] + field802 = unwrapped_fields801[0] if field802 is not None: self.newline() assert field802 is not None opt_val803 = field802 - self.pretty_sync(opt_val803) - field804 = unwrapped_fields799[2] - if not len(field804) == 0: + self.pretty_configure(opt_val803) + field804 = unwrapped_fields801[1] + if field804 is not None: self.newline() - for i806, elem805 in enumerate(field804): - if (i806 > 0): + assert field804 is not None + opt_val805 = field804 + self.pretty_sync(opt_val805) + field806 = unwrapped_fields801[2] + if not len(field806) == 0: + self.newline() + for i808, elem807 in enumerate(field806): + if (i808 > 0): self.newline() - self.pretty_epoch(elem805) + self.pretty_epoch(elem807) self.dedent() self.write(")") def pretty_configure(self, msg: transactions_pb2.Configure): - flat810 = self._try_flat(msg, self.pretty_configure) - if flat810 is not None: - assert flat810 is not None - self.write(flat810) + flat812 = self._try_flat(msg, self.pretty_configure) + if flat812 is not None: + assert flat812 is not None + self.write(flat812) return None else: _dollar_dollar = msg - _t1598 = self.deconstruct_configure(_dollar_dollar) - fields808 = _t1598 - assert fields808 is not None - unwrapped_fields809 = fields808 + _t1602 = self.deconstruct_configure(_dollar_dollar) + fields810 = _t1602 + assert fields810 is not None + unwrapped_fields811 = fields810 self.write("(configure") self.indent_sexp() self.newline() - self.pretty_config_dict(unwrapped_fields809) + self.pretty_config_dict(unwrapped_fields811) self.dedent() self.write(")") def pretty_config_dict(self, msg: Sequence[tuple[str, logic_pb2.Value]]): - flat814 = self._try_flat(msg, self.pretty_config_dict) - if flat814 is not None: - assert flat814 is not None - self.write(flat814) + flat816 = self._try_flat(msg, self.pretty_config_dict) + if flat816 is not None: + assert flat816 is not None + self.write(flat816) return None else: - fields811 = msg + fields813 = msg self.write("{") self.indent() - if not len(fields811) == 0: + if not len(fields813) == 0: self.newline() - for i813, elem812 in enumerate(fields811): - if (i813 > 0): + for i815, elem814 in enumerate(fields813): + if (i815 > 0): self.newline() - self.pretty_config_key_value(elem812) + self.pretty_config_key_value(elem814) self.dedent() self.write("}") def pretty_config_key_value(self, msg: tuple[str, logic_pb2.Value]): - flat819 = self._try_flat(msg, self.pretty_config_key_value) - if flat819 is not None: - assert flat819 is not None - self.write(flat819) + flat821 = self._try_flat(msg, self.pretty_config_key_value) + if flat821 is not None: + assert flat821 is not None + self.write(flat821) return None else: _dollar_dollar = msg - fields815 = (_dollar_dollar[0], _dollar_dollar[1],) - assert fields815 is not None - unwrapped_fields816 = fields815 + fields817 = (_dollar_dollar[0], _dollar_dollar[1],) + assert fields817 is not None + unwrapped_fields818 = fields817 self.write(":") - field817 = unwrapped_fields816[0] - self.write(field817) + field819 = unwrapped_fields818[0] + self.write(field819) self.write(" ") - field818 = unwrapped_fields816[1] - self.pretty_raw_value(field818) + field820 = unwrapped_fields818[1] + self.pretty_raw_value(field820) def pretty_raw_value(self, msg: logic_pb2.Value): - flat845 = self._try_flat(msg, self.pretty_raw_value) - if flat845 is not None: - assert flat845 is not None - self.write(flat845) + flat847 = self._try_flat(msg, self.pretty_raw_value) + if flat847 is not None: + assert flat847 is not None + self.write(flat847) return None else: _dollar_dollar = msg if _dollar_dollar.HasField("date_value"): - _t1599 = _dollar_dollar.date_value + _t1603 = _dollar_dollar.date_value else: - _t1599 = None - deconstruct_result843 = _t1599 - if deconstruct_result843 is not None: - assert deconstruct_result843 is not None - unwrapped844 = deconstruct_result843 - self.pretty_raw_date(unwrapped844) + _t1603 = None + deconstruct_result845 = _t1603 + if deconstruct_result845 is not None: + assert deconstruct_result845 is not None + unwrapped846 = deconstruct_result845 + self.pretty_raw_date(unwrapped846) else: _dollar_dollar = msg if _dollar_dollar.HasField("datetime_value"): - _t1600 = _dollar_dollar.datetime_value + _t1604 = _dollar_dollar.datetime_value else: - _t1600 = None - deconstruct_result841 = _t1600 - if deconstruct_result841 is not None: - assert deconstruct_result841 is not None - unwrapped842 = deconstruct_result841 - self.pretty_raw_datetime(unwrapped842) + _t1604 = None + deconstruct_result843 = _t1604 + if deconstruct_result843 is not None: + assert deconstruct_result843 is not None + unwrapped844 = deconstruct_result843 + self.pretty_raw_datetime(unwrapped844) else: _dollar_dollar = msg if _dollar_dollar.HasField("string_value"): - _t1601 = _dollar_dollar.string_value + _t1605 = _dollar_dollar.string_value else: - _t1601 = None - deconstruct_result839 = _t1601 - if deconstruct_result839 is not None: - assert deconstruct_result839 is not None - unwrapped840 = deconstruct_result839 - self.write(self.format_string_value(unwrapped840)) + _t1605 = None + deconstruct_result841 = _t1605 + if deconstruct_result841 is not None: + assert deconstruct_result841 is not None + unwrapped842 = deconstruct_result841 + self.write(self.format_string_value(unwrapped842)) else: _dollar_dollar = msg if _dollar_dollar.HasField("int32_value"): - _t1602 = _dollar_dollar.int32_value + _t1606 = _dollar_dollar.int32_value else: - _t1602 = None - deconstruct_result837 = _t1602 - if deconstruct_result837 is not None: - assert deconstruct_result837 is not None - unwrapped838 = deconstruct_result837 - self.write((str(unwrapped838) + 'i32')) + _t1606 = None + deconstruct_result839 = _t1606 + if deconstruct_result839 is not None: + assert deconstruct_result839 is not None + unwrapped840 = deconstruct_result839 + self.write((str(unwrapped840) + 'i32')) else: _dollar_dollar = msg if _dollar_dollar.HasField("int_value"): - _t1603 = _dollar_dollar.int_value + _t1607 = _dollar_dollar.int_value else: - _t1603 = None - deconstruct_result835 = _t1603 - if deconstruct_result835 is not None: - assert deconstruct_result835 is not None - unwrapped836 = deconstruct_result835 - self.write(str(unwrapped836)) + _t1607 = None + deconstruct_result837 = _t1607 + if deconstruct_result837 is not None: + assert deconstruct_result837 is not None + unwrapped838 = deconstruct_result837 + self.write(str(unwrapped838)) else: _dollar_dollar = msg if _dollar_dollar.HasField("float32_value"): - _t1604 = _dollar_dollar.float32_value + _t1608 = _dollar_dollar.float32_value else: - _t1604 = None - deconstruct_result833 = _t1604 - if deconstruct_result833 is not None: - assert deconstruct_result833 is not None - unwrapped834 = deconstruct_result833 - self.write(self.format_float32_literal(unwrapped834)) + _t1608 = None + deconstruct_result835 = _t1608 + if deconstruct_result835 is not None: + assert deconstruct_result835 is not None + unwrapped836 = deconstruct_result835 + self.write(self.format_float32_literal(unwrapped836)) else: _dollar_dollar = msg if _dollar_dollar.HasField("float_value"): - _t1605 = _dollar_dollar.float_value + _t1609 = _dollar_dollar.float_value else: - _t1605 = None - deconstruct_result831 = _t1605 - if deconstruct_result831 is not None: - assert deconstruct_result831 is not None - unwrapped832 = deconstruct_result831 - self.write(str(unwrapped832)) + _t1609 = None + deconstruct_result833 = _t1609 + if deconstruct_result833 is not None: + assert deconstruct_result833 is not None + unwrapped834 = deconstruct_result833 + self.write(str(unwrapped834)) else: _dollar_dollar = msg if _dollar_dollar.HasField("uint32_value"): - _t1606 = _dollar_dollar.uint32_value + _t1610 = _dollar_dollar.uint32_value else: - _t1606 = None - deconstruct_result829 = _t1606 - if deconstruct_result829 is not None: - assert deconstruct_result829 is not None - unwrapped830 = deconstruct_result829 - self.write((str(unwrapped830) + 'u32')) + _t1610 = None + deconstruct_result831 = _t1610 + if deconstruct_result831 is not None: + assert deconstruct_result831 is not None + unwrapped832 = deconstruct_result831 + self.write((str(unwrapped832) + 'u32')) else: _dollar_dollar = msg if _dollar_dollar.HasField("uint128_value"): - _t1607 = _dollar_dollar.uint128_value + _t1611 = _dollar_dollar.uint128_value else: - _t1607 = None - deconstruct_result827 = _t1607 - if deconstruct_result827 is not None: - assert deconstruct_result827 is not None - unwrapped828 = deconstruct_result827 - self.write(self.format_uint128(unwrapped828)) + _t1611 = None + deconstruct_result829 = _t1611 + if deconstruct_result829 is not None: + assert deconstruct_result829 is not None + unwrapped830 = deconstruct_result829 + self.write(self.format_uint128(unwrapped830)) else: _dollar_dollar = msg if _dollar_dollar.HasField("int128_value"): - _t1608 = _dollar_dollar.int128_value + _t1612 = _dollar_dollar.int128_value else: - _t1608 = None - deconstruct_result825 = _t1608 - if deconstruct_result825 is not None: - assert deconstruct_result825 is not None - unwrapped826 = deconstruct_result825 - self.write(self.format_int128(unwrapped826)) + _t1612 = None + deconstruct_result827 = _t1612 + if deconstruct_result827 is not None: + assert deconstruct_result827 is not None + unwrapped828 = deconstruct_result827 + self.write(self.format_int128(unwrapped828)) else: _dollar_dollar = msg if _dollar_dollar.HasField("decimal_value"): - _t1609 = _dollar_dollar.decimal_value + _t1613 = _dollar_dollar.decimal_value else: - _t1609 = None - deconstruct_result823 = _t1609 - if deconstruct_result823 is not None: - assert deconstruct_result823 is not None - unwrapped824 = deconstruct_result823 - self.write(self.format_decimal(unwrapped824)) + _t1613 = None + deconstruct_result825 = _t1613 + if deconstruct_result825 is not None: + assert deconstruct_result825 is not None + unwrapped826 = deconstruct_result825 + self.write(self.format_decimal(unwrapped826)) else: _dollar_dollar = msg if _dollar_dollar.HasField("boolean_value"): - _t1610 = _dollar_dollar.boolean_value + _t1614 = _dollar_dollar.boolean_value else: - _t1610 = None - deconstruct_result821 = _t1610 - if deconstruct_result821 is not None: - assert deconstruct_result821 is not None - unwrapped822 = deconstruct_result821 - self.pretty_boolean_value(unwrapped822) + _t1614 = None + deconstruct_result823 = _t1614 + if deconstruct_result823 is not None: + assert deconstruct_result823 is not None + unwrapped824 = deconstruct_result823 + self.pretty_boolean_value(unwrapped824) else: - fields820 = msg + fields822 = msg self.write("missing") def pretty_raw_date(self, msg: logic_pb2.DateValue): - flat851 = self._try_flat(msg, self.pretty_raw_date) - if flat851 is not None: - assert flat851 is not None - self.write(flat851) + flat853 = self._try_flat(msg, self.pretty_raw_date) + if flat853 is not None: + assert flat853 is not None + self.write(flat853) return None else: _dollar_dollar = msg - fields846 = (int(_dollar_dollar.year), int(_dollar_dollar.month), int(_dollar_dollar.day),) - assert fields846 is not None - unwrapped_fields847 = fields846 + fields848 = (int(_dollar_dollar.year), int(_dollar_dollar.month), int(_dollar_dollar.day),) + assert fields848 is not None + unwrapped_fields849 = fields848 self.write("(date") self.indent_sexp() self.newline() - field848 = unwrapped_fields847[0] - self.write(str(field848)) + field850 = unwrapped_fields849[0] + self.write(str(field850)) self.newline() - field849 = unwrapped_fields847[1] - self.write(str(field849)) + field851 = unwrapped_fields849[1] + self.write(str(field851)) self.newline() - field850 = unwrapped_fields847[2] - self.write(str(field850)) + field852 = unwrapped_fields849[2] + self.write(str(field852)) self.dedent() self.write(")") def pretty_raw_datetime(self, msg: logic_pb2.DateTimeValue): - flat862 = self._try_flat(msg, self.pretty_raw_datetime) - if flat862 is not None: - assert flat862 is not None - self.write(flat862) + flat864 = self._try_flat(msg, self.pretty_raw_datetime) + if flat864 is not None: + assert flat864 is not None + self.write(flat864) return None else: _dollar_dollar = msg - fields852 = (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 fields852 is not None - unwrapped_fields853 = fields852 + fields854 = (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 fields854 is not None + unwrapped_fields855 = fields854 self.write("(datetime") self.indent_sexp() self.newline() - field854 = unwrapped_fields853[0] - self.write(str(field854)) - self.newline() - field855 = unwrapped_fields853[1] - self.write(str(field855)) - self.newline() - field856 = unwrapped_fields853[2] + field856 = unwrapped_fields855[0] self.write(str(field856)) self.newline() - field857 = unwrapped_fields853[3] + field857 = unwrapped_fields855[1] self.write(str(field857)) self.newline() - field858 = unwrapped_fields853[4] + field858 = unwrapped_fields855[2] self.write(str(field858)) self.newline() - field859 = unwrapped_fields853[5] + field859 = unwrapped_fields855[3] self.write(str(field859)) - field860 = unwrapped_fields853[6] - if field860 is not None: + self.newline() + field860 = unwrapped_fields855[4] + self.write(str(field860)) + self.newline() + field861 = unwrapped_fields855[5] + self.write(str(field861)) + field862 = unwrapped_fields855[6] + if field862 is not None: self.newline() - assert field860 is not None - opt_val861 = field860 - self.write(str(opt_val861)) + assert field862 is not None + opt_val863 = field862 + self.write(str(opt_val863)) self.dedent() self.write(")") def pretty_boolean_value(self, msg: bool): _dollar_dollar = msg if _dollar_dollar: - _t1611 = () + _t1615 = () else: - _t1611 = None - deconstruct_result865 = _t1611 - if deconstruct_result865 is not None: - assert deconstruct_result865 is not None - unwrapped866 = deconstruct_result865 + _t1615 = None + deconstruct_result867 = _t1615 + if deconstruct_result867 is not None: + assert deconstruct_result867 is not None + unwrapped868 = deconstruct_result867 self.write("true") else: _dollar_dollar = msg if not _dollar_dollar: - _t1612 = () + _t1616 = () else: - _t1612 = None - deconstruct_result863 = _t1612 - if deconstruct_result863 is not None: - assert deconstruct_result863 is not None - unwrapped864 = deconstruct_result863 + _t1616 = None + deconstruct_result865 = _t1616 + if deconstruct_result865 is not None: + assert deconstruct_result865 is not None + unwrapped866 = deconstruct_result865 self.write("false") else: raise ParseError("No matching rule for boolean_value") def pretty_sync(self, msg: transactions_pb2.Sync): - flat871 = self._try_flat(msg, self.pretty_sync) - if flat871 is not None: - assert flat871 is not None - self.write(flat871) + flat873 = self._try_flat(msg, self.pretty_sync) + if flat873 is not None: + assert flat873 is not None + self.write(flat873) return None else: _dollar_dollar = msg - fields867 = _dollar_dollar.fragments - assert fields867 is not None - unwrapped_fields868 = fields867 + fields869 = _dollar_dollar.fragments + assert fields869 is not None + unwrapped_fields870 = fields869 self.write("(sync") self.indent_sexp() - if not len(unwrapped_fields868) == 0: + if not len(unwrapped_fields870) == 0: self.newline() - for i870, elem869 in enumerate(unwrapped_fields868): - if (i870 > 0): + for i872, elem871 in enumerate(unwrapped_fields870): + if (i872 > 0): self.newline() - self.pretty_fragment_id(elem869) + self.pretty_fragment_id(elem871) self.dedent() self.write(")") def pretty_fragment_id(self, msg: fragments_pb2.FragmentId): - flat874 = self._try_flat(msg, self.pretty_fragment_id) - if flat874 is not None: - assert flat874 is not None - self.write(flat874) + flat876 = self._try_flat(msg, self.pretty_fragment_id) + if flat876 is not None: + assert flat876 is not None + self.write(flat876) return None else: _dollar_dollar = msg - fields872 = self.fragment_id_to_string(_dollar_dollar) - assert fields872 is not None - unwrapped_fields873 = fields872 + fields874 = self.fragment_id_to_string(_dollar_dollar) + assert fields874 is not None + unwrapped_fields875 = fields874 self.write(":") - self.write(unwrapped_fields873) + self.write(unwrapped_fields875) def pretty_epoch(self, msg: transactions_pb2.Epoch): - flat881 = self._try_flat(msg, self.pretty_epoch) - if flat881 is not None: - assert flat881 is not None - self.write(flat881) + flat883 = self._try_flat(msg, self.pretty_epoch) + if flat883 is not None: + assert flat883 is not None + self.write(flat883) return None else: _dollar_dollar = msg if not len(_dollar_dollar.writes) == 0: - _t1613 = _dollar_dollar.writes + _t1617 = _dollar_dollar.writes else: - _t1613 = None + _t1617 = None if not len(_dollar_dollar.reads) == 0: - _t1614 = _dollar_dollar.reads + _t1618 = _dollar_dollar.reads else: - _t1614 = None - fields875 = (_t1613, _t1614,) - assert fields875 is not None - unwrapped_fields876 = fields875 + _t1618 = None + fields877 = (_t1617, _t1618,) + assert fields877 is not None + unwrapped_fields878 = fields877 self.write("(epoch") self.indent_sexp() - field877 = unwrapped_fields876[0] - if field877 is not None: - self.newline() - assert field877 is not None - opt_val878 = field877 - self.pretty_epoch_writes(opt_val878) - field879 = unwrapped_fields876[1] + field879 = unwrapped_fields878[0] if field879 is not None: self.newline() assert field879 is not None opt_val880 = field879 - self.pretty_epoch_reads(opt_val880) + self.pretty_epoch_writes(opt_val880) + field881 = unwrapped_fields878[1] + if field881 is not None: + self.newline() + assert field881 is not None + opt_val882 = field881 + self.pretty_epoch_reads(opt_val882) self.dedent() self.write(")") def pretty_epoch_writes(self, msg: Sequence[transactions_pb2.Write]): - flat885 = self._try_flat(msg, self.pretty_epoch_writes) - if flat885 is not None: - assert flat885 is not None - self.write(flat885) + flat887 = self._try_flat(msg, self.pretty_epoch_writes) + if flat887 is not None: + assert flat887 is not None + self.write(flat887) return None else: - fields882 = msg + fields884 = msg self.write("(writes") self.indent_sexp() - if not len(fields882) == 0: + if not len(fields884) == 0: self.newline() - for i884, elem883 in enumerate(fields882): - if (i884 > 0): + for i886, elem885 in enumerate(fields884): + if (i886 > 0): self.newline() - self.pretty_write(elem883) + self.pretty_write(elem885) self.dedent() self.write(")") def pretty_write(self, msg: transactions_pb2.Write): - flat894 = self._try_flat(msg, self.pretty_write) - if flat894 is not None: - assert flat894 is not None - self.write(flat894) + flat896 = self._try_flat(msg, self.pretty_write) + if flat896 is not None: + assert flat896 is not None + self.write(flat896) return None else: _dollar_dollar = msg if _dollar_dollar.HasField("define"): - _t1615 = _dollar_dollar.define + _t1619 = _dollar_dollar.define else: - _t1615 = None - deconstruct_result892 = _t1615 - if deconstruct_result892 is not None: - assert deconstruct_result892 is not None - unwrapped893 = deconstruct_result892 - self.pretty_define(unwrapped893) + _t1619 = None + deconstruct_result894 = _t1619 + if deconstruct_result894 is not None: + assert deconstruct_result894 is not None + unwrapped895 = deconstruct_result894 + self.pretty_define(unwrapped895) else: _dollar_dollar = msg if _dollar_dollar.HasField("undefine"): - _t1616 = _dollar_dollar.undefine + _t1620 = _dollar_dollar.undefine else: - _t1616 = None - deconstruct_result890 = _t1616 - if deconstruct_result890 is not None: - assert deconstruct_result890 is not None - unwrapped891 = deconstruct_result890 - self.pretty_undefine(unwrapped891) + _t1620 = None + deconstruct_result892 = _t1620 + if deconstruct_result892 is not None: + assert deconstruct_result892 is not None + unwrapped893 = deconstruct_result892 + self.pretty_undefine(unwrapped893) else: _dollar_dollar = msg if _dollar_dollar.HasField("context"): - _t1617 = _dollar_dollar.context + _t1621 = _dollar_dollar.context else: - _t1617 = None - deconstruct_result888 = _t1617 - if deconstruct_result888 is not None: - assert deconstruct_result888 is not None - unwrapped889 = deconstruct_result888 - self.pretty_context(unwrapped889) + _t1621 = None + deconstruct_result890 = _t1621 + if deconstruct_result890 is not None: + assert deconstruct_result890 is not None + unwrapped891 = deconstruct_result890 + self.pretty_context(unwrapped891) else: _dollar_dollar = msg if _dollar_dollar.HasField("snapshot"): - _t1618 = _dollar_dollar.snapshot + _t1622 = _dollar_dollar.snapshot else: - _t1618 = None - deconstruct_result886 = _t1618 - if deconstruct_result886 is not None: - assert deconstruct_result886 is not None - unwrapped887 = deconstruct_result886 - self.pretty_snapshot(unwrapped887) + _t1622 = None + deconstruct_result888 = _t1622 + if deconstruct_result888 is not None: + assert deconstruct_result888 is not None + unwrapped889 = deconstruct_result888 + self.pretty_snapshot(unwrapped889) else: raise ParseError("No matching rule for write") def pretty_define(self, msg: transactions_pb2.Define): - flat897 = self._try_flat(msg, self.pretty_define) - if flat897 is not None: - assert flat897 is not None - self.write(flat897) + flat899 = self._try_flat(msg, self.pretty_define) + if flat899 is not None: + assert flat899 is not None + self.write(flat899) return None else: _dollar_dollar = msg - fields895 = _dollar_dollar.fragment - assert fields895 is not None - unwrapped_fields896 = fields895 + fields897 = _dollar_dollar.fragment + assert fields897 is not None + unwrapped_fields898 = fields897 self.write("(define") self.indent_sexp() self.newline() - self.pretty_fragment(unwrapped_fields896) + self.pretty_fragment(unwrapped_fields898) self.dedent() self.write(")") def pretty_fragment(self, msg: fragments_pb2.Fragment): - flat904 = self._try_flat(msg, self.pretty_fragment) - if flat904 is not None: - assert flat904 is not None - self.write(flat904) + flat906 = self._try_flat(msg, self.pretty_fragment) + if flat906 is not None: + assert flat906 is not None + self.write(flat906) return None else: _dollar_dollar = msg self.start_pretty_fragment(_dollar_dollar) - fields898 = (_dollar_dollar.id, _dollar_dollar.declarations,) - assert fields898 is not None - unwrapped_fields899 = fields898 + fields900 = (_dollar_dollar.id, _dollar_dollar.declarations,) + assert fields900 is not None + unwrapped_fields901 = fields900 self.write("(fragment") self.indent_sexp() self.newline() - field900 = unwrapped_fields899[0] - self.pretty_new_fragment_id(field900) - field901 = unwrapped_fields899[1] - if not len(field901) == 0: + field902 = unwrapped_fields901[0] + self.pretty_new_fragment_id(field902) + field903 = unwrapped_fields901[1] + if not len(field903) == 0: self.newline() - for i903, elem902 in enumerate(field901): - if (i903 > 0): + for i905, elem904 in enumerate(field903): + if (i905 > 0): self.newline() - self.pretty_declaration(elem902) + self.pretty_declaration(elem904) self.dedent() self.write(")") def pretty_new_fragment_id(self, msg: fragments_pb2.FragmentId): - flat906 = self._try_flat(msg, self.pretty_new_fragment_id) - if flat906 is not None: - assert flat906 is not None - self.write(flat906) + flat908 = self._try_flat(msg, self.pretty_new_fragment_id) + if flat908 is not None: + assert flat908 is not None + self.write(flat908) return None else: - fields905 = msg - self.pretty_fragment_id(fields905) + fields907 = msg + self.pretty_fragment_id(fields907) def pretty_declaration(self, msg: logic_pb2.Declaration): - flat915 = self._try_flat(msg, self.pretty_declaration) - if flat915 is not None: - assert flat915 is not None - self.write(flat915) + flat917 = self._try_flat(msg, self.pretty_declaration) + if flat917 is not None: + assert flat917 is not None + self.write(flat917) return None else: _dollar_dollar = msg if _dollar_dollar.HasField("def"): - _t1619 = getattr(_dollar_dollar, 'def') + _t1623 = getattr(_dollar_dollar, 'def') else: - _t1619 = None - deconstruct_result913 = _t1619 - if deconstruct_result913 is not None: - assert deconstruct_result913 is not None - unwrapped914 = deconstruct_result913 - self.pretty_def(unwrapped914) + _t1623 = None + deconstruct_result915 = _t1623 + if deconstruct_result915 is not None: + assert deconstruct_result915 is not None + unwrapped916 = deconstruct_result915 + self.pretty_def(unwrapped916) else: _dollar_dollar = msg if _dollar_dollar.HasField("algorithm"): - _t1620 = _dollar_dollar.algorithm + _t1624 = _dollar_dollar.algorithm else: - _t1620 = None - deconstruct_result911 = _t1620 - if deconstruct_result911 is not None: - assert deconstruct_result911 is not None - unwrapped912 = deconstruct_result911 - self.pretty_algorithm(unwrapped912) + _t1624 = None + deconstruct_result913 = _t1624 + if deconstruct_result913 is not None: + assert deconstruct_result913 is not None + unwrapped914 = deconstruct_result913 + self.pretty_algorithm(unwrapped914) else: _dollar_dollar = msg if _dollar_dollar.HasField("constraint"): - _t1621 = _dollar_dollar.constraint + _t1625 = _dollar_dollar.constraint else: - _t1621 = None - deconstruct_result909 = _t1621 - if deconstruct_result909 is not None: - assert deconstruct_result909 is not None - unwrapped910 = deconstruct_result909 - self.pretty_constraint(unwrapped910) + _t1625 = None + deconstruct_result911 = _t1625 + if deconstruct_result911 is not None: + assert deconstruct_result911 is not None + unwrapped912 = deconstruct_result911 + self.pretty_constraint(unwrapped912) else: _dollar_dollar = msg if _dollar_dollar.HasField("data"): - _t1622 = _dollar_dollar.data + _t1626 = _dollar_dollar.data else: - _t1622 = None - deconstruct_result907 = _t1622 - if deconstruct_result907 is not None: - assert deconstruct_result907 is not None - unwrapped908 = deconstruct_result907 - self.pretty_data(unwrapped908) + _t1626 = None + deconstruct_result909 = _t1626 + if deconstruct_result909 is not None: + assert deconstruct_result909 is not None + unwrapped910 = deconstruct_result909 + self.pretty_data(unwrapped910) else: raise ParseError("No matching rule for declaration") def pretty_def(self, msg: logic_pb2.Def): - flat922 = self._try_flat(msg, self.pretty_def) - if flat922 is not None: - assert flat922 is not None - self.write(flat922) + flat924 = self._try_flat(msg, self.pretty_def) + if flat924 is not None: + assert flat924 is not None + self.write(flat924) return None else: _dollar_dollar = msg if not len(_dollar_dollar.attrs) == 0: - _t1623 = _dollar_dollar.attrs + _t1627 = _dollar_dollar.attrs else: - _t1623 = None - fields916 = (_dollar_dollar.name, _dollar_dollar.body, _t1623,) - assert fields916 is not None - unwrapped_fields917 = fields916 + _t1627 = None + fields918 = (_dollar_dollar.name, _dollar_dollar.body, _t1627,) + assert fields918 is not None + unwrapped_fields919 = fields918 self.write("(def") self.indent_sexp() self.newline() - field918 = unwrapped_fields917[0] - self.pretty_relation_id(field918) + field920 = unwrapped_fields919[0] + self.pretty_relation_id(field920) self.newline() - field919 = unwrapped_fields917[1] - self.pretty_abstraction(field919) - field920 = unwrapped_fields917[2] - if field920 is not None: + field921 = unwrapped_fields919[1] + self.pretty_abstraction(field921) + field922 = unwrapped_fields919[2] + if field922 is not None: self.newline() - assert field920 is not None - opt_val921 = field920 - self.pretty_attrs(opt_val921) + assert field922 is not None + opt_val923 = field922 + self.pretty_attrs(opt_val923) self.dedent() self.write(")") def pretty_relation_id(self, msg: logic_pb2.RelationId): - flat927 = self._try_flat(msg, self.pretty_relation_id) - if flat927 is not None: - assert flat927 is not None - self.write(flat927) + flat929 = self._try_flat(msg, self.pretty_relation_id) + if flat929 is not None: + assert flat929 is not None + self.write(flat929) return None else: _dollar_dollar = msg if self.relation_id_to_string(_dollar_dollar) is not None: - _t1625 = self.deconstruct_relation_id_string(_dollar_dollar) - _t1624 = _t1625 + _t1629 = self.deconstruct_relation_id_string(_dollar_dollar) + _t1628 = _t1629 else: - _t1624 = None - deconstruct_result925 = _t1624 - if deconstruct_result925 is not None: - assert deconstruct_result925 is not None - unwrapped926 = deconstruct_result925 + _t1628 = None + deconstruct_result927 = _t1628 + if deconstruct_result927 is not None: + assert deconstruct_result927 is not None + unwrapped928 = deconstruct_result927 self.write(":") - self.write(unwrapped926) + self.write(unwrapped928) else: _dollar_dollar = msg - _t1626 = self.deconstruct_relation_id_uint128(_dollar_dollar) - deconstruct_result923 = _t1626 - if deconstruct_result923 is not None: - assert deconstruct_result923 is not None - unwrapped924 = deconstruct_result923 - self.write(self.format_uint128(unwrapped924)) + _t1630 = self.deconstruct_relation_id_uint128(_dollar_dollar) + deconstruct_result925 = _t1630 + if deconstruct_result925 is not None: + assert deconstruct_result925 is not None + unwrapped926 = deconstruct_result925 + self.write(self.format_uint128(unwrapped926)) else: raise ParseError("No matching rule for relation_id") def pretty_abstraction(self, msg: logic_pb2.Abstraction): - flat932 = self._try_flat(msg, self.pretty_abstraction) - if flat932 is not None: - assert flat932 is not None - self.write(flat932) + flat934 = self._try_flat(msg, self.pretty_abstraction) + if flat934 is not None: + assert flat934 is not None + self.write(flat934) return None else: _dollar_dollar = msg - _t1627 = self.deconstruct_bindings(_dollar_dollar) - fields928 = (_t1627, _dollar_dollar.value,) - assert fields928 is not None - unwrapped_fields929 = fields928 + _t1631 = self.deconstruct_bindings(_dollar_dollar) + fields930 = (_t1631, _dollar_dollar.value,) + assert fields930 is not None + unwrapped_fields931 = fields930 self.write("(") self.indent() - field930 = unwrapped_fields929[0] - self.pretty_bindings(field930) + field932 = unwrapped_fields931[0] + self.pretty_bindings(field932) self.newline() - field931 = unwrapped_fields929[1] - self.pretty_formula(field931) + field933 = unwrapped_fields931[1] + self.pretty_formula(field933) self.dedent() self.write(")") def pretty_bindings(self, msg: tuple[Sequence[logic_pb2.Binding], Sequence[logic_pb2.Binding]]): - flat940 = self._try_flat(msg, self.pretty_bindings) - if flat940 is not None: - assert flat940 is not None - self.write(flat940) + flat942 = self._try_flat(msg, self.pretty_bindings) + if flat942 is not None: + assert flat942 is not None + self.write(flat942) return None else: _dollar_dollar = msg if not len(_dollar_dollar[1]) == 0: - _t1628 = _dollar_dollar[1] + _t1632 = _dollar_dollar[1] else: - _t1628 = None - fields933 = (_dollar_dollar[0], _t1628,) - assert fields933 is not None - unwrapped_fields934 = fields933 + _t1632 = None + fields935 = (_dollar_dollar[0], _t1632,) + assert fields935 is not None + unwrapped_fields936 = fields935 self.write("[") self.indent() - field935 = unwrapped_fields934[0] - for i937, elem936 in enumerate(field935): - if (i937 > 0): + field937 = unwrapped_fields936[0] + for i939, elem938 in enumerate(field937): + if (i939 > 0): self.newline() - self.pretty_binding(elem936) - field938 = unwrapped_fields934[1] - if field938 is not None: + self.pretty_binding(elem938) + field940 = unwrapped_fields936[1] + if field940 is not None: self.newline() - assert field938 is not None - opt_val939 = field938 - self.pretty_value_bindings(opt_val939) + assert field940 is not None + opt_val941 = field940 + self.pretty_value_bindings(opt_val941) self.dedent() self.write("]") def pretty_binding(self, msg: logic_pb2.Binding): - flat945 = self._try_flat(msg, self.pretty_binding) - if flat945 is not None: - assert flat945 is not None - self.write(flat945) + flat947 = self._try_flat(msg, self.pretty_binding) + if flat947 is not None: + assert flat947 is not None + self.write(flat947) return None else: _dollar_dollar = msg - fields941 = (_dollar_dollar.var.name, _dollar_dollar.type,) - assert fields941 is not None - unwrapped_fields942 = fields941 - field943 = unwrapped_fields942[0] - self.write(field943) + fields943 = (_dollar_dollar.var.name, _dollar_dollar.type,) + assert fields943 is not None + unwrapped_fields944 = fields943 + field945 = unwrapped_fields944[0] + self.write(field945) self.write("::") - field944 = unwrapped_fields942[1] - self.pretty_type(field944) + field946 = unwrapped_fields944[1] + self.pretty_type(field946) def pretty_type(self, msg: logic_pb2.Type): - flat974 = self._try_flat(msg, self.pretty_type) - if flat974 is not None: - assert flat974 is not None - self.write(flat974) + flat976 = self._try_flat(msg, self.pretty_type) + if flat976 is not None: + assert flat976 is not None + self.write(flat976) return None else: _dollar_dollar = msg if _dollar_dollar.HasField("unspecified_type"): - _t1629 = _dollar_dollar.unspecified_type + _t1633 = _dollar_dollar.unspecified_type else: - _t1629 = None - deconstruct_result972 = _t1629 - if deconstruct_result972 is not None: - assert deconstruct_result972 is not None - unwrapped973 = deconstruct_result972 - self.pretty_unspecified_type(unwrapped973) + _t1633 = None + deconstruct_result974 = _t1633 + if deconstruct_result974 is not None: + assert deconstruct_result974 is not None + unwrapped975 = deconstruct_result974 + self.pretty_unspecified_type(unwrapped975) else: _dollar_dollar = msg if _dollar_dollar.HasField("string_type"): - _t1630 = _dollar_dollar.string_type + _t1634 = _dollar_dollar.string_type else: - _t1630 = None - deconstruct_result970 = _t1630 - if deconstruct_result970 is not None: - assert deconstruct_result970 is not None - unwrapped971 = deconstruct_result970 - self.pretty_string_type(unwrapped971) + _t1634 = None + deconstruct_result972 = _t1634 + if deconstruct_result972 is not None: + assert deconstruct_result972 is not None + unwrapped973 = deconstruct_result972 + self.pretty_string_type(unwrapped973) else: _dollar_dollar = msg if _dollar_dollar.HasField("int_type"): - _t1631 = _dollar_dollar.int_type + _t1635 = _dollar_dollar.int_type else: - _t1631 = None - deconstruct_result968 = _t1631 - if deconstruct_result968 is not None: - assert deconstruct_result968 is not None - unwrapped969 = deconstruct_result968 - self.pretty_int_type(unwrapped969) + _t1635 = None + deconstruct_result970 = _t1635 + if deconstruct_result970 is not None: + assert deconstruct_result970 is not None + unwrapped971 = deconstruct_result970 + self.pretty_int_type(unwrapped971) else: _dollar_dollar = msg if _dollar_dollar.HasField("float_type"): - _t1632 = _dollar_dollar.float_type + _t1636 = _dollar_dollar.float_type else: - _t1632 = None - deconstruct_result966 = _t1632 - if deconstruct_result966 is not None: - assert deconstruct_result966 is not None - unwrapped967 = deconstruct_result966 - self.pretty_float_type(unwrapped967) + _t1636 = None + deconstruct_result968 = _t1636 + if deconstruct_result968 is not None: + assert deconstruct_result968 is not None + unwrapped969 = deconstruct_result968 + self.pretty_float_type(unwrapped969) else: _dollar_dollar = msg if _dollar_dollar.HasField("uint128_type"): - _t1633 = _dollar_dollar.uint128_type + _t1637 = _dollar_dollar.uint128_type else: - _t1633 = None - deconstruct_result964 = _t1633 - if deconstruct_result964 is not None: - assert deconstruct_result964 is not None - unwrapped965 = deconstruct_result964 - self.pretty_uint128_type(unwrapped965) + _t1637 = None + deconstruct_result966 = _t1637 + if deconstruct_result966 is not None: + assert deconstruct_result966 is not None + unwrapped967 = deconstruct_result966 + self.pretty_uint128_type(unwrapped967) else: _dollar_dollar = msg if _dollar_dollar.HasField("int128_type"): - _t1634 = _dollar_dollar.int128_type + _t1638 = _dollar_dollar.int128_type else: - _t1634 = None - deconstruct_result962 = _t1634 - if deconstruct_result962 is not None: - assert deconstruct_result962 is not None - unwrapped963 = deconstruct_result962 - self.pretty_int128_type(unwrapped963) + _t1638 = None + deconstruct_result964 = _t1638 + if deconstruct_result964 is not None: + assert deconstruct_result964 is not None + unwrapped965 = deconstruct_result964 + self.pretty_int128_type(unwrapped965) else: _dollar_dollar = msg if _dollar_dollar.HasField("date_type"): - _t1635 = _dollar_dollar.date_type + _t1639 = _dollar_dollar.date_type else: - _t1635 = None - deconstruct_result960 = _t1635 - if deconstruct_result960 is not None: - assert deconstruct_result960 is not None - unwrapped961 = deconstruct_result960 - self.pretty_date_type(unwrapped961) + _t1639 = None + deconstruct_result962 = _t1639 + if deconstruct_result962 is not None: + assert deconstruct_result962 is not None + unwrapped963 = deconstruct_result962 + self.pretty_date_type(unwrapped963) else: _dollar_dollar = msg if _dollar_dollar.HasField("datetime_type"): - _t1636 = _dollar_dollar.datetime_type + _t1640 = _dollar_dollar.datetime_type else: - _t1636 = None - deconstruct_result958 = _t1636 - if deconstruct_result958 is not None: - assert deconstruct_result958 is not None - unwrapped959 = deconstruct_result958 - self.pretty_datetime_type(unwrapped959) + _t1640 = None + deconstruct_result960 = _t1640 + if deconstruct_result960 is not None: + assert deconstruct_result960 is not None + unwrapped961 = deconstruct_result960 + self.pretty_datetime_type(unwrapped961) else: _dollar_dollar = msg if _dollar_dollar.HasField("missing_type"): - _t1637 = _dollar_dollar.missing_type + _t1641 = _dollar_dollar.missing_type else: - _t1637 = None - deconstruct_result956 = _t1637 - if deconstruct_result956 is not None: - assert deconstruct_result956 is not None - unwrapped957 = deconstruct_result956 - self.pretty_missing_type(unwrapped957) + _t1641 = None + deconstruct_result958 = _t1641 + if deconstruct_result958 is not None: + assert deconstruct_result958 is not None + unwrapped959 = deconstruct_result958 + self.pretty_missing_type(unwrapped959) else: _dollar_dollar = msg if _dollar_dollar.HasField("decimal_type"): - _t1638 = _dollar_dollar.decimal_type + _t1642 = _dollar_dollar.decimal_type else: - _t1638 = None - deconstruct_result954 = _t1638 - if deconstruct_result954 is not None: - assert deconstruct_result954 is not None - unwrapped955 = deconstruct_result954 - self.pretty_decimal_type(unwrapped955) + _t1642 = None + deconstruct_result956 = _t1642 + if deconstruct_result956 is not None: + assert deconstruct_result956 is not None + unwrapped957 = deconstruct_result956 + self.pretty_decimal_type(unwrapped957) else: _dollar_dollar = msg if _dollar_dollar.HasField("boolean_type"): - _t1639 = _dollar_dollar.boolean_type + _t1643 = _dollar_dollar.boolean_type else: - _t1639 = None - deconstruct_result952 = _t1639 - if deconstruct_result952 is not None: - assert deconstruct_result952 is not None - unwrapped953 = deconstruct_result952 - self.pretty_boolean_type(unwrapped953) + _t1643 = None + deconstruct_result954 = _t1643 + if deconstruct_result954 is not None: + assert deconstruct_result954 is not None + unwrapped955 = deconstruct_result954 + self.pretty_boolean_type(unwrapped955) else: _dollar_dollar = msg if _dollar_dollar.HasField("int32_type"): - _t1640 = _dollar_dollar.int32_type + _t1644 = _dollar_dollar.int32_type else: - _t1640 = None - deconstruct_result950 = _t1640 - if deconstruct_result950 is not None: - assert deconstruct_result950 is not None - unwrapped951 = deconstruct_result950 - self.pretty_int32_type(unwrapped951) + _t1644 = None + deconstruct_result952 = _t1644 + if deconstruct_result952 is not None: + assert deconstruct_result952 is not None + unwrapped953 = deconstruct_result952 + self.pretty_int32_type(unwrapped953) else: _dollar_dollar = msg if _dollar_dollar.HasField("float32_type"): - _t1641 = _dollar_dollar.float32_type + _t1645 = _dollar_dollar.float32_type else: - _t1641 = None - deconstruct_result948 = _t1641 - if deconstruct_result948 is not None: - assert deconstruct_result948 is not None - unwrapped949 = deconstruct_result948 - self.pretty_float32_type(unwrapped949) + _t1645 = None + deconstruct_result950 = _t1645 + if deconstruct_result950 is not None: + assert deconstruct_result950 is not None + unwrapped951 = deconstruct_result950 + self.pretty_float32_type(unwrapped951) else: _dollar_dollar = msg if _dollar_dollar.HasField("uint32_type"): - _t1642 = _dollar_dollar.uint32_type + _t1646 = _dollar_dollar.uint32_type else: - _t1642 = None - deconstruct_result946 = _t1642 - if deconstruct_result946 is not None: - assert deconstruct_result946 is not None - unwrapped947 = deconstruct_result946 - self.pretty_uint32_type(unwrapped947) + _t1646 = None + deconstruct_result948 = _t1646 + if deconstruct_result948 is not None: + assert deconstruct_result948 is not None + unwrapped949 = deconstruct_result948 + self.pretty_uint32_type(unwrapped949) else: raise ParseError("No matching rule for type") def pretty_unspecified_type(self, msg: logic_pb2.UnspecifiedType): - fields975 = msg + fields977 = msg self.write("UNKNOWN") def pretty_string_type(self, msg: logic_pb2.StringType): - fields976 = msg + fields978 = msg self.write("STRING") def pretty_int_type(self, msg: logic_pb2.IntType): - fields977 = msg + fields979 = msg self.write("INT") def pretty_float_type(self, msg: logic_pb2.FloatType): - fields978 = msg + fields980 = msg self.write("FLOAT") def pretty_uint128_type(self, msg: logic_pb2.UInt128Type): - fields979 = msg + fields981 = msg self.write("UINT128") def pretty_int128_type(self, msg: logic_pb2.Int128Type): - fields980 = msg + fields982 = msg self.write("INT128") def pretty_date_type(self, msg: logic_pb2.DateType): - fields981 = msg + fields983 = msg self.write("DATE") def pretty_datetime_type(self, msg: logic_pb2.DateTimeType): - fields982 = msg + fields984 = msg self.write("DATETIME") def pretty_missing_type(self, msg: logic_pb2.MissingType): - fields983 = msg + fields985 = msg self.write("MISSING") def pretty_decimal_type(self, msg: logic_pb2.DecimalType): - flat988 = self._try_flat(msg, self.pretty_decimal_type) - if flat988 is not None: - assert flat988 is not None - self.write(flat988) + flat990 = self._try_flat(msg, self.pretty_decimal_type) + if flat990 is not None: + assert flat990 is not None + self.write(flat990) return None else: _dollar_dollar = msg - fields984 = (int(_dollar_dollar.precision), int(_dollar_dollar.scale),) - assert fields984 is not None - unwrapped_fields985 = fields984 + fields986 = (int(_dollar_dollar.precision), int(_dollar_dollar.scale),) + assert fields986 is not None + unwrapped_fields987 = fields986 self.write("(DECIMAL") self.indent_sexp() self.newline() - field986 = unwrapped_fields985[0] - self.write(str(field986)) + field988 = unwrapped_fields987[0] + self.write(str(field988)) self.newline() - field987 = unwrapped_fields985[1] - self.write(str(field987)) + field989 = unwrapped_fields987[1] + self.write(str(field989)) self.dedent() self.write(")") def pretty_boolean_type(self, msg: logic_pb2.BooleanType): - fields989 = msg + fields991 = msg self.write("BOOLEAN") def pretty_int32_type(self, msg: logic_pb2.Int32Type): - fields990 = msg + fields992 = msg self.write("INT32") def pretty_float32_type(self, msg: logic_pb2.Float32Type): - fields991 = msg + fields993 = msg self.write("FLOAT32") def pretty_uint32_type(self, msg: logic_pb2.UInt32Type): - fields992 = msg + fields994 = msg self.write("UINT32") def pretty_value_bindings(self, msg: Sequence[logic_pb2.Binding]): - flat996 = self._try_flat(msg, self.pretty_value_bindings) - if flat996 is not None: - assert flat996 is not None - self.write(flat996) + flat998 = self._try_flat(msg, self.pretty_value_bindings) + if flat998 is not None: + assert flat998 is not None + self.write(flat998) return None else: - fields993 = msg + fields995 = msg self.write("|") - if not len(fields993) == 0: + if not len(fields995) == 0: self.write(" ") - for i995, elem994 in enumerate(fields993): - if (i995 > 0): + for i997, elem996 in enumerate(fields995): + if (i997 > 0): self.newline() - self.pretty_binding(elem994) + self.pretty_binding(elem996) def pretty_formula(self, msg: logic_pb2.Formula): - flat1023 = self._try_flat(msg, self.pretty_formula) - if flat1023 is not None: - assert flat1023 is not None - self.write(flat1023) + flat1025 = self._try_flat(msg, self.pretty_formula) + if flat1025 is not None: + assert flat1025 is not None + self.write(flat1025) return None else: _dollar_dollar = msg if (_dollar_dollar.HasField("conjunction") and len(_dollar_dollar.conjunction.args) == 0): - _t1643 = _dollar_dollar.conjunction + _t1647 = _dollar_dollar.conjunction else: - _t1643 = None - deconstruct_result1021 = _t1643 - if deconstruct_result1021 is not None: - assert deconstruct_result1021 is not None - unwrapped1022 = deconstruct_result1021 - self.pretty_true(unwrapped1022) + _t1647 = None + deconstruct_result1023 = _t1647 + if deconstruct_result1023 is not None: + assert deconstruct_result1023 is not None + unwrapped1024 = deconstruct_result1023 + self.pretty_true(unwrapped1024) else: _dollar_dollar = msg if (_dollar_dollar.HasField("disjunction") and len(_dollar_dollar.disjunction.args) == 0): - _t1644 = _dollar_dollar.disjunction + _t1648 = _dollar_dollar.disjunction else: - _t1644 = None - deconstruct_result1019 = _t1644 - if deconstruct_result1019 is not None: - assert deconstruct_result1019 is not None - unwrapped1020 = deconstruct_result1019 - self.pretty_false(unwrapped1020) + _t1648 = None + deconstruct_result1021 = _t1648 + if deconstruct_result1021 is not None: + assert deconstruct_result1021 is not None + unwrapped1022 = deconstruct_result1021 + self.pretty_false(unwrapped1022) else: _dollar_dollar = msg if _dollar_dollar.HasField("exists"): - _t1645 = _dollar_dollar.exists + _t1649 = _dollar_dollar.exists else: - _t1645 = None - deconstruct_result1017 = _t1645 - if deconstruct_result1017 is not None: - assert deconstruct_result1017 is not None - unwrapped1018 = deconstruct_result1017 - self.pretty_exists(unwrapped1018) + _t1649 = None + deconstruct_result1019 = _t1649 + if deconstruct_result1019 is not None: + assert deconstruct_result1019 is not None + unwrapped1020 = deconstruct_result1019 + self.pretty_exists(unwrapped1020) else: _dollar_dollar = msg if _dollar_dollar.HasField("reduce"): - _t1646 = _dollar_dollar.reduce + _t1650 = _dollar_dollar.reduce else: - _t1646 = None - deconstruct_result1015 = _t1646 - if deconstruct_result1015 is not None: - assert deconstruct_result1015 is not None - unwrapped1016 = deconstruct_result1015 - self.pretty_reduce(unwrapped1016) + _t1650 = None + deconstruct_result1017 = _t1650 + if deconstruct_result1017 is not None: + assert deconstruct_result1017 is not None + unwrapped1018 = deconstruct_result1017 + self.pretty_reduce(unwrapped1018) else: _dollar_dollar = msg if (_dollar_dollar.HasField("conjunction") and not len(_dollar_dollar.conjunction.args) == 0): - _t1647 = _dollar_dollar.conjunction + _t1651 = _dollar_dollar.conjunction else: - _t1647 = None - deconstruct_result1013 = _t1647 - if deconstruct_result1013 is not None: - assert deconstruct_result1013 is not None - unwrapped1014 = deconstruct_result1013 - self.pretty_conjunction(unwrapped1014) + _t1651 = None + deconstruct_result1015 = _t1651 + if deconstruct_result1015 is not None: + assert deconstruct_result1015 is not None + unwrapped1016 = deconstruct_result1015 + self.pretty_conjunction(unwrapped1016) else: _dollar_dollar = msg if (_dollar_dollar.HasField("disjunction") and not len(_dollar_dollar.disjunction.args) == 0): - _t1648 = _dollar_dollar.disjunction + _t1652 = _dollar_dollar.disjunction else: - _t1648 = None - deconstruct_result1011 = _t1648 - if deconstruct_result1011 is not None: - assert deconstruct_result1011 is not None - unwrapped1012 = deconstruct_result1011 - self.pretty_disjunction(unwrapped1012) + _t1652 = None + deconstruct_result1013 = _t1652 + if deconstruct_result1013 is not None: + assert deconstruct_result1013 is not None + unwrapped1014 = deconstruct_result1013 + self.pretty_disjunction(unwrapped1014) else: _dollar_dollar = msg if _dollar_dollar.HasField("not"): - _t1649 = getattr(_dollar_dollar, 'not') + _t1653 = getattr(_dollar_dollar, 'not') else: - _t1649 = None - deconstruct_result1009 = _t1649 - if deconstruct_result1009 is not None: - assert deconstruct_result1009 is not None - unwrapped1010 = deconstruct_result1009 - self.pretty_not(unwrapped1010) + _t1653 = None + deconstruct_result1011 = _t1653 + if deconstruct_result1011 is not None: + assert deconstruct_result1011 is not None + unwrapped1012 = deconstruct_result1011 + self.pretty_not(unwrapped1012) else: _dollar_dollar = msg if _dollar_dollar.HasField("ffi"): - _t1650 = _dollar_dollar.ffi + _t1654 = _dollar_dollar.ffi else: - _t1650 = None - deconstruct_result1007 = _t1650 - if deconstruct_result1007 is not None: - assert deconstruct_result1007 is not None - unwrapped1008 = deconstruct_result1007 - self.pretty_ffi(unwrapped1008) + _t1654 = None + deconstruct_result1009 = _t1654 + if deconstruct_result1009 is not None: + assert deconstruct_result1009 is not None + unwrapped1010 = deconstruct_result1009 + self.pretty_ffi(unwrapped1010) else: _dollar_dollar = msg if _dollar_dollar.HasField("atom"): - _t1651 = _dollar_dollar.atom + _t1655 = _dollar_dollar.atom else: - _t1651 = None - deconstruct_result1005 = _t1651 - if deconstruct_result1005 is not None: - assert deconstruct_result1005 is not None - unwrapped1006 = deconstruct_result1005 - self.pretty_atom(unwrapped1006) + _t1655 = None + deconstruct_result1007 = _t1655 + if deconstruct_result1007 is not None: + assert deconstruct_result1007 is not None + unwrapped1008 = deconstruct_result1007 + self.pretty_atom(unwrapped1008) else: _dollar_dollar = msg if _dollar_dollar.HasField("pragma"): - _t1652 = _dollar_dollar.pragma + _t1656 = _dollar_dollar.pragma else: - _t1652 = None - deconstruct_result1003 = _t1652 - if deconstruct_result1003 is not None: - assert deconstruct_result1003 is not None - unwrapped1004 = deconstruct_result1003 - self.pretty_pragma(unwrapped1004) + _t1656 = None + deconstruct_result1005 = _t1656 + if deconstruct_result1005 is not None: + assert deconstruct_result1005 is not None + unwrapped1006 = deconstruct_result1005 + self.pretty_pragma(unwrapped1006) else: _dollar_dollar = msg if _dollar_dollar.HasField("primitive"): - _t1653 = _dollar_dollar.primitive + _t1657 = _dollar_dollar.primitive else: - _t1653 = None - deconstruct_result1001 = _t1653 - if deconstruct_result1001 is not None: - assert deconstruct_result1001 is not None - unwrapped1002 = deconstruct_result1001 - self.pretty_primitive(unwrapped1002) + _t1657 = None + deconstruct_result1003 = _t1657 + if deconstruct_result1003 is not None: + assert deconstruct_result1003 is not None + unwrapped1004 = deconstruct_result1003 + self.pretty_primitive(unwrapped1004) else: _dollar_dollar = msg if _dollar_dollar.HasField("rel_atom"): - _t1654 = _dollar_dollar.rel_atom + _t1658 = _dollar_dollar.rel_atom else: - _t1654 = None - deconstruct_result999 = _t1654 - if deconstruct_result999 is not None: - assert deconstruct_result999 is not None - unwrapped1000 = deconstruct_result999 - self.pretty_rel_atom(unwrapped1000) + _t1658 = None + deconstruct_result1001 = _t1658 + if deconstruct_result1001 is not None: + assert deconstruct_result1001 is not None + unwrapped1002 = deconstruct_result1001 + self.pretty_rel_atom(unwrapped1002) else: _dollar_dollar = msg if _dollar_dollar.HasField("cast"): - _t1655 = _dollar_dollar.cast + _t1659 = _dollar_dollar.cast else: - _t1655 = None - deconstruct_result997 = _t1655 - if deconstruct_result997 is not None: - assert deconstruct_result997 is not None - unwrapped998 = deconstruct_result997 - self.pretty_cast(unwrapped998) + _t1659 = None + deconstruct_result999 = _t1659 + if deconstruct_result999 is not None: + assert deconstruct_result999 is not None + unwrapped1000 = deconstruct_result999 + self.pretty_cast(unwrapped1000) else: raise ParseError("No matching rule for formula") def pretty_true(self, msg: logic_pb2.Conjunction): - fields1024 = msg + fields1026 = msg self.write("(true)") def pretty_false(self, msg: logic_pb2.Disjunction): - fields1025 = msg + fields1027 = msg self.write("(false)") def pretty_exists(self, msg: logic_pb2.Exists): - flat1030 = self._try_flat(msg, self.pretty_exists) - if flat1030 is not None: - assert flat1030 is not None - self.write(flat1030) + flat1032 = self._try_flat(msg, self.pretty_exists) + if flat1032 is not None: + assert flat1032 is not None + self.write(flat1032) return None else: _dollar_dollar = msg - _t1656 = self.deconstruct_bindings(_dollar_dollar.body) - fields1026 = (_t1656, _dollar_dollar.body.value,) - assert fields1026 is not None - unwrapped_fields1027 = fields1026 + _t1660 = self.deconstruct_bindings(_dollar_dollar.body) + fields1028 = (_t1660, _dollar_dollar.body.value,) + assert fields1028 is not None + unwrapped_fields1029 = fields1028 self.write("(exists") self.indent_sexp() self.newline() - field1028 = unwrapped_fields1027[0] - self.pretty_bindings(field1028) + field1030 = unwrapped_fields1029[0] + self.pretty_bindings(field1030) self.newline() - field1029 = unwrapped_fields1027[1] - self.pretty_formula(field1029) + field1031 = unwrapped_fields1029[1] + self.pretty_formula(field1031) self.dedent() self.write(")") def pretty_reduce(self, msg: logic_pb2.Reduce): - flat1036 = self._try_flat(msg, self.pretty_reduce) - if flat1036 is not None: - assert flat1036 is not None - self.write(flat1036) + flat1038 = self._try_flat(msg, self.pretty_reduce) + if flat1038 is not None: + assert flat1038 is not None + self.write(flat1038) return None else: _dollar_dollar = msg - fields1031 = (_dollar_dollar.op, _dollar_dollar.body, _dollar_dollar.terms,) - assert fields1031 is not None - unwrapped_fields1032 = fields1031 + fields1033 = (_dollar_dollar.op, _dollar_dollar.body, _dollar_dollar.terms,) + assert fields1033 is not None + unwrapped_fields1034 = fields1033 self.write("(reduce") self.indent_sexp() self.newline() - field1033 = unwrapped_fields1032[0] - self.pretty_abstraction(field1033) + field1035 = unwrapped_fields1034[0] + self.pretty_abstraction(field1035) self.newline() - field1034 = unwrapped_fields1032[1] - self.pretty_abstraction(field1034) + field1036 = unwrapped_fields1034[1] + self.pretty_abstraction(field1036) self.newline() - field1035 = unwrapped_fields1032[2] - self.pretty_terms(field1035) + field1037 = unwrapped_fields1034[2] + self.pretty_terms(field1037) self.dedent() self.write(")") def pretty_terms(self, msg: Sequence[logic_pb2.Term]): - flat1040 = self._try_flat(msg, self.pretty_terms) - if flat1040 is not None: - assert flat1040 is not None - self.write(flat1040) + flat1042 = self._try_flat(msg, self.pretty_terms) + if flat1042 is not None: + assert flat1042 is not None + self.write(flat1042) return None else: - fields1037 = msg + fields1039 = msg self.write("(terms") self.indent_sexp() - if not len(fields1037) == 0: + if not len(fields1039) == 0: self.newline() - for i1039, elem1038 in enumerate(fields1037): - if (i1039 > 0): + for i1041, elem1040 in enumerate(fields1039): + if (i1041 > 0): self.newline() - self.pretty_term(elem1038) + self.pretty_term(elem1040) self.dedent() self.write(")") def pretty_term(self, msg: logic_pb2.Term): - flat1045 = self._try_flat(msg, self.pretty_term) - if flat1045 is not None: - assert flat1045 is not None - self.write(flat1045) + flat1047 = self._try_flat(msg, self.pretty_term) + if flat1047 is not None: + assert flat1047 is not None + self.write(flat1047) return None else: _dollar_dollar = msg if _dollar_dollar.HasField("var"): - _t1657 = _dollar_dollar.var + _t1661 = _dollar_dollar.var else: - _t1657 = None - deconstruct_result1043 = _t1657 - if deconstruct_result1043 is not None: - assert deconstruct_result1043 is not None - unwrapped1044 = deconstruct_result1043 - self.pretty_var(unwrapped1044) + _t1661 = None + deconstruct_result1045 = _t1661 + if deconstruct_result1045 is not None: + assert deconstruct_result1045 is not None + unwrapped1046 = deconstruct_result1045 + self.pretty_var(unwrapped1046) else: _dollar_dollar = msg if _dollar_dollar.HasField("constant"): - _t1658 = _dollar_dollar.constant + _t1662 = _dollar_dollar.constant else: - _t1658 = None - deconstruct_result1041 = _t1658 - if deconstruct_result1041 is not None: - assert deconstruct_result1041 is not None - unwrapped1042 = deconstruct_result1041 - self.pretty_value(unwrapped1042) + _t1662 = None + deconstruct_result1043 = _t1662 + if deconstruct_result1043 is not None: + assert deconstruct_result1043 is not None + unwrapped1044 = deconstruct_result1043 + self.pretty_value(unwrapped1044) else: raise ParseError("No matching rule for term") def pretty_var(self, msg: logic_pb2.Var): - flat1048 = self._try_flat(msg, self.pretty_var) - if flat1048 is not None: - assert flat1048 is not None - self.write(flat1048) + flat1050 = self._try_flat(msg, self.pretty_var) + if flat1050 is not None: + assert flat1050 is not None + self.write(flat1050) return None else: _dollar_dollar = msg - fields1046 = _dollar_dollar.name - assert fields1046 is not None - unwrapped_fields1047 = fields1046 - self.write(unwrapped_fields1047) + fields1048 = _dollar_dollar.name + assert fields1048 is not None + unwrapped_fields1049 = fields1048 + self.write(unwrapped_fields1049) def pretty_value(self, msg: logic_pb2.Value): - flat1074 = self._try_flat(msg, self.pretty_value) - if flat1074 is not None: - assert flat1074 is not None - self.write(flat1074) + flat1076 = self._try_flat(msg, self.pretty_value) + if flat1076 is not None: + assert flat1076 is not None + self.write(flat1076) return None else: _dollar_dollar = msg if _dollar_dollar.HasField("date_value"): - _t1659 = _dollar_dollar.date_value + _t1663 = _dollar_dollar.date_value else: - _t1659 = None - deconstruct_result1072 = _t1659 - if deconstruct_result1072 is not None: - assert deconstruct_result1072 is not None - unwrapped1073 = deconstruct_result1072 - self.pretty_date(unwrapped1073) + _t1663 = None + deconstruct_result1074 = _t1663 + if deconstruct_result1074 is not None: + assert deconstruct_result1074 is not None + unwrapped1075 = deconstruct_result1074 + self.pretty_date(unwrapped1075) else: _dollar_dollar = msg if _dollar_dollar.HasField("datetime_value"): - _t1660 = _dollar_dollar.datetime_value + _t1664 = _dollar_dollar.datetime_value else: - _t1660 = None - deconstruct_result1070 = _t1660 - if deconstruct_result1070 is not None: - assert deconstruct_result1070 is not None - unwrapped1071 = deconstruct_result1070 - self.pretty_datetime(unwrapped1071) + _t1664 = None + deconstruct_result1072 = _t1664 + if deconstruct_result1072 is not None: + assert deconstruct_result1072 is not None + unwrapped1073 = deconstruct_result1072 + self.pretty_datetime(unwrapped1073) else: _dollar_dollar = msg if _dollar_dollar.HasField("string_value"): - _t1661 = _dollar_dollar.string_value + _t1665 = _dollar_dollar.string_value else: - _t1661 = None - deconstruct_result1068 = _t1661 - if deconstruct_result1068 is not None: - assert deconstruct_result1068 is not None - unwrapped1069 = deconstruct_result1068 - self.write(self.format_string_value(unwrapped1069)) + _t1665 = None + deconstruct_result1070 = _t1665 + if deconstruct_result1070 is not None: + assert deconstruct_result1070 is not None + unwrapped1071 = deconstruct_result1070 + self.write(self.format_string_value(unwrapped1071)) else: _dollar_dollar = msg if _dollar_dollar.HasField("int32_value"): - _t1662 = _dollar_dollar.int32_value + _t1666 = _dollar_dollar.int32_value else: - _t1662 = None - deconstruct_result1066 = _t1662 - if deconstruct_result1066 is not None: - assert deconstruct_result1066 is not None - unwrapped1067 = deconstruct_result1066 - self.write((str(unwrapped1067) + 'i32')) + _t1666 = None + deconstruct_result1068 = _t1666 + if deconstruct_result1068 is not None: + assert deconstruct_result1068 is not None + unwrapped1069 = deconstruct_result1068 + self.write((str(unwrapped1069) + 'i32')) else: _dollar_dollar = msg if _dollar_dollar.HasField("int_value"): - _t1663 = _dollar_dollar.int_value + _t1667 = _dollar_dollar.int_value else: - _t1663 = None - deconstruct_result1064 = _t1663 - if deconstruct_result1064 is not None: - assert deconstruct_result1064 is not None - unwrapped1065 = deconstruct_result1064 - self.write(str(unwrapped1065)) + _t1667 = None + deconstruct_result1066 = _t1667 + if deconstruct_result1066 is not None: + assert deconstruct_result1066 is not None + unwrapped1067 = deconstruct_result1066 + self.write(str(unwrapped1067)) else: _dollar_dollar = msg if _dollar_dollar.HasField("float32_value"): - _t1664 = _dollar_dollar.float32_value + _t1668 = _dollar_dollar.float32_value else: - _t1664 = None - deconstruct_result1062 = _t1664 - if deconstruct_result1062 is not None: - assert deconstruct_result1062 is not None - unwrapped1063 = deconstruct_result1062 - self.write(self.format_float32_literal(unwrapped1063)) + _t1668 = None + deconstruct_result1064 = _t1668 + if deconstruct_result1064 is not None: + assert deconstruct_result1064 is not None + unwrapped1065 = deconstruct_result1064 + self.write(self.format_float32_literal(unwrapped1065)) else: _dollar_dollar = msg if _dollar_dollar.HasField("float_value"): - _t1665 = _dollar_dollar.float_value + _t1669 = _dollar_dollar.float_value else: - _t1665 = None - deconstruct_result1060 = _t1665 - if deconstruct_result1060 is not None: - assert deconstruct_result1060 is not None - unwrapped1061 = deconstruct_result1060 - self.write(str(unwrapped1061)) + _t1669 = None + deconstruct_result1062 = _t1669 + if deconstruct_result1062 is not None: + assert deconstruct_result1062 is not None + unwrapped1063 = deconstruct_result1062 + self.write(str(unwrapped1063)) else: _dollar_dollar = msg if _dollar_dollar.HasField("uint32_value"): - _t1666 = _dollar_dollar.uint32_value + _t1670 = _dollar_dollar.uint32_value else: - _t1666 = None - deconstruct_result1058 = _t1666 - if deconstruct_result1058 is not None: - assert deconstruct_result1058 is not None - unwrapped1059 = deconstruct_result1058 - self.write((str(unwrapped1059) + 'u32')) + _t1670 = None + deconstruct_result1060 = _t1670 + if deconstruct_result1060 is not None: + assert deconstruct_result1060 is not None + unwrapped1061 = deconstruct_result1060 + self.write((str(unwrapped1061) + 'u32')) else: _dollar_dollar = msg if _dollar_dollar.HasField("uint128_value"): - _t1667 = _dollar_dollar.uint128_value + _t1671 = _dollar_dollar.uint128_value else: - _t1667 = None - deconstruct_result1056 = _t1667 - if deconstruct_result1056 is not None: - assert deconstruct_result1056 is not None - unwrapped1057 = deconstruct_result1056 - self.write(self.format_uint128(unwrapped1057)) + _t1671 = None + deconstruct_result1058 = _t1671 + if deconstruct_result1058 is not None: + assert deconstruct_result1058 is not None + unwrapped1059 = deconstruct_result1058 + self.write(self.format_uint128(unwrapped1059)) else: _dollar_dollar = msg if _dollar_dollar.HasField("int128_value"): - _t1668 = _dollar_dollar.int128_value + _t1672 = _dollar_dollar.int128_value else: - _t1668 = None - deconstruct_result1054 = _t1668 - if deconstruct_result1054 is not None: - assert deconstruct_result1054 is not None - unwrapped1055 = deconstruct_result1054 - self.write(self.format_int128(unwrapped1055)) + _t1672 = None + deconstruct_result1056 = _t1672 + if deconstruct_result1056 is not None: + assert deconstruct_result1056 is not None + unwrapped1057 = deconstruct_result1056 + self.write(self.format_int128(unwrapped1057)) else: _dollar_dollar = msg if _dollar_dollar.HasField("decimal_value"): - _t1669 = _dollar_dollar.decimal_value + _t1673 = _dollar_dollar.decimal_value else: - _t1669 = None - deconstruct_result1052 = _t1669 - if deconstruct_result1052 is not None: - assert deconstruct_result1052 is not None - unwrapped1053 = deconstruct_result1052 - self.write(self.format_decimal(unwrapped1053)) + _t1673 = None + deconstruct_result1054 = _t1673 + if deconstruct_result1054 is not None: + assert deconstruct_result1054 is not None + unwrapped1055 = deconstruct_result1054 + self.write(self.format_decimal(unwrapped1055)) else: _dollar_dollar = msg if _dollar_dollar.HasField("boolean_value"): - _t1670 = _dollar_dollar.boolean_value + _t1674 = _dollar_dollar.boolean_value else: - _t1670 = None - deconstruct_result1050 = _t1670 - if deconstruct_result1050 is not None: - assert deconstruct_result1050 is not None - unwrapped1051 = deconstruct_result1050 - self.pretty_boolean_value(unwrapped1051) + _t1674 = None + deconstruct_result1052 = _t1674 + if deconstruct_result1052 is not None: + assert deconstruct_result1052 is not None + unwrapped1053 = deconstruct_result1052 + self.pretty_boolean_value(unwrapped1053) else: - fields1049 = msg + fields1051 = msg self.write("missing") def pretty_date(self, msg: logic_pb2.DateValue): - flat1080 = self._try_flat(msg, self.pretty_date) - if flat1080 is not None: - assert flat1080 is not None - self.write(flat1080) + flat1082 = self._try_flat(msg, self.pretty_date) + if flat1082 is not None: + assert flat1082 is not None + self.write(flat1082) return None else: _dollar_dollar = msg - fields1075 = (int(_dollar_dollar.year), int(_dollar_dollar.month), int(_dollar_dollar.day),) - assert fields1075 is not None - unwrapped_fields1076 = fields1075 + fields1077 = (int(_dollar_dollar.year), int(_dollar_dollar.month), int(_dollar_dollar.day),) + assert fields1077 is not None + unwrapped_fields1078 = fields1077 self.write("(date") self.indent_sexp() self.newline() - field1077 = unwrapped_fields1076[0] - self.write(str(field1077)) + field1079 = unwrapped_fields1078[0] + self.write(str(field1079)) self.newline() - field1078 = unwrapped_fields1076[1] - self.write(str(field1078)) + field1080 = unwrapped_fields1078[1] + self.write(str(field1080)) self.newline() - field1079 = unwrapped_fields1076[2] - self.write(str(field1079)) + field1081 = unwrapped_fields1078[2] + self.write(str(field1081)) self.dedent() self.write(")") def pretty_datetime(self, msg: logic_pb2.DateTimeValue): - flat1091 = self._try_flat(msg, self.pretty_datetime) - if flat1091 is not None: - assert flat1091 is not None - self.write(flat1091) + flat1093 = self._try_flat(msg, self.pretty_datetime) + if flat1093 is not None: + assert flat1093 is not None + self.write(flat1093) return None else: _dollar_dollar = msg - fields1081 = (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 fields1081 is not None - unwrapped_fields1082 = fields1081 + fields1083 = (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 fields1083 is not None + unwrapped_fields1084 = fields1083 self.write("(datetime") self.indent_sexp() self.newline() - field1083 = unwrapped_fields1082[0] - self.write(str(field1083)) - self.newline() - field1084 = unwrapped_fields1082[1] - self.write(str(field1084)) - self.newline() - field1085 = unwrapped_fields1082[2] + field1085 = unwrapped_fields1084[0] self.write(str(field1085)) self.newline() - field1086 = unwrapped_fields1082[3] + field1086 = unwrapped_fields1084[1] self.write(str(field1086)) self.newline() - field1087 = unwrapped_fields1082[4] + field1087 = unwrapped_fields1084[2] self.write(str(field1087)) self.newline() - field1088 = unwrapped_fields1082[5] + field1088 = unwrapped_fields1084[3] self.write(str(field1088)) - field1089 = unwrapped_fields1082[6] - if field1089 is not None: + self.newline() + field1089 = unwrapped_fields1084[4] + self.write(str(field1089)) + self.newline() + field1090 = unwrapped_fields1084[5] + self.write(str(field1090)) + field1091 = unwrapped_fields1084[6] + if field1091 is not None: self.newline() - assert field1089 is not None - opt_val1090 = field1089 - self.write(str(opt_val1090)) + assert field1091 is not None + opt_val1092 = field1091 + self.write(str(opt_val1092)) self.dedent() self.write(")") def pretty_conjunction(self, msg: logic_pb2.Conjunction): - flat1096 = self._try_flat(msg, self.pretty_conjunction) - if flat1096 is not None: - assert flat1096 is not None - self.write(flat1096) + flat1098 = self._try_flat(msg, self.pretty_conjunction) + if flat1098 is not None: + assert flat1098 is not None + self.write(flat1098) return None else: _dollar_dollar = msg - fields1092 = _dollar_dollar.args - assert fields1092 is not None - unwrapped_fields1093 = fields1092 + fields1094 = _dollar_dollar.args + assert fields1094 is not None + unwrapped_fields1095 = fields1094 self.write("(and") self.indent_sexp() - if not len(unwrapped_fields1093) == 0: + if not len(unwrapped_fields1095) == 0: self.newline() - for i1095, elem1094 in enumerate(unwrapped_fields1093): - if (i1095 > 0): + for i1097, elem1096 in enumerate(unwrapped_fields1095): + if (i1097 > 0): self.newline() - self.pretty_formula(elem1094) + self.pretty_formula(elem1096) self.dedent() self.write(")") def pretty_disjunction(self, msg: logic_pb2.Disjunction): - flat1101 = self._try_flat(msg, self.pretty_disjunction) - if flat1101 is not None: - assert flat1101 is not None - self.write(flat1101) + flat1103 = self._try_flat(msg, self.pretty_disjunction) + if flat1103 is not None: + assert flat1103 is not None + self.write(flat1103) return None else: _dollar_dollar = msg - fields1097 = _dollar_dollar.args - assert fields1097 is not None - unwrapped_fields1098 = fields1097 + fields1099 = _dollar_dollar.args + assert fields1099 is not None + unwrapped_fields1100 = fields1099 self.write("(or") self.indent_sexp() - if not len(unwrapped_fields1098) == 0: + if not len(unwrapped_fields1100) == 0: self.newline() - for i1100, elem1099 in enumerate(unwrapped_fields1098): - if (i1100 > 0): + for i1102, elem1101 in enumerate(unwrapped_fields1100): + if (i1102 > 0): self.newline() - self.pretty_formula(elem1099) + self.pretty_formula(elem1101) self.dedent() self.write(")") def pretty_not(self, msg: logic_pb2.Not): - flat1104 = self._try_flat(msg, self.pretty_not) - if flat1104 is not None: - assert flat1104 is not None - self.write(flat1104) + flat1106 = self._try_flat(msg, self.pretty_not) + if flat1106 is not None: + assert flat1106 is not None + self.write(flat1106) return None else: _dollar_dollar = msg - fields1102 = _dollar_dollar.arg - assert fields1102 is not None - unwrapped_fields1103 = fields1102 + fields1104 = _dollar_dollar.arg + assert fields1104 is not None + unwrapped_fields1105 = fields1104 self.write("(not") self.indent_sexp() self.newline() - self.pretty_formula(unwrapped_fields1103) + self.pretty_formula(unwrapped_fields1105) self.dedent() self.write(")") def pretty_ffi(self, msg: logic_pb2.FFI): - flat1110 = self._try_flat(msg, self.pretty_ffi) - if flat1110 is not None: - assert flat1110 is not None - self.write(flat1110) + flat1112 = self._try_flat(msg, self.pretty_ffi) + if flat1112 is not None: + assert flat1112 is not None + self.write(flat1112) return None else: _dollar_dollar = msg - fields1105 = (_dollar_dollar.name, _dollar_dollar.args, _dollar_dollar.terms,) - assert fields1105 is not None - unwrapped_fields1106 = fields1105 + fields1107 = (_dollar_dollar.name, _dollar_dollar.args, _dollar_dollar.terms,) + assert fields1107 is not None + unwrapped_fields1108 = fields1107 self.write("(ffi") self.indent_sexp() self.newline() - field1107 = unwrapped_fields1106[0] - self.pretty_name(field1107) + field1109 = unwrapped_fields1108[0] + self.pretty_name(field1109) self.newline() - field1108 = unwrapped_fields1106[1] - self.pretty_ffi_args(field1108) + field1110 = unwrapped_fields1108[1] + self.pretty_ffi_args(field1110) self.newline() - field1109 = unwrapped_fields1106[2] - self.pretty_terms(field1109) + field1111 = unwrapped_fields1108[2] + self.pretty_terms(field1111) self.dedent() self.write(")") def pretty_name(self, msg: str): - flat1112 = self._try_flat(msg, self.pretty_name) - if flat1112 is not None: - assert flat1112 is not None - self.write(flat1112) + flat1114 = self._try_flat(msg, self.pretty_name) + if flat1114 is not None: + assert flat1114 is not None + self.write(flat1114) return None else: - fields1111 = msg + fields1113 = msg self.write(":") - self.write(fields1111) + self.write(fields1113) def pretty_ffi_args(self, msg: Sequence[logic_pb2.Abstraction]): - flat1116 = self._try_flat(msg, self.pretty_ffi_args) - if flat1116 is not None: - assert flat1116 is not None - self.write(flat1116) + flat1118 = self._try_flat(msg, self.pretty_ffi_args) + if flat1118 is not None: + assert flat1118 is not None + self.write(flat1118) return None else: - fields1113 = msg + fields1115 = msg self.write("(args") self.indent_sexp() - if not len(fields1113) == 0: + if not len(fields1115) == 0: self.newline() - for i1115, elem1114 in enumerate(fields1113): - if (i1115 > 0): + for i1117, elem1116 in enumerate(fields1115): + if (i1117 > 0): self.newline() - self.pretty_abstraction(elem1114) + self.pretty_abstraction(elem1116) self.dedent() self.write(")") def pretty_atom(self, msg: logic_pb2.Atom): - flat1123 = self._try_flat(msg, self.pretty_atom) - if flat1123 is not None: - assert flat1123 is not None - self.write(flat1123) + flat1125 = self._try_flat(msg, self.pretty_atom) + if flat1125 is not None: + assert flat1125 is not None + self.write(flat1125) return None else: _dollar_dollar = msg - fields1117 = (_dollar_dollar.name, _dollar_dollar.terms,) - assert fields1117 is not None - unwrapped_fields1118 = fields1117 + fields1119 = (_dollar_dollar.name, _dollar_dollar.terms,) + assert fields1119 is not None + unwrapped_fields1120 = fields1119 self.write("(atom") self.indent_sexp() self.newline() - field1119 = unwrapped_fields1118[0] - self.pretty_relation_id(field1119) - field1120 = unwrapped_fields1118[1] - if not len(field1120) == 0: + field1121 = unwrapped_fields1120[0] + self.pretty_relation_id(field1121) + field1122 = unwrapped_fields1120[1] + if not len(field1122) == 0: self.newline() - for i1122, elem1121 in enumerate(field1120): - if (i1122 > 0): + for i1124, elem1123 in enumerate(field1122): + if (i1124 > 0): self.newline() - self.pretty_term(elem1121) + self.pretty_term(elem1123) self.dedent() self.write(")") def pretty_pragma(self, msg: logic_pb2.Pragma): - flat1130 = self._try_flat(msg, self.pretty_pragma) - if flat1130 is not None: - assert flat1130 is not None - self.write(flat1130) + flat1132 = self._try_flat(msg, self.pretty_pragma) + if flat1132 is not None: + assert flat1132 is not None + self.write(flat1132) return None else: _dollar_dollar = msg - fields1124 = (_dollar_dollar.name, _dollar_dollar.terms,) - assert fields1124 is not None - unwrapped_fields1125 = fields1124 + fields1126 = (_dollar_dollar.name, _dollar_dollar.terms,) + assert fields1126 is not None + unwrapped_fields1127 = fields1126 self.write("(pragma") self.indent_sexp() self.newline() - field1126 = unwrapped_fields1125[0] - self.pretty_name(field1126) - field1127 = unwrapped_fields1125[1] - if not len(field1127) == 0: + field1128 = unwrapped_fields1127[0] + self.pretty_name(field1128) + field1129 = unwrapped_fields1127[1] + if not len(field1129) == 0: self.newline() - for i1129, elem1128 in enumerate(field1127): - if (i1129 > 0): + for i1131, elem1130 in enumerate(field1129): + if (i1131 > 0): self.newline() - self.pretty_term(elem1128) + self.pretty_term(elem1130) self.dedent() self.write(")") def pretty_primitive(self, msg: logic_pb2.Primitive): - flat1146 = self._try_flat(msg, self.pretty_primitive) - if flat1146 is not None: - assert flat1146 is not None - self.write(flat1146) + flat1148 = self._try_flat(msg, self.pretty_primitive) + if flat1148 is not None: + assert flat1148 is not None + self.write(flat1148) return None else: _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_eq": - _t1671 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) + _t1675 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) else: - _t1671 = None - guard_result1145 = _t1671 - if guard_result1145 is not None: + _t1675 = None + guard_result1147 = _t1675 + if guard_result1147 is not None: self.pretty_eq(msg) else: _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_lt_monotype": - _t1672 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) + _t1676 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) else: - _t1672 = None - guard_result1144 = _t1672 - if guard_result1144 is not None: + _t1676 = None + guard_result1146 = _t1676 + if guard_result1146 is not None: self.pretty_lt(msg) else: _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_lt_eq_monotype": - _t1673 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) + _t1677 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) else: - _t1673 = None - guard_result1143 = _t1673 - if guard_result1143 is not None: + _t1677 = None + guard_result1145 = _t1677 + if guard_result1145 is not None: self.pretty_lt_eq(msg) else: _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_gt_monotype": - _t1674 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) + _t1678 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) else: - _t1674 = None - guard_result1142 = _t1674 - if guard_result1142 is not None: + _t1678 = None + guard_result1144 = _t1678 + if guard_result1144 is not None: self.pretty_gt(msg) else: _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_gt_eq_monotype": - _t1675 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) + _t1679 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) else: - _t1675 = None - guard_result1141 = _t1675 - if guard_result1141 is not None: + _t1679 = None + guard_result1143 = _t1679 + if guard_result1143 is not None: self.pretty_gt_eq(msg) else: _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_add_monotype": - _t1676 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) + _t1680 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) else: - _t1676 = None - guard_result1140 = _t1676 - if guard_result1140 is not None: + _t1680 = None + guard_result1142 = _t1680 + if guard_result1142 is not None: self.pretty_add(msg) else: _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_subtract_monotype": - _t1677 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) + _t1681 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) else: - _t1677 = None - guard_result1139 = _t1677 - if guard_result1139 is not None: + _t1681 = None + guard_result1141 = _t1681 + if guard_result1141 is not None: self.pretty_minus(msg) else: _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_multiply_monotype": - _t1678 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) + _t1682 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) else: - _t1678 = None - guard_result1138 = _t1678 - if guard_result1138 is not None: + _t1682 = None + guard_result1140 = _t1682 + if guard_result1140 is not None: self.pretty_multiply(msg) else: _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_divide_monotype": - _t1679 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) + _t1683 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) else: - _t1679 = None - guard_result1137 = _t1679 - if guard_result1137 is not None: + _t1683 = None + guard_result1139 = _t1683 + if guard_result1139 is not None: self.pretty_divide(msg) else: _dollar_dollar = msg - fields1131 = (_dollar_dollar.name, _dollar_dollar.terms,) - assert fields1131 is not None - unwrapped_fields1132 = fields1131 + fields1133 = (_dollar_dollar.name, _dollar_dollar.terms,) + assert fields1133 is not None + unwrapped_fields1134 = fields1133 self.write("(primitive") self.indent_sexp() self.newline() - field1133 = unwrapped_fields1132[0] - self.pretty_name(field1133) - field1134 = unwrapped_fields1132[1] - if not len(field1134) == 0: + field1135 = unwrapped_fields1134[0] + self.pretty_name(field1135) + field1136 = unwrapped_fields1134[1] + if not len(field1136) == 0: self.newline() - for i1136, elem1135 in enumerate(field1134): - if (i1136 > 0): + for i1138, elem1137 in enumerate(field1136): + if (i1138 > 0): self.newline() - self.pretty_rel_term(elem1135) + self.pretty_rel_term(elem1137) self.dedent() self.write(")") def pretty_eq(self, msg: logic_pb2.Primitive): - flat1151 = self._try_flat(msg, self.pretty_eq) - if flat1151 is not None: - assert flat1151 is not None - self.write(flat1151) + flat1153 = self._try_flat(msg, self.pretty_eq) + if flat1153 is not None: + assert flat1153 is not None + self.write(flat1153) return None else: _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_eq": - _t1680 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) + _t1684 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) else: - _t1680 = None - fields1147 = _t1680 - assert fields1147 is not None - unwrapped_fields1148 = fields1147 + _t1684 = None + fields1149 = _t1684 + assert fields1149 is not None + unwrapped_fields1150 = fields1149 self.write("(=") self.indent_sexp() self.newline() - field1149 = unwrapped_fields1148[0] - self.pretty_term(field1149) + field1151 = unwrapped_fields1150[0] + self.pretty_term(field1151) self.newline() - field1150 = unwrapped_fields1148[1] - self.pretty_term(field1150) + field1152 = unwrapped_fields1150[1] + self.pretty_term(field1152) self.dedent() self.write(")") def pretty_lt(self, msg: logic_pb2.Primitive): - flat1156 = self._try_flat(msg, self.pretty_lt) - if flat1156 is not None: - assert flat1156 is not None - self.write(flat1156) + flat1158 = self._try_flat(msg, self.pretty_lt) + if flat1158 is not None: + assert flat1158 is not None + self.write(flat1158) return None else: _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_lt_monotype": - _t1681 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) + _t1685 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) else: - _t1681 = None - fields1152 = _t1681 - assert fields1152 is not None - unwrapped_fields1153 = fields1152 + _t1685 = None + fields1154 = _t1685 + assert fields1154 is not None + unwrapped_fields1155 = fields1154 self.write("(<") self.indent_sexp() self.newline() - field1154 = unwrapped_fields1153[0] - self.pretty_term(field1154) + field1156 = unwrapped_fields1155[0] + self.pretty_term(field1156) self.newline() - field1155 = unwrapped_fields1153[1] - self.pretty_term(field1155) + field1157 = unwrapped_fields1155[1] + self.pretty_term(field1157) self.dedent() self.write(")") def pretty_lt_eq(self, msg: logic_pb2.Primitive): - flat1161 = self._try_flat(msg, self.pretty_lt_eq) - if flat1161 is not None: - assert flat1161 is not None - self.write(flat1161) + flat1163 = self._try_flat(msg, self.pretty_lt_eq) + if flat1163 is not None: + assert flat1163 is not None + self.write(flat1163) return None else: _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_lt_eq_monotype": - _t1682 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) + _t1686 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) else: - _t1682 = None - fields1157 = _t1682 - assert fields1157 is not None - unwrapped_fields1158 = fields1157 + _t1686 = None + fields1159 = _t1686 + assert fields1159 is not None + unwrapped_fields1160 = fields1159 self.write("(<=") self.indent_sexp() self.newline() - field1159 = unwrapped_fields1158[0] - self.pretty_term(field1159) + field1161 = unwrapped_fields1160[0] + self.pretty_term(field1161) self.newline() - field1160 = unwrapped_fields1158[1] - self.pretty_term(field1160) + field1162 = unwrapped_fields1160[1] + self.pretty_term(field1162) self.dedent() self.write(")") def pretty_gt(self, msg: logic_pb2.Primitive): - flat1166 = self._try_flat(msg, self.pretty_gt) - if flat1166 is not None: - assert flat1166 is not None - self.write(flat1166) + flat1168 = self._try_flat(msg, self.pretty_gt) + if flat1168 is not None: + assert flat1168 is not None + self.write(flat1168) return None else: _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_gt_monotype": - _t1683 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) + _t1687 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) else: - _t1683 = None - fields1162 = _t1683 - assert fields1162 is not None - unwrapped_fields1163 = fields1162 + _t1687 = None + fields1164 = _t1687 + assert fields1164 is not None + unwrapped_fields1165 = fields1164 self.write("(>") self.indent_sexp() self.newline() - field1164 = unwrapped_fields1163[0] - self.pretty_term(field1164) + field1166 = unwrapped_fields1165[0] + self.pretty_term(field1166) self.newline() - field1165 = unwrapped_fields1163[1] - self.pretty_term(field1165) + field1167 = unwrapped_fields1165[1] + self.pretty_term(field1167) self.dedent() self.write(")") def pretty_gt_eq(self, msg: logic_pb2.Primitive): - flat1171 = self._try_flat(msg, self.pretty_gt_eq) - if flat1171 is not None: - assert flat1171 is not None - self.write(flat1171) + flat1173 = self._try_flat(msg, self.pretty_gt_eq) + if flat1173 is not None: + assert flat1173 is not None + self.write(flat1173) return None else: _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_gt_eq_monotype": - _t1684 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) + _t1688 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) else: - _t1684 = None - fields1167 = _t1684 - assert fields1167 is not None - unwrapped_fields1168 = fields1167 + _t1688 = None + fields1169 = _t1688 + assert fields1169 is not None + unwrapped_fields1170 = fields1169 self.write("(>=") self.indent_sexp() self.newline() - field1169 = unwrapped_fields1168[0] - self.pretty_term(field1169) + field1171 = unwrapped_fields1170[0] + self.pretty_term(field1171) self.newline() - field1170 = unwrapped_fields1168[1] - self.pretty_term(field1170) + field1172 = unwrapped_fields1170[1] + self.pretty_term(field1172) self.dedent() self.write(")") def pretty_add(self, msg: logic_pb2.Primitive): - flat1177 = self._try_flat(msg, self.pretty_add) - if flat1177 is not None: - assert flat1177 is not None - self.write(flat1177) + flat1179 = self._try_flat(msg, self.pretty_add) + 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_add_monotype": - _t1685 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) + _t1689 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) else: - _t1685 = None - fields1172 = _t1685 - assert fields1172 is not None - unwrapped_fields1173 = fields1172 + _t1689 = None + fields1174 = _t1689 + assert fields1174 is not None + unwrapped_fields1175 = fields1174 self.write("(+") self.indent_sexp() self.newline() - field1174 = unwrapped_fields1173[0] - self.pretty_term(field1174) + field1176 = unwrapped_fields1175[0] + self.pretty_term(field1176) self.newline() - field1175 = unwrapped_fields1173[1] - self.pretty_term(field1175) + field1177 = unwrapped_fields1175[1] + self.pretty_term(field1177) self.newline() - field1176 = unwrapped_fields1173[2] - self.pretty_term(field1176) + field1178 = unwrapped_fields1175[2] + self.pretty_term(field1178) self.dedent() self.write(")") def pretty_minus(self, msg: logic_pb2.Primitive): - flat1183 = self._try_flat(msg, self.pretty_minus) - if flat1183 is not None: - assert flat1183 is not None - self.write(flat1183) + flat1185 = self._try_flat(msg, self.pretty_minus) + if flat1185 is not None: + assert flat1185 is not None + self.write(flat1185) return None else: _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_subtract_monotype": - _t1686 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) + _t1690 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) else: - _t1686 = None - fields1178 = _t1686 - assert fields1178 is not None - unwrapped_fields1179 = fields1178 + _t1690 = None + fields1180 = _t1690 + 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.newline() - field1182 = unwrapped_fields1179[2] - self.pretty_term(field1182) + field1184 = unwrapped_fields1181[2] + self.pretty_term(field1184) self.dedent() self.write(")") def pretty_multiply(self, msg: logic_pb2.Primitive): - flat1189 = self._try_flat(msg, self.pretty_multiply) - if flat1189 is not None: - assert flat1189 is not None - self.write(flat1189) + flat1191 = self._try_flat(msg, self.pretty_multiply) + if flat1191 is not None: + assert flat1191 is not None + self.write(flat1191) return None else: _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_multiply_monotype": - _t1687 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) + _t1691 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) else: - _t1687 = None - fields1184 = _t1687 - assert fields1184 is not None - unwrapped_fields1185 = fields1184 + _t1691 = None + fields1186 = _t1691 + assert fields1186 is not None + unwrapped_fields1187 = fields1186 self.write("(*") self.indent_sexp() self.newline() - field1186 = unwrapped_fields1185[0] - self.pretty_term(field1186) + field1188 = unwrapped_fields1187[0] + self.pretty_term(field1188) self.newline() - field1187 = unwrapped_fields1185[1] - self.pretty_term(field1187) + field1189 = unwrapped_fields1187[1] + self.pretty_term(field1189) self.newline() - field1188 = unwrapped_fields1185[2] - self.pretty_term(field1188) + field1190 = unwrapped_fields1187[2] + self.pretty_term(field1190) self.dedent() self.write(")") def pretty_divide(self, msg: logic_pb2.Primitive): - flat1195 = self._try_flat(msg, self.pretty_divide) - if flat1195 is not None: - assert flat1195 is not None - self.write(flat1195) + flat1197 = self._try_flat(msg, self.pretty_divide) + if flat1197 is not None: + assert flat1197 is not None + self.write(flat1197) return None else: _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_divide_monotype": - _t1688 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) + _t1692 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) else: - _t1688 = None - fields1190 = _t1688 - assert fields1190 is not None - unwrapped_fields1191 = fields1190 + _t1692 = None + fields1192 = _t1692 + assert fields1192 is not None + unwrapped_fields1193 = fields1192 self.write("(/") self.indent_sexp() self.newline() - field1192 = unwrapped_fields1191[0] - self.pretty_term(field1192) + field1194 = unwrapped_fields1193[0] + self.pretty_term(field1194) self.newline() - field1193 = unwrapped_fields1191[1] - self.pretty_term(field1193) + field1195 = unwrapped_fields1193[1] + self.pretty_term(field1195) self.newline() - field1194 = unwrapped_fields1191[2] - self.pretty_term(field1194) + field1196 = unwrapped_fields1193[2] + self.pretty_term(field1196) self.dedent() self.write(")") def pretty_rel_term(self, msg: logic_pb2.RelTerm): - flat1200 = self._try_flat(msg, self.pretty_rel_term) - if flat1200 is not None: - assert flat1200 is not None - self.write(flat1200) + flat1202 = self._try_flat(msg, self.pretty_rel_term) + if flat1202 is not None: + assert flat1202 is not None + self.write(flat1202) return None else: _dollar_dollar = msg if _dollar_dollar.HasField("specialized_value"): - _t1689 = _dollar_dollar.specialized_value + _t1693 = _dollar_dollar.specialized_value else: - _t1689 = None - deconstruct_result1198 = _t1689 - if deconstruct_result1198 is not None: - assert deconstruct_result1198 is not None - unwrapped1199 = deconstruct_result1198 - self.pretty_specialized_value(unwrapped1199) + _t1693 = None + deconstruct_result1200 = _t1693 + if deconstruct_result1200 is not None: + assert deconstruct_result1200 is not None + unwrapped1201 = deconstruct_result1200 + self.pretty_specialized_value(unwrapped1201) else: _dollar_dollar = msg if _dollar_dollar.HasField("term"): - _t1690 = _dollar_dollar.term + _t1694 = _dollar_dollar.term else: - _t1690 = None - deconstruct_result1196 = _t1690 - if deconstruct_result1196 is not None: - assert deconstruct_result1196 is not None - unwrapped1197 = deconstruct_result1196 - self.pretty_term(unwrapped1197) + _t1694 = None + deconstruct_result1198 = _t1694 + if deconstruct_result1198 is not None: + assert deconstruct_result1198 is not None + unwrapped1199 = deconstruct_result1198 + self.pretty_term(unwrapped1199) else: raise ParseError("No matching rule for rel_term") def pretty_specialized_value(self, msg: logic_pb2.Value): - flat1202 = self._try_flat(msg, self.pretty_specialized_value) - if flat1202 is not None: - assert flat1202 is not None - self.write(flat1202) + flat1204 = self._try_flat(msg, self.pretty_specialized_value) + if flat1204 is not None: + assert flat1204 is not None + self.write(flat1204) return None else: - fields1201 = msg + fields1203 = msg self.write("#") - self.pretty_raw_value(fields1201) + self.pretty_raw_value(fields1203) def pretty_rel_atom(self, msg: logic_pb2.RelAtom): - flat1209 = self._try_flat(msg, self.pretty_rel_atom) - if flat1209 is not None: - assert flat1209 is not None - self.write(flat1209) + flat1211 = self._try_flat(msg, self.pretty_rel_atom) + if flat1211 is not None: + assert flat1211 is not None + self.write(flat1211) return None else: _dollar_dollar = msg - fields1203 = (_dollar_dollar.name, _dollar_dollar.terms,) - assert fields1203 is not None - unwrapped_fields1204 = fields1203 + fields1205 = (_dollar_dollar.name, _dollar_dollar.terms,) + assert fields1205 is not None + unwrapped_fields1206 = fields1205 self.write("(relatom") self.indent_sexp() self.newline() - field1205 = unwrapped_fields1204[0] - self.pretty_name(field1205) - field1206 = unwrapped_fields1204[1] - if not len(field1206) == 0: + field1207 = unwrapped_fields1206[0] + self.pretty_name(field1207) + field1208 = unwrapped_fields1206[1] + if not len(field1208) == 0: self.newline() - for i1208, elem1207 in enumerate(field1206): - if (i1208 > 0): + for i1210, elem1209 in enumerate(field1208): + if (i1210 > 0): self.newline() - self.pretty_rel_term(elem1207) + self.pretty_rel_term(elem1209) self.dedent() self.write(")") def pretty_cast(self, msg: logic_pb2.Cast): - flat1214 = self._try_flat(msg, self.pretty_cast) - if flat1214 is not None: - assert flat1214 is not None - self.write(flat1214) + flat1216 = self._try_flat(msg, self.pretty_cast) + if flat1216 is not None: + assert flat1216 is not None + self.write(flat1216) return None else: _dollar_dollar = msg - fields1210 = (_dollar_dollar.input, _dollar_dollar.result,) - assert fields1210 is not None - unwrapped_fields1211 = fields1210 + fields1212 = (_dollar_dollar.input, _dollar_dollar.result,) + assert fields1212 is not None + unwrapped_fields1213 = fields1212 self.write("(cast") self.indent_sexp() self.newline() - field1212 = unwrapped_fields1211[0] - self.pretty_term(field1212) + field1214 = unwrapped_fields1213[0] + self.pretty_term(field1214) self.newline() - field1213 = unwrapped_fields1211[1] - self.pretty_term(field1213) + field1215 = unwrapped_fields1213[1] + self.pretty_term(field1215) self.dedent() self.write(")") def pretty_attrs(self, msg: Sequence[logic_pb2.Attribute]): - flat1218 = self._try_flat(msg, self.pretty_attrs) - if flat1218 is not None: - assert flat1218 is not None - self.write(flat1218) + flat1220 = self._try_flat(msg, self.pretty_attrs) + if flat1220 is not None: + assert flat1220 is not None + self.write(flat1220) return None else: - fields1215 = msg + fields1217 = msg self.write("(attrs") self.indent_sexp() - if not len(fields1215) == 0: + if not len(fields1217) == 0: self.newline() - for i1217, elem1216 in enumerate(fields1215): - if (i1217 > 0): + for i1219, elem1218 in enumerate(fields1217): + if (i1219 > 0): self.newline() - self.pretty_attribute(elem1216) + self.pretty_attribute(elem1218) self.dedent() self.write(")") def pretty_attribute(self, msg: logic_pb2.Attribute): - flat1225 = self._try_flat(msg, self.pretty_attribute) - if flat1225 is not None: - assert flat1225 is not None - self.write(flat1225) + flat1227 = self._try_flat(msg, self.pretty_attribute) + if flat1227 is not None: + assert flat1227 is not None + self.write(flat1227) return None else: _dollar_dollar = msg - fields1219 = (_dollar_dollar.name, _dollar_dollar.args,) - assert fields1219 is not None - unwrapped_fields1220 = fields1219 + fields1221 = (_dollar_dollar.name, _dollar_dollar.args,) + assert fields1221 is not None + unwrapped_fields1222 = fields1221 self.write("(attribute") self.indent_sexp() self.newline() - field1221 = unwrapped_fields1220[0] - self.pretty_name(field1221) - field1222 = unwrapped_fields1220[1] - if not len(field1222) == 0: + field1223 = unwrapped_fields1222[0] + self.pretty_name(field1223) + field1224 = unwrapped_fields1222[1] + if not len(field1224) == 0: self.newline() - for i1224, elem1223 in enumerate(field1222): - if (i1224 > 0): + for i1226, elem1225 in enumerate(field1224): + if (i1226 > 0): self.newline() - self.pretty_raw_value(elem1223) + self.pretty_raw_value(elem1225) self.dedent() self.write(")") def pretty_algorithm(self, msg: logic_pb2.Algorithm): - flat1232 = self._try_flat(msg, self.pretty_algorithm) - if flat1232 is not None: - assert flat1232 is not None - self.write(flat1232) + flat1234 = self._try_flat(msg, self.pretty_algorithm) + if flat1234 is not None: + assert flat1234 is not None + self.write(flat1234) return None else: _dollar_dollar = msg - fields1226 = (getattr(_dollar_dollar, 'global'), _dollar_dollar.body,) - assert fields1226 is not None - unwrapped_fields1227 = fields1226 + fields1228 = (getattr(_dollar_dollar, 'global'), _dollar_dollar.body,) + assert fields1228 is not None + unwrapped_fields1229 = fields1228 self.write("(algorithm") self.indent_sexp() - field1228 = unwrapped_fields1227[0] - if not len(field1228) == 0: + field1230 = unwrapped_fields1229[0] + if not len(field1230) == 0: self.newline() - for i1230, elem1229 in enumerate(field1228): - if (i1230 > 0): + for i1232, elem1231 in enumerate(field1230): + if (i1232 > 0): self.newline() - self.pretty_relation_id(elem1229) + self.pretty_relation_id(elem1231) self.newline() - field1231 = unwrapped_fields1227[1] - self.pretty_script(field1231) + field1233 = unwrapped_fields1229[1] + self.pretty_script(field1233) self.dedent() self.write(")") def pretty_script(self, msg: logic_pb2.Script): - flat1237 = self._try_flat(msg, self.pretty_script) - if flat1237 is not None: - assert flat1237 is not None - self.write(flat1237) + flat1239 = self._try_flat(msg, self.pretty_script) + if flat1239 is not None: + assert flat1239 is not None + self.write(flat1239) return None else: _dollar_dollar = msg - fields1233 = _dollar_dollar.constructs - assert fields1233 is not None - unwrapped_fields1234 = fields1233 + fields1235 = _dollar_dollar.constructs + assert fields1235 is not None + unwrapped_fields1236 = fields1235 self.write("(script") self.indent_sexp() - if not len(unwrapped_fields1234) == 0: + if not len(unwrapped_fields1236) == 0: self.newline() - for i1236, elem1235 in enumerate(unwrapped_fields1234): - if (i1236 > 0): + for i1238, elem1237 in enumerate(unwrapped_fields1236): + if (i1238 > 0): self.newline() - self.pretty_construct(elem1235) + self.pretty_construct(elem1237) self.dedent() self.write(")") def pretty_construct(self, msg: logic_pb2.Construct): - flat1242 = self._try_flat(msg, self.pretty_construct) - if flat1242 is not None: - assert flat1242 is not None - self.write(flat1242) + flat1244 = self._try_flat(msg, self.pretty_construct) + if flat1244 is not None: + assert flat1244 is not None + self.write(flat1244) return None else: _dollar_dollar = msg if _dollar_dollar.HasField("loop"): - _t1691 = _dollar_dollar.loop + _t1695 = _dollar_dollar.loop else: - _t1691 = None - deconstruct_result1240 = _t1691 - if deconstruct_result1240 is not None: - assert deconstruct_result1240 is not None - unwrapped1241 = deconstruct_result1240 - self.pretty_loop(unwrapped1241) + _t1695 = None + deconstruct_result1242 = _t1695 + if deconstruct_result1242 is not None: + assert deconstruct_result1242 is not None + unwrapped1243 = deconstruct_result1242 + self.pretty_loop(unwrapped1243) else: _dollar_dollar = msg if _dollar_dollar.HasField("instruction"): - _t1692 = _dollar_dollar.instruction + _t1696 = _dollar_dollar.instruction else: - _t1692 = None - deconstruct_result1238 = _t1692 - if deconstruct_result1238 is not None: - assert deconstruct_result1238 is not None - unwrapped1239 = deconstruct_result1238 - self.pretty_instruction(unwrapped1239) + _t1696 = None + deconstruct_result1240 = _t1696 + if deconstruct_result1240 is not None: + assert deconstruct_result1240 is not None + unwrapped1241 = deconstruct_result1240 + self.pretty_instruction(unwrapped1241) else: raise ParseError("No matching rule for construct") def pretty_loop(self, msg: logic_pb2.Loop): - flat1247 = self._try_flat(msg, self.pretty_loop) - if flat1247 is not None: - assert flat1247 is not None - self.write(flat1247) + flat1249 = self._try_flat(msg, self.pretty_loop) + if flat1249 is not None: + assert flat1249 is not None + self.write(flat1249) return None else: _dollar_dollar = msg - fields1243 = (_dollar_dollar.init, _dollar_dollar.body,) - assert fields1243 is not None - unwrapped_fields1244 = fields1243 + fields1245 = (_dollar_dollar.init, _dollar_dollar.body,) + assert fields1245 is not None + unwrapped_fields1246 = fields1245 self.write("(loop") self.indent_sexp() self.newline() - field1245 = unwrapped_fields1244[0] - self.pretty_init(field1245) + field1247 = unwrapped_fields1246[0] + self.pretty_init(field1247) self.newline() - field1246 = unwrapped_fields1244[1] - self.pretty_script(field1246) + field1248 = unwrapped_fields1246[1] + self.pretty_script(field1248) self.dedent() self.write(")") def pretty_init(self, msg: Sequence[logic_pb2.Instruction]): - flat1251 = self._try_flat(msg, self.pretty_init) - if flat1251 is not None: - assert flat1251 is not None - self.write(flat1251) + flat1253 = self._try_flat(msg, self.pretty_init) + if flat1253 is not None: + assert flat1253 is not None + self.write(flat1253) return None else: - fields1248 = msg + fields1250 = msg self.write("(init") self.indent_sexp() - if not len(fields1248) == 0: + if not len(fields1250) == 0: self.newline() - for i1250, elem1249 in enumerate(fields1248): - if (i1250 > 0): + for i1252, elem1251 in enumerate(fields1250): + if (i1252 > 0): self.newline() - self.pretty_instruction(elem1249) + self.pretty_instruction(elem1251) self.dedent() self.write(")") def pretty_instruction(self, msg: logic_pb2.Instruction): - flat1262 = self._try_flat(msg, self.pretty_instruction) - if flat1262 is not None: - assert flat1262 is not None - self.write(flat1262) + flat1264 = self._try_flat(msg, self.pretty_instruction) + if flat1264 is not None: + assert flat1264 is not None + self.write(flat1264) return None else: _dollar_dollar = msg if _dollar_dollar.HasField("assign"): - _t1693 = _dollar_dollar.assign + _t1697 = _dollar_dollar.assign else: - _t1693 = None - deconstruct_result1260 = _t1693 - if deconstruct_result1260 is not None: - assert deconstruct_result1260 is not None - unwrapped1261 = deconstruct_result1260 - self.pretty_assign(unwrapped1261) + _t1697 = None + deconstruct_result1262 = _t1697 + if deconstruct_result1262 is not None: + assert deconstruct_result1262 is not None + unwrapped1263 = deconstruct_result1262 + self.pretty_assign(unwrapped1263) else: _dollar_dollar = msg if _dollar_dollar.HasField("upsert"): - _t1694 = _dollar_dollar.upsert + _t1698 = _dollar_dollar.upsert else: - _t1694 = None - deconstruct_result1258 = _t1694 - if deconstruct_result1258 is not None: - assert deconstruct_result1258 is not None - unwrapped1259 = deconstruct_result1258 - self.pretty_upsert(unwrapped1259) + _t1698 = None + deconstruct_result1260 = _t1698 + if deconstruct_result1260 is not None: + assert deconstruct_result1260 is not None + unwrapped1261 = deconstruct_result1260 + self.pretty_upsert(unwrapped1261) else: _dollar_dollar = msg if _dollar_dollar.HasField("break"): - _t1695 = getattr(_dollar_dollar, 'break') + _t1699 = getattr(_dollar_dollar, 'break') else: - _t1695 = None - deconstruct_result1256 = _t1695 - if deconstruct_result1256 is not None: - assert deconstruct_result1256 is not None - unwrapped1257 = deconstruct_result1256 - self.pretty_break(unwrapped1257) + _t1699 = None + deconstruct_result1258 = _t1699 + if deconstruct_result1258 is not None: + assert deconstruct_result1258 is not None + unwrapped1259 = deconstruct_result1258 + self.pretty_break(unwrapped1259) else: _dollar_dollar = msg if _dollar_dollar.HasField("monoid_def"): - _t1696 = _dollar_dollar.monoid_def + _t1700 = _dollar_dollar.monoid_def else: - _t1696 = None - deconstruct_result1254 = _t1696 - if deconstruct_result1254 is not None: - assert deconstruct_result1254 is not None - unwrapped1255 = deconstruct_result1254 - self.pretty_monoid_def(unwrapped1255) + _t1700 = None + deconstruct_result1256 = _t1700 + if deconstruct_result1256 is not None: + assert deconstruct_result1256 is not None + unwrapped1257 = deconstruct_result1256 + self.pretty_monoid_def(unwrapped1257) else: _dollar_dollar = msg if _dollar_dollar.HasField("monus_def"): - _t1697 = _dollar_dollar.monus_def + _t1701 = _dollar_dollar.monus_def else: - _t1697 = None - deconstruct_result1252 = _t1697 - if deconstruct_result1252 is not None: - assert deconstruct_result1252 is not None - unwrapped1253 = deconstruct_result1252 - self.pretty_monus_def(unwrapped1253) + _t1701 = None + deconstruct_result1254 = _t1701 + if deconstruct_result1254 is not None: + assert deconstruct_result1254 is not None + unwrapped1255 = deconstruct_result1254 + self.pretty_monus_def(unwrapped1255) else: raise ParseError("No matching rule for instruction") def pretty_assign(self, msg: logic_pb2.Assign): - flat1269 = self._try_flat(msg, self.pretty_assign) - if flat1269 is not None: - assert flat1269 is not None - self.write(flat1269) + flat1271 = self._try_flat(msg, self.pretty_assign) + if flat1271 is not None: + assert flat1271 is not None + self.write(flat1271) return None else: _dollar_dollar = msg if not len(_dollar_dollar.attrs) == 0: - _t1698 = _dollar_dollar.attrs + _t1702 = _dollar_dollar.attrs else: - _t1698 = None - fields1263 = (_dollar_dollar.name, _dollar_dollar.body, _t1698,) - assert fields1263 is not None - unwrapped_fields1264 = fields1263 + _t1702 = None + fields1265 = (_dollar_dollar.name, _dollar_dollar.body, _t1702,) + assert fields1265 is not None + unwrapped_fields1266 = fields1265 self.write("(assign") self.indent_sexp() self.newline() - field1265 = unwrapped_fields1264[0] - self.pretty_relation_id(field1265) + field1267 = unwrapped_fields1266[0] + self.pretty_relation_id(field1267) self.newline() - field1266 = unwrapped_fields1264[1] - self.pretty_abstraction(field1266) - field1267 = unwrapped_fields1264[2] - if field1267 is not None: + field1268 = unwrapped_fields1266[1] + self.pretty_abstraction(field1268) + field1269 = unwrapped_fields1266[2] + if field1269 is not None: self.newline() - assert field1267 is not None - opt_val1268 = field1267 - self.pretty_attrs(opt_val1268) + assert field1269 is not None + opt_val1270 = field1269 + self.pretty_attrs(opt_val1270) self.dedent() self.write(")") def pretty_upsert(self, msg: logic_pb2.Upsert): - flat1276 = self._try_flat(msg, self.pretty_upsert) - if flat1276 is not None: - assert flat1276 is not None - self.write(flat1276) + flat1278 = self._try_flat(msg, self.pretty_upsert) + if flat1278 is not None: + assert flat1278 is not None + self.write(flat1278) return None else: _dollar_dollar = msg if not len(_dollar_dollar.attrs) == 0: - _t1699 = _dollar_dollar.attrs + _t1703 = _dollar_dollar.attrs else: - _t1699 = None - fields1270 = (_dollar_dollar.name, (_dollar_dollar.body, _dollar_dollar.value_arity,), _t1699,) - assert fields1270 is not None - unwrapped_fields1271 = fields1270 + _t1703 = None + fields1272 = (_dollar_dollar.name, (_dollar_dollar.body, _dollar_dollar.value_arity,), _t1703,) + assert fields1272 is not None + unwrapped_fields1273 = fields1272 self.write("(upsert") self.indent_sexp() self.newline() - field1272 = unwrapped_fields1271[0] - self.pretty_relation_id(field1272) + field1274 = unwrapped_fields1273[0] + self.pretty_relation_id(field1274) self.newline() - field1273 = unwrapped_fields1271[1] - self.pretty_abstraction_with_arity(field1273) - field1274 = unwrapped_fields1271[2] - if field1274 is not None: + field1275 = unwrapped_fields1273[1] + self.pretty_abstraction_with_arity(field1275) + field1276 = unwrapped_fields1273[2] + if field1276 is not None: self.newline() - assert field1274 is not None - opt_val1275 = field1274 - self.pretty_attrs(opt_val1275) + assert field1276 is not None + opt_val1277 = field1276 + self.pretty_attrs(opt_val1277) self.dedent() self.write(")") def pretty_abstraction_with_arity(self, msg: tuple[logic_pb2.Abstraction, int]): - flat1281 = self._try_flat(msg, self.pretty_abstraction_with_arity) - if flat1281 is not None: - assert flat1281 is not None - self.write(flat1281) + flat1283 = self._try_flat(msg, self.pretty_abstraction_with_arity) + if flat1283 is not None: + assert flat1283 is not None + self.write(flat1283) return None else: _dollar_dollar = msg - _t1700 = self.deconstruct_bindings_with_arity(_dollar_dollar[0], _dollar_dollar[1]) - fields1277 = (_t1700, _dollar_dollar[0].value,) - assert fields1277 is not None - unwrapped_fields1278 = fields1277 + _t1704 = self.deconstruct_bindings_with_arity(_dollar_dollar[0], _dollar_dollar[1]) + fields1279 = (_t1704, _dollar_dollar[0].value,) + assert fields1279 is not None + unwrapped_fields1280 = fields1279 self.write("(") self.indent() - field1279 = unwrapped_fields1278[0] - self.pretty_bindings(field1279) + field1281 = unwrapped_fields1280[0] + self.pretty_bindings(field1281) self.newline() - field1280 = unwrapped_fields1278[1] - self.pretty_formula(field1280) + field1282 = unwrapped_fields1280[1] + self.pretty_formula(field1282) self.dedent() self.write(")") def pretty_break(self, msg: logic_pb2.Break): - flat1288 = self._try_flat(msg, self.pretty_break) - if flat1288 is not None: - assert flat1288 is not None - self.write(flat1288) + flat1290 = self._try_flat(msg, self.pretty_break) + if flat1290 is not None: + assert flat1290 is not None + self.write(flat1290) return None else: _dollar_dollar = msg if not len(_dollar_dollar.attrs) == 0: - _t1701 = _dollar_dollar.attrs + _t1705 = _dollar_dollar.attrs else: - _t1701 = None - fields1282 = (_dollar_dollar.name, _dollar_dollar.body, _t1701,) - assert fields1282 is not None - unwrapped_fields1283 = fields1282 + _t1705 = None + fields1284 = (_dollar_dollar.name, _dollar_dollar.body, _t1705,) + assert fields1284 is not None + unwrapped_fields1285 = fields1284 self.write("(break") self.indent_sexp() self.newline() - field1284 = unwrapped_fields1283[0] - self.pretty_relation_id(field1284) + field1286 = unwrapped_fields1285[0] + self.pretty_relation_id(field1286) self.newline() - field1285 = unwrapped_fields1283[1] - self.pretty_abstraction(field1285) - field1286 = unwrapped_fields1283[2] - if field1286 is not None: + field1287 = unwrapped_fields1285[1] + self.pretty_abstraction(field1287) + field1288 = unwrapped_fields1285[2] + if field1288 is not None: self.newline() - assert field1286 is not None - opt_val1287 = field1286 - self.pretty_attrs(opt_val1287) + assert field1288 is not None + opt_val1289 = field1288 + self.pretty_attrs(opt_val1289) self.dedent() self.write(")") def pretty_monoid_def(self, msg: logic_pb2.MonoidDef): - flat1296 = self._try_flat(msg, self.pretty_monoid_def) - if flat1296 is not None: - assert flat1296 is not None - self.write(flat1296) + flat1298 = self._try_flat(msg, self.pretty_monoid_def) + if flat1298 is not None: + assert flat1298 is not None + self.write(flat1298) return None else: _dollar_dollar = msg if not len(_dollar_dollar.attrs) == 0: - _t1702 = _dollar_dollar.attrs + _t1706 = _dollar_dollar.attrs else: - _t1702 = None - fields1289 = (_dollar_dollar.monoid, _dollar_dollar.name, (_dollar_dollar.body, _dollar_dollar.value_arity,), _t1702,) - assert fields1289 is not None - unwrapped_fields1290 = fields1289 + _t1706 = None + fields1291 = (_dollar_dollar.monoid, _dollar_dollar.name, (_dollar_dollar.body, _dollar_dollar.value_arity,), _t1706,) + assert fields1291 is not None + unwrapped_fields1292 = fields1291 self.write("(monoid") self.indent_sexp() self.newline() - field1291 = unwrapped_fields1290[0] - self.pretty_monoid(field1291) + field1293 = unwrapped_fields1292[0] + self.pretty_monoid(field1293) self.newline() - field1292 = unwrapped_fields1290[1] - self.pretty_relation_id(field1292) + field1294 = unwrapped_fields1292[1] + self.pretty_relation_id(field1294) self.newline() - field1293 = unwrapped_fields1290[2] - self.pretty_abstraction_with_arity(field1293) - field1294 = unwrapped_fields1290[3] - if field1294 is not None: + field1295 = unwrapped_fields1292[2] + self.pretty_abstraction_with_arity(field1295) + field1296 = unwrapped_fields1292[3] + if field1296 is not None: self.newline() - assert field1294 is not None - opt_val1295 = field1294 - self.pretty_attrs(opt_val1295) + assert field1296 is not None + opt_val1297 = field1296 + self.pretty_attrs(opt_val1297) self.dedent() self.write(")") def pretty_monoid(self, msg: logic_pb2.Monoid): - flat1305 = self._try_flat(msg, self.pretty_monoid) - if flat1305 is not None: - assert flat1305 is not None - self.write(flat1305) + flat1307 = self._try_flat(msg, self.pretty_monoid) + if flat1307 is not None: + assert flat1307 is not None + self.write(flat1307) return None else: _dollar_dollar = msg if _dollar_dollar.HasField("or_monoid"): - _t1703 = _dollar_dollar.or_monoid + _t1707 = _dollar_dollar.or_monoid else: - _t1703 = None - deconstruct_result1303 = _t1703 - if deconstruct_result1303 is not None: - assert deconstruct_result1303 is not None - unwrapped1304 = deconstruct_result1303 - self.pretty_or_monoid(unwrapped1304) + _t1707 = None + deconstruct_result1305 = _t1707 + if deconstruct_result1305 is not None: + assert deconstruct_result1305 is not None + unwrapped1306 = deconstruct_result1305 + self.pretty_or_monoid(unwrapped1306) else: _dollar_dollar = msg if _dollar_dollar.HasField("min_monoid"): - _t1704 = _dollar_dollar.min_monoid + _t1708 = _dollar_dollar.min_monoid else: - _t1704 = None - deconstruct_result1301 = _t1704 - if deconstruct_result1301 is not None: - assert deconstruct_result1301 is not None - unwrapped1302 = deconstruct_result1301 - self.pretty_min_monoid(unwrapped1302) + _t1708 = None + deconstruct_result1303 = _t1708 + if deconstruct_result1303 is not None: + assert deconstruct_result1303 is not None + unwrapped1304 = deconstruct_result1303 + self.pretty_min_monoid(unwrapped1304) else: _dollar_dollar = msg if _dollar_dollar.HasField("max_monoid"): - _t1705 = _dollar_dollar.max_monoid + _t1709 = _dollar_dollar.max_monoid else: - _t1705 = None - deconstruct_result1299 = _t1705 - if deconstruct_result1299 is not None: - assert deconstruct_result1299 is not None - unwrapped1300 = deconstruct_result1299 - self.pretty_max_monoid(unwrapped1300) + _t1709 = None + deconstruct_result1301 = _t1709 + if deconstruct_result1301 is not None: + assert deconstruct_result1301 is not None + unwrapped1302 = deconstruct_result1301 + self.pretty_max_monoid(unwrapped1302) else: _dollar_dollar = msg if _dollar_dollar.HasField("sum_monoid"): - _t1706 = _dollar_dollar.sum_monoid + _t1710 = _dollar_dollar.sum_monoid else: - _t1706 = None - deconstruct_result1297 = _t1706 - if deconstruct_result1297 is not None: - assert deconstruct_result1297 is not None - unwrapped1298 = deconstruct_result1297 - self.pretty_sum_monoid(unwrapped1298) + _t1710 = None + deconstruct_result1299 = _t1710 + if deconstruct_result1299 is not None: + assert deconstruct_result1299 is not None + unwrapped1300 = deconstruct_result1299 + self.pretty_sum_monoid(unwrapped1300) else: raise ParseError("No matching rule for monoid") def pretty_or_monoid(self, msg: logic_pb2.OrMonoid): - fields1306 = msg + fields1308 = msg self.write("(or)") def pretty_min_monoid(self, msg: logic_pb2.MinMonoid): - flat1309 = self._try_flat(msg, self.pretty_min_monoid) - if flat1309 is not None: - assert flat1309 is not None - self.write(flat1309) + flat1311 = self._try_flat(msg, self.pretty_min_monoid) + if flat1311 is not None: + assert flat1311 is not None + self.write(flat1311) return None else: _dollar_dollar = msg - fields1307 = _dollar_dollar.type - assert fields1307 is not None - unwrapped_fields1308 = fields1307 + fields1309 = _dollar_dollar.type + assert fields1309 is not None + unwrapped_fields1310 = fields1309 self.write("(min") self.indent_sexp() self.newline() - self.pretty_type(unwrapped_fields1308) + self.pretty_type(unwrapped_fields1310) self.dedent() self.write(")") def pretty_max_monoid(self, msg: logic_pb2.MaxMonoid): - flat1312 = self._try_flat(msg, self.pretty_max_monoid) - if flat1312 is not None: - assert flat1312 is not None - self.write(flat1312) + flat1314 = self._try_flat(msg, self.pretty_max_monoid) + if flat1314 is not None: + assert flat1314 is not None + self.write(flat1314) return None else: _dollar_dollar = msg - fields1310 = _dollar_dollar.type - assert fields1310 is not None - unwrapped_fields1311 = fields1310 + fields1312 = _dollar_dollar.type + assert fields1312 is not None + unwrapped_fields1313 = fields1312 self.write("(max") self.indent_sexp() self.newline() - self.pretty_type(unwrapped_fields1311) + self.pretty_type(unwrapped_fields1313) self.dedent() self.write(")") def pretty_sum_monoid(self, msg: logic_pb2.SumMonoid): - flat1315 = self._try_flat(msg, self.pretty_sum_monoid) - if flat1315 is not None: - assert flat1315 is not None - self.write(flat1315) + flat1317 = self._try_flat(msg, self.pretty_sum_monoid) + if flat1317 is not None: + assert flat1317 is not None + self.write(flat1317) return None else: _dollar_dollar = msg - fields1313 = _dollar_dollar.type - assert fields1313 is not None - unwrapped_fields1314 = fields1313 + fields1315 = _dollar_dollar.type + assert fields1315 is not None + unwrapped_fields1316 = fields1315 self.write("(sum") self.indent_sexp() self.newline() - self.pretty_type(unwrapped_fields1314) + self.pretty_type(unwrapped_fields1316) self.dedent() self.write(")") def pretty_monus_def(self, msg: logic_pb2.MonusDef): - flat1323 = self._try_flat(msg, self.pretty_monus_def) - if flat1323 is not None: - assert flat1323 is not None - self.write(flat1323) + flat1325 = self._try_flat(msg, self.pretty_monus_def) + if flat1325 is not None: + assert flat1325 is not None + self.write(flat1325) return None else: _dollar_dollar = msg if not len(_dollar_dollar.attrs) == 0: - _t1707 = _dollar_dollar.attrs + _t1711 = _dollar_dollar.attrs else: - _t1707 = None - fields1316 = (_dollar_dollar.monoid, _dollar_dollar.name, (_dollar_dollar.body, _dollar_dollar.value_arity,), _t1707,) - assert fields1316 is not None - unwrapped_fields1317 = fields1316 + _t1711 = None + fields1318 = (_dollar_dollar.monoid, _dollar_dollar.name, (_dollar_dollar.body, _dollar_dollar.value_arity,), _t1711,) + assert fields1318 is not None + unwrapped_fields1319 = fields1318 self.write("(monus") self.indent_sexp() self.newline() - field1318 = unwrapped_fields1317[0] - self.pretty_monoid(field1318) + field1320 = unwrapped_fields1319[0] + self.pretty_monoid(field1320) self.newline() - field1319 = unwrapped_fields1317[1] - self.pretty_relation_id(field1319) + field1321 = unwrapped_fields1319[1] + self.pretty_relation_id(field1321) self.newline() - field1320 = unwrapped_fields1317[2] - self.pretty_abstraction_with_arity(field1320) - field1321 = unwrapped_fields1317[3] - if field1321 is not None: + field1322 = unwrapped_fields1319[2] + self.pretty_abstraction_with_arity(field1322) + field1323 = unwrapped_fields1319[3] + if field1323 is not None: self.newline() - assert field1321 is not None - opt_val1322 = field1321 - self.pretty_attrs(opt_val1322) + assert field1323 is not None + opt_val1324 = field1323 + self.pretty_attrs(opt_val1324) self.dedent() self.write(")") def pretty_constraint(self, msg: logic_pb2.Constraint): - flat1330 = self._try_flat(msg, self.pretty_constraint) - if flat1330 is not None: - assert flat1330 is not None - self.write(flat1330) + flat1332 = self._try_flat(msg, self.pretty_constraint) + if flat1332 is not None: + assert flat1332 is not None + self.write(flat1332) return None else: _dollar_dollar = msg - fields1324 = (_dollar_dollar.name, _dollar_dollar.functional_dependency.guard, _dollar_dollar.functional_dependency.keys, _dollar_dollar.functional_dependency.values,) - assert fields1324 is not None - unwrapped_fields1325 = fields1324 + fields1326 = (_dollar_dollar.name, _dollar_dollar.functional_dependency.guard, _dollar_dollar.functional_dependency.keys, _dollar_dollar.functional_dependency.values,) + assert fields1326 is not None + unwrapped_fields1327 = fields1326 self.write("(functional_dependency") self.indent_sexp() self.newline() - field1326 = unwrapped_fields1325[0] - self.pretty_relation_id(field1326) + field1328 = unwrapped_fields1327[0] + self.pretty_relation_id(field1328) self.newline() - field1327 = unwrapped_fields1325[1] - self.pretty_abstraction(field1327) + field1329 = unwrapped_fields1327[1] + self.pretty_abstraction(field1329) self.newline() - field1328 = unwrapped_fields1325[2] - self.pretty_functional_dependency_keys(field1328) + field1330 = unwrapped_fields1327[2] + self.pretty_functional_dependency_keys(field1330) self.newline() - field1329 = unwrapped_fields1325[3] - self.pretty_functional_dependency_values(field1329) + field1331 = unwrapped_fields1327[3] + self.pretty_functional_dependency_values(field1331) self.dedent() self.write(")") def pretty_functional_dependency_keys(self, msg: Sequence[logic_pb2.Var]): - flat1334 = self._try_flat(msg, self.pretty_functional_dependency_keys) - if flat1334 is not None: - assert flat1334 is not None - self.write(flat1334) + flat1336 = self._try_flat(msg, self.pretty_functional_dependency_keys) + if flat1336 is not None: + assert flat1336 is not None + self.write(flat1336) return None else: - fields1331 = msg + fields1333 = msg self.write("(keys") self.indent_sexp() - if not len(fields1331) == 0: + if not len(fields1333) == 0: self.newline() - for i1333, elem1332 in enumerate(fields1331): - if (i1333 > 0): + for i1335, elem1334 in enumerate(fields1333): + if (i1335 > 0): self.newline() - self.pretty_var(elem1332) + self.pretty_var(elem1334) self.dedent() self.write(")") def pretty_functional_dependency_values(self, msg: Sequence[logic_pb2.Var]): - flat1338 = self._try_flat(msg, self.pretty_functional_dependency_values) - if flat1338 is not None: - assert flat1338 is not None - self.write(flat1338) + flat1340 = self._try_flat(msg, self.pretty_functional_dependency_values) + if flat1340 is not None: + assert flat1340 is not None + self.write(flat1340) return None else: - fields1335 = msg + fields1337 = msg self.write("(values") self.indent_sexp() - if not len(fields1335) == 0: + if not len(fields1337) == 0: self.newline() - for i1337, elem1336 in enumerate(fields1335): - if (i1337 > 0): + for i1339, elem1338 in enumerate(fields1337): + if (i1339 > 0): self.newline() - self.pretty_var(elem1336) + self.pretty_var(elem1338) self.dedent() self.write(")") def pretty_data(self, msg: logic_pb2.Data): - flat1347 = self._try_flat(msg, self.pretty_data) - if flat1347 is not None: - assert flat1347 is not None - self.write(flat1347) + flat1349 = self._try_flat(msg, self.pretty_data) + if flat1349 is not None: + assert flat1349 is not None + self.write(flat1349) return None else: _dollar_dollar = msg if _dollar_dollar.HasField("edb"): - _t1708 = _dollar_dollar.edb + _t1712 = _dollar_dollar.edb else: - _t1708 = None - deconstruct_result1345 = _t1708 - if deconstruct_result1345 is not None: - assert deconstruct_result1345 is not None - unwrapped1346 = deconstruct_result1345 - self.pretty_edb(unwrapped1346) + _t1712 = None + deconstruct_result1347 = _t1712 + if deconstruct_result1347 is not None: + assert deconstruct_result1347 is not None + unwrapped1348 = deconstruct_result1347 + self.pretty_edb(unwrapped1348) else: _dollar_dollar = msg if _dollar_dollar.HasField("betree_relation"): - _t1709 = _dollar_dollar.betree_relation + _t1713 = _dollar_dollar.betree_relation else: - _t1709 = None - deconstruct_result1343 = _t1709 - if deconstruct_result1343 is not None: - assert deconstruct_result1343 is not None - unwrapped1344 = deconstruct_result1343 - self.pretty_betree_relation(unwrapped1344) + _t1713 = None + deconstruct_result1345 = _t1713 + if deconstruct_result1345 is not None: + assert deconstruct_result1345 is not None + unwrapped1346 = deconstruct_result1345 + self.pretty_betree_relation(unwrapped1346) else: _dollar_dollar = msg if _dollar_dollar.HasField("csv_data"): - _t1710 = _dollar_dollar.csv_data + _t1714 = _dollar_dollar.csv_data else: - _t1710 = None - deconstruct_result1341 = _t1710 - if deconstruct_result1341 is not None: - assert deconstruct_result1341 is not None - unwrapped1342 = deconstruct_result1341 - self.pretty_csv_data(unwrapped1342) + _t1714 = None + deconstruct_result1343 = _t1714 + if deconstruct_result1343 is not None: + assert deconstruct_result1343 is not None + unwrapped1344 = deconstruct_result1343 + self.pretty_csv_data(unwrapped1344) else: _dollar_dollar = msg if _dollar_dollar.HasField("iceberg_data"): - _t1711 = _dollar_dollar.iceberg_data + _t1715 = _dollar_dollar.iceberg_data else: - _t1711 = None - deconstruct_result1339 = _t1711 - if deconstruct_result1339 is not None: - assert deconstruct_result1339 is not None - unwrapped1340 = deconstruct_result1339 - self.pretty_iceberg_data(unwrapped1340) + _t1715 = None + deconstruct_result1341 = _t1715 + if deconstruct_result1341 is not None: + assert deconstruct_result1341 is not None + unwrapped1342 = deconstruct_result1341 + self.pretty_iceberg_data(unwrapped1342) else: raise ParseError("No matching rule for data") def pretty_edb(self, msg: logic_pb2.EDB): - flat1353 = self._try_flat(msg, self.pretty_edb) - if flat1353 is not None: - assert flat1353 is not None - self.write(flat1353) + flat1355 = self._try_flat(msg, self.pretty_edb) + if flat1355 is not None: + assert flat1355 is not None + self.write(flat1355) return None else: _dollar_dollar = msg - fields1348 = (_dollar_dollar.target_id, _dollar_dollar.path, _dollar_dollar.types,) - assert fields1348 is not None - unwrapped_fields1349 = fields1348 + fields1350 = (_dollar_dollar.target_id, _dollar_dollar.path, _dollar_dollar.types,) + assert fields1350 is not None + unwrapped_fields1351 = fields1350 self.write("(edb") self.indent_sexp() self.newline() - field1350 = unwrapped_fields1349[0] - self.pretty_relation_id(field1350) + field1352 = unwrapped_fields1351[0] + self.pretty_relation_id(field1352) self.newline() - field1351 = unwrapped_fields1349[1] - self.pretty_edb_path(field1351) + field1353 = unwrapped_fields1351[1] + self.pretty_edb_path(field1353) self.newline() - field1352 = unwrapped_fields1349[2] - self.pretty_edb_types(field1352) + field1354 = unwrapped_fields1351[2] + self.pretty_edb_types(field1354) self.dedent() self.write(")") def pretty_edb_path(self, msg: Sequence[str]): - flat1357 = self._try_flat(msg, self.pretty_edb_path) - if flat1357 is not None: - assert flat1357 is not None - self.write(flat1357) + flat1359 = self._try_flat(msg, self.pretty_edb_path) + if flat1359 is not None: + assert flat1359 is not None + self.write(flat1359) return None else: - fields1354 = msg + fields1356 = msg self.write("[") self.indent() - for i1356, elem1355 in enumerate(fields1354): - if (i1356 > 0): + for i1358, elem1357 in enumerate(fields1356): + if (i1358 > 0): self.newline() - self.write(self.format_string_value(elem1355)) + self.write(self.format_string_value(elem1357)) self.dedent() self.write("]") def pretty_edb_types(self, msg: Sequence[logic_pb2.Type]): - flat1361 = self._try_flat(msg, self.pretty_edb_types) - if flat1361 is not None: - assert flat1361 is not None - self.write(flat1361) + flat1363 = self._try_flat(msg, self.pretty_edb_types) + if flat1363 is not None: + assert flat1363 is not None + self.write(flat1363) return None else: - fields1358 = msg + fields1360 = msg self.write("[") self.indent() - for i1360, elem1359 in enumerate(fields1358): - if (i1360 > 0): + for i1362, elem1361 in enumerate(fields1360): + if (i1362 > 0): self.newline() - self.pretty_type(elem1359) + self.pretty_type(elem1361) self.dedent() self.write("]") def pretty_betree_relation(self, msg: logic_pb2.BeTreeRelation): - flat1366 = self._try_flat(msg, self.pretty_betree_relation) - if flat1366 is not None: - assert flat1366 is not None - self.write(flat1366) + flat1368 = self._try_flat(msg, self.pretty_betree_relation) + if flat1368 is not None: + assert flat1368 is not None + self.write(flat1368) return None else: _dollar_dollar = msg - fields1362 = (_dollar_dollar.name, _dollar_dollar.relation_info,) - assert fields1362 is not None - unwrapped_fields1363 = fields1362 + fields1364 = (_dollar_dollar.name, _dollar_dollar.relation_info,) + assert fields1364 is not None + unwrapped_fields1365 = fields1364 self.write("(betree_relation") self.indent_sexp() self.newline() - field1364 = unwrapped_fields1363[0] - self.pretty_relation_id(field1364) + field1366 = unwrapped_fields1365[0] + self.pretty_relation_id(field1366) self.newline() - field1365 = unwrapped_fields1363[1] - self.pretty_betree_info(field1365) + field1367 = unwrapped_fields1365[1] + self.pretty_betree_info(field1367) self.dedent() self.write(")") def pretty_betree_info(self, msg: logic_pb2.BeTreeInfo): - flat1372 = self._try_flat(msg, self.pretty_betree_info) - if flat1372 is not None: - assert flat1372 is not None - self.write(flat1372) + flat1374 = self._try_flat(msg, self.pretty_betree_info) + if flat1374 is not None: + assert flat1374 is not None + self.write(flat1374) return None else: _dollar_dollar = msg - _t1712 = self.deconstruct_betree_info_config(_dollar_dollar) - fields1367 = (_dollar_dollar.key_types, _dollar_dollar.value_types, _t1712,) - assert fields1367 is not None - unwrapped_fields1368 = fields1367 + _t1716 = self.deconstruct_betree_info_config(_dollar_dollar) + fields1369 = (_dollar_dollar.key_types, _dollar_dollar.value_types, _t1716,) + assert fields1369 is not None + unwrapped_fields1370 = fields1369 self.write("(betree_info") self.indent_sexp() self.newline() - field1369 = unwrapped_fields1368[0] - self.pretty_betree_info_key_types(field1369) + field1371 = unwrapped_fields1370[0] + self.pretty_betree_info_key_types(field1371) self.newline() - field1370 = unwrapped_fields1368[1] - self.pretty_betree_info_value_types(field1370) + field1372 = unwrapped_fields1370[1] + self.pretty_betree_info_value_types(field1372) self.newline() - field1371 = unwrapped_fields1368[2] - self.pretty_config_dict(field1371) + field1373 = unwrapped_fields1370[2] + self.pretty_config_dict(field1373) self.dedent() self.write(")") def pretty_betree_info_key_types(self, msg: Sequence[logic_pb2.Type]): - flat1376 = self._try_flat(msg, self.pretty_betree_info_key_types) - if flat1376 is not None: - assert flat1376 is not None - self.write(flat1376) + flat1378 = self._try_flat(msg, self.pretty_betree_info_key_types) + if flat1378 is not None: + assert flat1378 is not None + self.write(flat1378) return None else: - fields1373 = msg + fields1375 = msg self.write("(key_types") self.indent_sexp() - if not len(fields1373) == 0: + if not len(fields1375) == 0: self.newline() - 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_info_value_types(self, msg: Sequence[logic_pb2.Type]): - flat1380 = self._try_flat(msg, self.pretty_betree_info_value_types) - if flat1380 is not None: - assert flat1380 is not None - self.write(flat1380) + flat1382 = self._try_flat(msg, self.pretty_betree_info_value_types) + if flat1382 is not None: + assert flat1382 is not None + self.write(flat1382) return None else: - fields1377 = msg + fields1379 = msg self.write("(value_types") self.indent_sexp() - if not len(fields1377) == 0: + if not len(fields1379) == 0: self.newline() - for i1379, elem1378 in enumerate(fields1377): - if (i1379 > 0): + for i1381, elem1380 in enumerate(fields1379): + if (i1381 > 0): self.newline() - self.pretty_type(elem1378) + self.pretty_type(elem1380) self.dedent() self.write(")") def pretty_csv_data(self, msg: logic_pb2.CSVData): - flat1387 = self._try_flat(msg, self.pretty_csv_data) - if flat1387 is not None: - assert flat1387 is not None - self.write(flat1387) + flat1389 = self._try_flat(msg, self.pretty_csv_data) + if flat1389 is not None: + assert flat1389 is not None + self.write(flat1389) return None else: _dollar_dollar = msg - fields1381 = (_dollar_dollar.locator, _dollar_dollar.config, _dollar_dollar.columns, _dollar_dollar.asof,) - assert fields1381 is not None - unwrapped_fields1382 = fields1381 + fields1383 = (_dollar_dollar.locator, _dollar_dollar.config, _dollar_dollar.columns, _dollar_dollar.asof,) + assert fields1383 is not None + unwrapped_fields1384 = fields1383 self.write("(csv_data") self.indent_sexp() self.newline() - field1383 = unwrapped_fields1382[0] - self.pretty_csvlocator(field1383) + field1385 = unwrapped_fields1384[0] + self.pretty_csvlocator(field1385) self.newline() - field1384 = unwrapped_fields1382[1] - self.pretty_csv_config(field1384) + field1386 = unwrapped_fields1384[1] + self.pretty_csv_config(field1386) self.newline() - field1385 = unwrapped_fields1382[2] - self.pretty_gnf_columns(field1385) + field1387 = unwrapped_fields1384[2] + self.pretty_gnf_columns(field1387) self.newline() - field1386 = unwrapped_fields1382[3] - self.pretty_csv_asof(field1386) + field1388 = unwrapped_fields1384[3] + self.pretty_csv_asof(field1388) self.dedent() self.write(")") def pretty_csvlocator(self, msg: logic_pb2.CSVLocator): - flat1394 = self._try_flat(msg, self.pretty_csvlocator) - if flat1394 is not None: - assert flat1394 is not None - self.write(flat1394) + flat1396 = self._try_flat(msg, self.pretty_csvlocator) + if flat1396 is not None: + assert flat1396 is not None + self.write(flat1396) return None else: _dollar_dollar = msg if not len(_dollar_dollar.paths) == 0: - _t1713 = _dollar_dollar.paths + _t1717 = _dollar_dollar.paths else: - _t1713 = None + _t1717 = None if _dollar_dollar.inline_data.decode('utf-8') != "": - _t1714 = _dollar_dollar.inline_data.decode('utf-8') + _t1718 = _dollar_dollar.inline_data.decode('utf-8') else: - _t1714 = None - fields1388 = (_t1713, _t1714,) - assert fields1388 is not None - unwrapped_fields1389 = fields1388 + _t1718 = None + fields1390 = (_t1717, _t1718,) + assert fields1390 is not None + unwrapped_fields1391 = fields1390 self.write("(csv_locator") self.indent_sexp() - field1390 = unwrapped_fields1389[0] - if field1390 is not None: - self.newline() - assert field1390 is not None - opt_val1391 = field1390 - self.pretty_csv_locator_paths(opt_val1391) - field1392 = unwrapped_fields1389[1] + field1392 = unwrapped_fields1391[0] if field1392 is not None: self.newline() assert field1392 is not None opt_val1393 = field1392 - self.pretty_csv_locator_inline_data(opt_val1393) + self.pretty_csv_locator_paths(opt_val1393) + field1394 = unwrapped_fields1391[1] + if field1394 is not None: + self.newline() + assert field1394 is not None + opt_val1395 = field1394 + self.pretty_csv_locator_inline_data(opt_val1395) self.dedent() self.write(")") def pretty_csv_locator_paths(self, msg: Sequence[str]): - flat1398 = self._try_flat(msg, self.pretty_csv_locator_paths) - if flat1398 is not None: - assert flat1398 is not None - self.write(flat1398) + flat1400 = self._try_flat(msg, self.pretty_csv_locator_paths) + if flat1400 is not None: + assert flat1400 is not None + self.write(flat1400) return None else: - fields1395 = msg + fields1397 = msg self.write("(paths") self.indent_sexp() - if not len(fields1395) == 0: + if not len(fields1397) == 0: self.newline() - for i1397, elem1396 in enumerate(fields1395): - if (i1397 > 0): + for i1399, elem1398 in enumerate(fields1397): + if (i1399 > 0): self.newline() - self.write(self.format_string_value(elem1396)) + self.write(self.format_string_value(elem1398)) self.dedent() self.write(")") def pretty_csv_locator_inline_data(self, msg: str): - flat1400 = self._try_flat(msg, self.pretty_csv_locator_inline_data) - if flat1400 is not None: - assert flat1400 is not None - self.write(flat1400) + flat1402 = self._try_flat(msg, self.pretty_csv_locator_inline_data) + if flat1402 is not None: + assert flat1402 is not None + self.write(flat1402) return None else: - fields1399 = msg + fields1401 = msg self.write("(inline_data") self.indent_sexp() self.newline() - self.write(self.format_string_value(fields1399)) + self.write(self.format_string_value(fields1401)) self.dedent() self.write(")") def pretty_csv_config(self, msg: logic_pb2.CSVConfig): - flat1403 = self._try_flat(msg, self.pretty_csv_config) - if flat1403 is not None: - assert flat1403 is not None - self.write(flat1403) + flat1405 = self._try_flat(msg, self.pretty_csv_config) + if flat1405 is not None: + assert flat1405 is not None + self.write(flat1405) return None else: _dollar_dollar = msg - _t1715 = self.deconstruct_csv_config(_dollar_dollar) - fields1401 = _t1715 - assert fields1401 is not None - unwrapped_fields1402 = fields1401 + _t1719 = self.deconstruct_csv_config(_dollar_dollar) + fields1403 = _t1719 + assert fields1403 is not None + unwrapped_fields1404 = fields1403 self.write("(csv_config") self.indent_sexp() self.newline() - self.pretty_config_dict(unwrapped_fields1402) + self.pretty_config_dict(unwrapped_fields1404) self.dedent() self.write(")") def pretty_gnf_columns(self, msg: Sequence[logic_pb2.GNFColumn]): - flat1407 = self._try_flat(msg, self.pretty_gnf_columns) - if flat1407 is not None: - assert flat1407 is not None - self.write(flat1407) + flat1409 = self._try_flat(msg, self.pretty_gnf_columns) + if flat1409 is not None: + assert flat1409 is not None + self.write(flat1409) return None else: - fields1404 = msg + fields1406 = msg self.write("(columns") self.indent_sexp() - if not len(fields1404) == 0: + if not len(fields1406) == 0: self.newline() - for i1406, elem1405 in enumerate(fields1404): - if (i1406 > 0): + for i1408, elem1407 in enumerate(fields1406): + if (i1408 > 0): self.newline() - self.pretty_gnf_column(elem1405) + self.pretty_gnf_column(elem1407) self.dedent() self.write(")") def pretty_gnf_column(self, msg: logic_pb2.GNFColumn): - flat1416 = self._try_flat(msg, self.pretty_gnf_column) - if flat1416 is not None: - assert flat1416 is not None - self.write(flat1416) + flat1418 = self._try_flat(msg, self.pretty_gnf_column) + if flat1418 is not None: + assert flat1418 is not None + self.write(flat1418) return None else: _dollar_dollar = msg if _dollar_dollar.HasField("target_id"): - _t1716 = _dollar_dollar.target_id + _t1720 = _dollar_dollar.target_id else: - _t1716 = None - fields1408 = (_dollar_dollar.column_path, _t1716, _dollar_dollar.types,) - assert fields1408 is not None - unwrapped_fields1409 = fields1408 + _t1720 = None + fields1410 = (_dollar_dollar.column_path, _t1720, _dollar_dollar.types,) + assert fields1410 is not None + unwrapped_fields1411 = fields1410 self.write("(column") self.indent_sexp() self.newline() - field1410 = unwrapped_fields1409[0] - self.pretty_gnf_column_path(field1410) - field1411 = unwrapped_fields1409[1] - if field1411 is not None: + field1412 = unwrapped_fields1411[0] + self.pretty_gnf_column_path(field1412) + field1413 = unwrapped_fields1411[1] + if field1413 is not None: self.newline() - assert field1411 is not None - opt_val1412 = field1411 - self.pretty_relation_id(opt_val1412) + assert field1413 is not None + opt_val1414 = field1413 + self.pretty_relation_id(opt_val1414) self.newline() self.write("[") - field1413 = unwrapped_fields1409[2] - for i1415, elem1414 in enumerate(field1413): - if (i1415 > 0): + field1415 = unwrapped_fields1411[2] + for i1417, elem1416 in enumerate(field1415): + if (i1417 > 0): self.newline() - self.pretty_type(elem1414) + self.pretty_type(elem1416) self.write("]") self.dedent() self.write(")") def pretty_gnf_column_path(self, msg: Sequence[str]): - flat1423 = self._try_flat(msg, self.pretty_gnf_column_path) - if flat1423 is not None: - assert flat1423 is not None - self.write(flat1423) + flat1425 = self._try_flat(msg, self.pretty_gnf_column_path) + if flat1425 is not None: + assert flat1425 is not None + self.write(flat1425) return None else: _dollar_dollar = msg if len(_dollar_dollar) == 1: - _t1717 = _dollar_dollar[0] + _t1721 = _dollar_dollar[0] else: - _t1717 = None - deconstruct_result1421 = _t1717 - if deconstruct_result1421 is not None: - assert deconstruct_result1421 is not None - unwrapped1422 = deconstruct_result1421 - self.write(self.format_string_value(unwrapped1422)) + _t1721 = None + deconstruct_result1423 = _t1721 + if deconstruct_result1423 is not None: + assert deconstruct_result1423 is not None + unwrapped1424 = deconstruct_result1423 + self.write(self.format_string_value(unwrapped1424)) else: _dollar_dollar = msg if len(_dollar_dollar) != 1: - _t1718 = _dollar_dollar + _t1722 = _dollar_dollar else: - _t1718 = None - deconstruct_result1417 = _t1718 - if deconstruct_result1417 is not None: - assert deconstruct_result1417 is not None - unwrapped1418 = deconstruct_result1417 + _t1722 = None + deconstruct_result1419 = _t1722 + if deconstruct_result1419 is not None: + assert deconstruct_result1419 is not None + unwrapped1420 = deconstruct_result1419 self.write("[") self.indent() - for i1420, elem1419 in enumerate(unwrapped1418): - if (i1420 > 0): + for i1422, elem1421 in enumerate(unwrapped1420): + if (i1422 > 0): self.newline() - self.write(self.format_string_value(elem1419)) + self.write(self.format_string_value(elem1421)) self.dedent() self.write("]") else: raise ParseError("No matching rule for gnf_column_path") def pretty_csv_asof(self, msg: str): - flat1425 = self._try_flat(msg, self.pretty_csv_asof) - if flat1425 is not None: - assert flat1425 is not None - self.write(flat1425) + flat1427 = self._try_flat(msg, self.pretty_csv_asof) + if flat1427 is not None: + assert flat1427 is not None + self.write(flat1427) return None else: - fields1424 = msg + fields1426 = msg self.write("(asof") self.indent_sexp() self.newline() - self.write(self.format_string_value(fields1424)) + self.write(self.format_string_value(fields1426)) self.dedent() self.write(")") def pretty_iceberg_data(self, msg: logic_pb2.IcebergData): - flat1436 = self._try_flat(msg, self.pretty_iceberg_data) - if flat1436 is not None: - assert flat1436 is not None - self.write(flat1436) + flat1438 = self._try_flat(msg, self.pretty_iceberg_data) + if flat1438 is not None: + assert flat1438 is not None + self.write(flat1438) return None else: _dollar_dollar = msg - _t1719 = self.deconstruct_iceberg_data_from_snapshot_optional(_dollar_dollar) - _t1720 = self.deconstruct_iceberg_data_to_snapshot_optional(_dollar_dollar) - fields1426 = (_dollar_dollar.locator, _dollar_dollar.config, _dollar_dollar.columns, _t1719, _t1720, _dollar_dollar.returns_delta,) - assert fields1426 is not None - unwrapped_fields1427 = fields1426 + _t1723 = self.deconstruct_iceberg_data_from_snapshot_optional(_dollar_dollar) + _t1724 = self.deconstruct_iceberg_data_to_snapshot_optional(_dollar_dollar) + fields1428 = (_dollar_dollar.locator, _dollar_dollar.config, _dollar_dollar.columns, _t1723, _t1724, _dollar_dollar.returns_delta,) + assert fields1428 is not None + unwrapped_fields1429 = fields1428 self.write("(iceberg_data") self.indent_sexp() self.newline() - field1428 = unwrapped_fields1427[0] - self.pretty_iceberg_locator(field1428) + field1430 = unwrapped_fields1429[0] + self.pretty_iceberg_locator(field1430) self.newline() - field1429 = unwrapped_fields1427[1] - self.pretty_iceberg_catalog_config(field1429) + field1431 = unwrapped_fields1429[1] + self.pretty_iceberg_catalog_config(field1431) self.newline() - field1430 = unwrapped_fields1427[2] - self.pretty_gnf_columns(field1430) - field1431 = unwrapped_fields1427[3] - if field1431 is not None: - self.newline() - assert field1431 is not None - opt_val1432 = field1431 - self.pretty_iceberg_from_snapshot(opt_val1432) - field1433 = unwrapped_fields1427[4] + field1432 = unwrapped_fields1429[2] + self.pretty_gnf_columns(field1432) + field1433 = unwrapped_fields1429[3] if field1433 is not None: self.newline() assert field1433 is not None opt_val1434 = field1433 - self.pretty_iceberg_to_snapshot(opt_val1434) + self.pretty_iceberg_from_snapshot(opt_val1434) + field1435 = unwrapped_fields1429[4] + if field1435 is not None: + self.newline() + assert field1435 is not None + opt_val1436 = field1435 + self.pretty_iceberg_to_snapshot(opt_val1436) self.newline() - field1435 = unwrapped_fields1427[5] - self.pretty_boolean_value(field1435) + field1437 = unwrapped_fields1429[5] + self.pretty_boolean_value(field1437) self.dedent() self.write(")") def pretty_iceberg_locator(self, msg: logic_pb2.IcebergLocator): - flat1442 = self._try_flat(msg, self.pretty_iceberg_locator) - if flat1442 is not None: - assert flat1442 is not None - self.write(flat1442) + flat1444 = self._try_flat(msg, self.pretty_iceberg_locator) + if flat1444 is not None: + assert flat1444 is not None + self.write(flat1444) return None else: _dollar_dollar = msg - fields1437 = (_dollar_dollar.table_name, _dollar_dollar.namespace, _dollar_dollar.warehouse,) - assert fields1437 is not None - unwrapped_fields1438 = fields1437 + fields1439 = (_dollar_dollar.table_name, _dollar_dollar.namespace, _dollar_dollar.warehouse,) + assert fields1439 is not None + unwrapped_fields1440 = fields1439 self.write("(iceberg_locator") self.indent_sexp() self.newline() - field1439 = unwrapped_fields1438[0] - self.pretty_iceberg_locator_table_name(field1439) + field1441 = unwrapped_fields1440[0] + self.pretty_iceberg_locator_table_name(field1441) self.newline() - field1440 = unwrapped_fields1438[1] - self.pretty_iceberg_locator_namespace(field1440) + field1442 = unwrapped_fields1440[1] + self.pretty_iceberg_locator_namespace(field1442) self.newline() - field1441 = unwrapped_fields1438[2] - self.pretty_iceberg_locator_warehouse(field1441) + field1443 = unwrapped_fields1440[2] + self.pretty_iceberg_locator_warehouse(field1443) self.dedent() self.write(")") def pretty_iceberg_locator_table_name(self, msg: str): - flat1444 = self._try_flat(msg, self.pretty_iceberg_locator_table_name) - if flat1444 is not None: - assert flat1444 is not None - self.write(flat1444) + flat1446 = self._try_flat(msg, self.pretty_iceberg_locator_table_name) + if flat1446 is not None: + assert flat1446 is not None + self.write(flat1446) return None else: - fields1443 = msg + fields1445 = msg self.write("(table_name") self.indent_sexp() self.newline() - self.write(self.format_string_value(fields1443)) + self.write(self.format_string_value(fields1445)) self.dedent() self.write(")") def pretty_iceberg_locator_namespace(self, msg: Sequence[str]): - flat1448 = self._try_flat(msg, self.pretty_iceberg_locator_namespace) - if flat1448 is not None: - assert flat1448 is not None - self.write(flat1448) + flat1450 = self._try_flat(msg, self.pretty_iceberg_locator_namespace) + if flat1450 is not None: + assert flat1450 is not None + self.write(flat1450) return None else: - fields1445 = msg + fields1447 = msg self.write("(namespace") self.indent_sexp() - if not len(fields1445) == 0: + if not len(fields1447) == 0: self.newline() - for i1447, elem1446 in enumerate(fields1445): - if (i1447 > 0): + for i1449, elem1448 in enumerate(fields1447): + if (i1449 > 0): self.newline() - self.write(self.format_string_value(elem1446)) + self.write(self.format_string_value(elem1448)) self.dedent() self.write(")") def pretty_iceberg_locator_warehouse(self, msg: str): - flat1450 = self._try_flat(msg, self.pretty_iceberg_locator_warehouse) - if flat1450 is not None: - assert flat1450 is not None - self.write(flat1450) + flat1452 = self._try_flat(msg, self.pretty_iceberg_locator_warehouse) + if flat1452 is not None: + assert flat1452 is not None + self.write(flat1452) return None else: - fields1449 = msg + fields1451 = msg self.write("(warehouse") self.indent_sexp() self.newline() - self.write(self.format_string_value(fields1449)) + self.write(self.format_string_value(fields1451)) self.dedent() self.write(")") def pretty_iceberg_catalog_config(self, msg: logic_pb2.IcebergCatalogConfig): - flat1458 = self._try_flat(msg, self.pretty_iceberg_catalog_config) - if flat1458 is not None: - assert flat1458 is not None - self.write(flat1458) + flat1460 = self._try_flat(msg, self.pretty_iceberg_catalog_config) + if flat1460 is not None: + assert flat1460 is not None + self.write(flat1460) return None else: _dollar_dollar = msg - _t1721 = self.deconstruct_iceberg_catalog_config_scope_optional(_dollar_dollar) - fields1451 = (_dollar_dollar.catalog_uri, _t1721, sorted(_dollar_dollar.properties.items()), sorted(_dollar_dollar.auth_properties.items()),) - assert fields1451 is not None - unwrapped_fields1452 = fields1451 + _t1725 = self.deconstruct_iceberg_catalog_config_scope_optional(_dollar_dollar) + fields1453 = (_dollar_dollar.catalog_uri, _t1725, sorted(_dollar_dollar.properties.items()), sorted(_dollar_dollar.auth_properties.items()),) + assert fields1453 is not None + unwrapped_fields1454 = fields1453 self.write("(iceberg_catalog_config") self.indent_sexp() self.newline() - field1453 = unwrapped_fields1452[0] - self.pretty_iceberg_catalog_uri(field1453) - field1454 = unwrapped_fields1452[1] - if field1454 is not None: + field1455 = unwrapped_fields1454[0] + self.pretty_iceberg_catalog_uri(field1455) + field1456 = unwrapped_fields1454[1] + if field1456 is not None: self.newline() - assert field1454 is not None - opt_val1455 = field1454 - self.pretty_iceberg_catalog_config_scope(opt_val1455) + assert field1456 is not None + opt_val1457 = field1456 + self.pretty_iceberg_catalog_config_scope(opt_val1457) self.newline() - field1456 = unwrapped_fields1452[2] - self.pretty_iceberg_properties(field1456) + field1458 = unwrapped_fields1454[2] + self.pretty_iceberg_properties(field1458) self.newline() - field1457 = unwrapped_fields1452[3] - self.pretty_iceberg_auth_properties(field1457) + field1459 = unwrapped_fields1454[3] + self.pretty_iceberg_auth_properties(field1459) self.dedent() self.write(")") def pretty_iceberg_catalog_uri(self, msg: str): - flat1460 = self._try_flat(msg, self.pretty_iceberg_catalog_uri) - if flat1460 is not None: - assert flat1460 is not None - self.write(flat1460) + flat1462 = self._try_flat(msg, self.pretty_iceberg_catalog_uri) + if flat1462 is not None: + assert flat1462 is not None + self.write(flat1462) return None else: - fields1459 = msg + fields1461 = msg self.write("(catalog_uri") self.indent_sexp() self.newline() - self.write(self.format_string_value(fields1459)) + self.write(self.format_string_value(fields1461)) self.dedent() self.write(")") def pretty_iceberg_catalog_config_scope(self, msg: str): - flat1462 = self._try_flat(msg, self.pretty_iceberg_catalog_config_scope) - if flat1462 is not None: - assert flat1462 is not None - self.write(flat1462) + flat1464 = self._try_flat(msg, self.pretty_iceberg_catalog_config_scope) + if flat1464 is not None: + assert flat1464 is not None + self.write(flat1464) return None else: - fields1461 = msg + fields1463 = msg self.write("(scope") self.indent_sexp() self.newline() - self.write(self.format_string_value(fields1461)) + self.write(self.format_string_value(fields1463)) self.dedent() self.write(")") def pretty_iceberg_properties(self, msg: Sequence[tuple[str, str]]): - flat1466 = self._try_flat(msg, self.pretty_iceberg_properties) - if flat1466 is not None: - assert flat1466 is not None - self.write(flat1466) + flat1468 = self._try_flat(msg, self.pretty_iceberg_properties) + if flat1468 is not None: + assert flat1468 is not None + self.write(flat1468) return None else: - fields1463 = msg + fields1465 = msg self.write("(properties") self.indent_sexp() - if not len(fields1463) == 0: + if not len(fields1465) == 0: self.newline() - for i1465, elem1464 in enumerate(fields1463): - if (i1465 > 0): + for i1467, elem1466 in enumerate(fields1465): + if (i1467 > 0): self.newline() - self.pretty_iceberg_property_entry(elem1464) + self.pretty_iceberg_property_entry(elem1466) self.dedent() self.write(")") def pretty_iceberg_property_entry(self, msg: tuple[str, str]): - flat1471 = self._try_flat(msg, self.pretty_iceberg_property_entry) - if flat1471 is not None: - assert flat1471 is not None - self.write(flat1471) + flat1473 = self._try_flat(msg, self.pretty_iceberg_property_entry) + if flat1473 is not None: + assert flat1473 is not None + self.write(flat1473) return None else: _dollar_dollar = msg - fields1467 = (_dollar_dollar[0], _dollar_dollar[1],) - assert fields1467 is not None - unwrapped_fields1468 = fields1467 + fields1469 = (_dollar_dollar[0], _dollar_dollar[1],) + assert fields1469 is not None + unwrapped_fields1470 = fields1469 self.write("(prop") self.indent_sexp() self.newline() - field1469 = unwrapped_fields1468[0] - self.write(self.format_string_value(field1469)) + field1471 = unwrapped_fields1470[0] + self.write(self.format_string_value(field1471)) self.newline() - field1470 = unwrapped_fields1468[1] - self.write(self.format_string_value(field1470)) + field1472 = unwrapped_fields1470[1] + self.write(self.format_string_value(field1472)) self.dedent() self.write(")") def pretty_iceberg_auth_properties(self, msg: Sequence[tuple[str, str]]): - flat1475 = self._try_flat(msg, self.pretty_iceberg_auth_properties) - if flat1475 is not None: - assert flat1475 is not None - self.write(flat1475) + flat1477 = self._try_flat(msg, self.pretty_iceberg_auth_properties) + if flat1477 is not None: + assert flat1477 is not None + self.write(flat1477) return None else: - fields1472 = msg + fields1474 = msg self.write("(auth_properties") self.indent_sexp() - if not len(fields1472) == 0: + if not len(fields1474) == 0: self.newline() - for i1474, elem1473 in enumerate(fields1472): - if (i1474 > 0): + for i1476, elem1475 in enumerate(fields1474): + if (i1476 > 0): self.newline() - self.pretty_iceberg_masked_property_entry(elem1473) + self.pretty_iceberg_masked_property_entry(elem1475) self.dedent() self.write(")") def pretty_iceberg_masked_property_entry(self, msg: tuple[str, str]): - flat1480 = self._try_flat(msg, self.pretty_iceberg_masked_property_entry) - if flat1480 is not None: - assert flat1480 is not None - self.write(flat1480) + flat1482 = self._try_flat(msg, self.pretty_iceberg_masked_property_entry) + if flat1482 is not None: + assert flat1482 is not None + self.write(flat1482) return None else: _dollar_dollar = msg - _t1722 = self.mask_secret_value(_dollar_dollar) - fields1476 = (_dollar_dollar[0], _t1722,) - assert fields1476 is not None - unwrapped_fields1477 = fields1476 + _t1726 = self.mask_secret_value(_dollar_dollar) + fields1478 = (_dollar_dollar[0], _t1726,) + assert fields1478 is not None + unwrapped_fields1479 = fields1478 self.write("(prop") self.indent_sexp() self.newline() - field1478 = unwrapped_fields1477[0] - self.write(self.format_string_value(field1478)) + field1480 = unwrapped_fields1479[0] + self.write(self.format_string_value(field1480)) self.newline() - field1479 = unwrapped_fields1477[1] - self.write(self.format_string_value(field1479)) + field1481 = unwrapped_fields1479[1] + self.write(self.format_string_value(field1481)) self.dedent() self.write(")") def pretty_iceberg_from_snapshot(self, msg: str): - flat1482 = self._try_flat(msg, self.pretty_iceberg_from_snapshot) - if flat1482 is not None: - assert flat1482 is not None - self.write(flat1482) + flat1484 = self._try_flat(msg, self.pretty_iceberg_from_snapshot) + if flat1484 is not None: + assert flat1484 is not None + self.write(flat1484) return None else: - fields1481 = msg + fields1483 = msg self.write("(from_snapshot") 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_to_snapshot(self, msg: str): - flat1484 = self._try_flat(msg, self.pretty_iceberg_to_snapshot) - if flat1484 is not None: - assert flat1484 is not None - self.write(flat1484) + flat1486 = self._try_flat(msg, self.pretty_iceberg_to_snapshot) + if flat1486 is not None: + assert flat1486 is not None + self.write(flat1486) return None else: - fields1483 = msg + fields1485 = msg self.write("(to_snapshot") self.indent_sexp() self.newline() - self.write(self.format_string_value(fields1483)) + self.write(self.format_string_value(fields1485)) self.dedent() self.write(")") def pretty_undefine(self, msg: transactions_pb2.Undefine): - flat1487 = self._try_flat(msg, self.pretty_undefine) - if flat1487 is not None: - assert flat1487 is not None - self.write(flat1487) + flat1489 = self._try_flat(msg, self.pretty_undefine) + if flat1489 is not None: + assert flat1489 is not None + self.write(flat1489) return None else: _dollar_dollar = msg - fields1485 = _dollar_dollar.fragment_id - assert fields1485 is not None - unwrapped_fields1486 = fields1485 + fields1487 = _dollar_dollar.fragment_id + assert fields1487 is not None + unwrapped_fields1488 = fields1487 self.write("(undefine") self.indent_sexp() self.newline() - self.pretty_fragment_id(unwrapped_fields1486) + self.pretty_fragment_id(unwrapped_fields1488) self.dedent() self.write(")") def pretty_context(self, msg: transactions_pb2.Context): - flat1492 = self._try_flat(msg, self.pretty_context) - if flat1492 is not None: - assert flat1492 is not None - self.write(flat1492) + flat1494 = self._try_flat(msg, self.pretty_context) + if flat1494 is not None: + assert flat1494 is not None + self.write(flat1494) return None else: _dollar_dollar = msg - fields1488 = _dollar_dollar.relations - assert fields1488 is not None - unwrapped_fields1489 = fields1488 + fields1490 = _dollar_dollar.relations + assert fields1490 is not None + unwrapped_fields1491 = fields1490 self.write("(context") self.indent_sexp() - if not len(unwrapped_fields1489) == 0: + if not len(unwrapped_fields1491) == 0: self.newline() - for i1491, elem1490 in enumerate(unwrapped_fields1489): - if (i1491 > 0): + for i1493, elem1492 in enumerate(unwrapped_fields1491): + if (i1493 > 0): self.newline() - self.pretty_relation_id(elem1490) + self.pretty_relation_id(elem1492) self.dedent() self.write(")") def pretty_snapshot(self, msg: transactions_pb2.Snapshot): - flat1497 = self._try_flat(msg, self.pretty_snapshot) - if flat1497 is not None: - assert flat1497 is not None - self.write(flat1497) + flat1501 = self._try_flat(msg, self.pretty_snapshot) + if flat1501 is not None: + assert flat1501 is not None + self.write(flat1501) return None else: _dollar_dollar = msg - fields1493 = _dollar_dollar.mappings - assert fields1493 is not None - unwrapped_fields1494 = fields1493 + fields1495 = (_dollar_dollar.prefix, _dollar_dollar.mappings,) + assert fields1495 is not None + unwrapped_fields1496 = fields1495 self.write("(snapshot") self.indent_sexp() - if not len(unwrapped_fields1494) == 0: + self.newline() + field1497 = unwrapped_fields1496[0] + self.pretty_edb_path(field1497) + field1498 = unwrapped_fields1496[1] + if not len(field1498) == 0: self.newline() - for i1496, elem1495 in enumerate(unwrapped_fields1494): - if (i1496 > 0): + for i1500, elem1499 in enumerate(field1498): + if (i1500 > 0): self.newline() - self.pretty_snapshot_mapping(elem1495) + self.pretty_snapshot_mapping(elem1499) self.dedent() self.write(")") def pretty_snapshot_mapping(self, msg: transactions_pb2.SnapshotMapping): - flat1502 = self._try_flat(msg, self.pretty_snapshot_mapping) - if flat1502 is not None: - assert flat1502 is not None - self.write(flat1502) + flat1506 = self._try_flat(msg, self.pretty_snapshot_mapping) + if flat1506 is not None: + assert flat1506 is not None + self.write(flat1506) return None else: _dollar_dollar = msg - fields1498 = (_dollar_dollar.destination_path, _dollar_dollar.source_relation,) - assert fields1498 is not None - unwrapped_fields1499 = fields1498 - field1500 = unwrapped_fields1499[0] - self.pretty_edb_path(field1500) + fields1502 = (_dollar_dollar.destination_path, _dollar_dollar.source_relation,) + assert fields1502 is not None + unwrapped_fields1503 = fields1502 + field1504 = unwrapped_fields1503[0] + self.pretty_edb_path(field1504) self.write(" ") - field1501 = unwrapped_fields1499[1] - self.pretty_relation_id(field1501) + field1505 = unwrapped_fields1503[1] + self.pretty_relation_id(field1505) def pretty_epoch_reads(self, msg: Sequence[transactions_pb2.Read]): - flat1506 = self._try_flat(msg, self.pretty_epoch_reads) - if flat1506 is not None: - assert flat1506 is not None - self.write(flat1506) + flat1510 = self._try_flat(msg, self.pretty_epoch_reads) + if flat1510 is not None: + assert flat1510 is not None + self.write(flat1510) return None else: - fields1503 = msg + fields1507 = msg self.write("(reads") self.indent_sexp() - if not len(fields1503) == 0: + if not len(fields1507) == 0: self.newline() - for i1505, elem1504 in enumerate(fields1503): - if (i1505 > 0): + for i1509, elem1508 in enumerate(fields1507): + if (i1509 > 0): self.newline() - self.pretty_read(elem1504) + self.pretty_read(elem1508) self.dedent() self.write(")") def pretty_read(self, msg: transactions_pb2.Read): - flat1517 = self._try_flat(msg, self.pretty_read) - if flat1517 is not None: - assert flat1517 is not None - self.write(flat1517) + flat1521 = self._try_flat(msg, self.pretty_read) + if flat1521 is not None: + assert flat1521 is not None + self.write(flat1521) return None else: _dollar_dollar = msg if _dollar_dollar.HasField("demand"): - _t1723 = _dollar_dollar.demand + _t1727 = _dollar_dollar.demand else: - _t1723 = None - deconstruct_result1515 = _t1723 - if deconstruct_result1515 is not None: - assert deconstruct_result1515 is not None - unwrapped1516 = deconstruct_result1515 - self.pretty_demand(unwrapped1516) + _t1727 = None + deconstruct_result1519 = _t1727 + if deconstruct_result1519 is not None: + assert deconstruct_result1519 is not None + unwrapped1520 = deconstruct_result1519 + self.pretty_demand(unwrapped1520) else: _dollar_dollar = msg if _dollar_dollar.HasField("output"): - _t1724 = _dollar_dollar.output + _t1728 = _dollar_dollar.output else: - _t1724 = None - deconstruct_result1513 = _t1724 - if deconstruct_result1513 is not None: - assert deconstruct_result1513 is not None - unwrapped1514 = deconstruct_result1513 - self.pretty_output(unwrapped1514) + _t1728 = None + deconstruct_result1517 = _t1728 + if deconstruct_result1517 is not None: + assert deconstruct_result1517 is not None + unwrapped1518 = deconstruct_result1517 + self.pretty_output(unwrapped1518) else: _dollar_dollar = msg if _dollar_dollar.HasField("what_if"): - _t1725 = _dollar_dollar.what_if + _t1729 = _dollar_dollar.what_if else: - _t1725 = None - deconstruct_result1511 = _t1725 - if deconstruct_result1511 is not None: - assert deconstruct_result1511 is not None - unwrapped1512 = deconstruct_result1511 - self.pretty_what_if(unwrapped1512) + _t1729 = None + deconstruct_result1515 = _t1729 + if deconstruct_result1515 is not None: + assert deconstruct_result1515 is not None + unwrapped1516 = deconstruct_result1515 + self.pretty_what_if(unwrapped1516) else: _dollar_dollar = msg if _dollar_dollar.HasField("abort"): - _t1726 = _dollar_dollar.abort + _t1730 = _dollar_dollar.abort else: - _t1726 = None - deconstruct_result1509 = _t1726 - if deconstruct_result1509 is not None: - assert deconstruct_result1509 is not None - unwrapped1510 = deconstruct_result1509 - self.pretty_abort(unwrapped1510) + _t1730 = None + deconstruct_result1513 = _t1730 + if deconstruct_result1513 is not None: + assert deconstruct_result1513 is not None + unwrapped1514 = deconstruct_result1513 + self.pretty_abort(unwrapped1514) else: _dollar_dollar = msg if _dollar_dollar.HasField("export"): - _t1727 = _dollar_dollar.export + _t1731 = _dollar_dollar.export else: - _t1727 = None - deconstruct_result1507 = _t1727 - if deconstruct_result1507 is not None: - assert deconstruct_result1507 is not None - unwrapped1508 = deconstruct_result1507 - self.pretty_export(unwrapped1508) + _t1731 = None + deconstruct_result1511 = _t1731 + if deconstruct_result1511 is not None: + assert deconstruct_result1511 is not None + unwrapped1512 = deconstruct_result1511 + self.pretty_export(unwrapped1512) else: raise ParseError("No matching rule for read") def pretty_demand(self, msg: transactions_pb2.Demand): - flat1520 = self._try_flat(msg, self.pretty_demand) - if flat1520 is not None: - assert flat1520 is not None - self.write(flat1520) + flat1524 = self._try_flat(msg, self.pretty_demand) + if flat1524 is not None: + assert flat1524 is not None + self.write(flat1524) return None else: _dollar_dollar = msg - fields1518 = _dollar_dollar.relation_id - assert fields1518 is not None - unwrapped_fields1519 = fields1518 + fields1522 = _dollar_dollar.relation_id + assert fields1522 is not None + unwrapped_fields1523 = fields1522 self.write("(demand") self.indent_sexp() self.newline() - self.pretty_relation_id(unwrapped_fields1519) + self.pretty_relation_id(unwrapped_fields1523) self.dedent() self.write(")") def pretty_output(self, msg: transactions_pb2.Output): - flat1525 = self._try_flat(msg, self.pretty_output) - if flat1525 is not None: - assert flat1525 is not None - self.write(flat1525) + flat1529 = self._try_flat(msg, self.pretty_output) + if flat1529 is not None: + assert flat1529 is not None + self.write(flat1529) return None else: _dollar_dollar = msg - fields1521 = (_dollar_dollar.name, _dollar_dollar.relation_id,) - assert fields1521 is not None - unwrapped_fields1522 = fields1521 + fields1525 = (_dollar_dollar.name, _dollar_dollar.relation_id,) + assert fields1525 is not None + unwrapped_fields1526 = fields1525 self.write("(output") self.indent_sexp() self.newline() - field1523 = unwrapped_fields1522[0] - self.pretty_name(field1523) + field1527 = unwrapped_fields1526[0] + self.pretty_name(field1527) self.newline() - field1524 = unwrapped_fields1522[1] - self.pretty_relation_id(field1524) + field1528 = unwrapped_fields1526[1] + self.pretty_relation_id(field1528) self.dedent() self.write(")") def pretty_what_if(self, msg: transactions_pb2.WhatIf): - flat1530 = self._try_flat(msg, self.pretty_what_if) - if flat1530 is not None: - assert flat1530 is not None - self.write(flat1530) + flat1534 = self._try_flat(msg, self.pretty_what_if) + if flat1534 is not None: + assert flat1534 is not None + self.write(flat1534) return None else: _dollar_dollar = msg - fields1526 = (_dollar_dollar.branch, _dollar_dollar.epoch,) - assert fields1526 is not None - unwrapped_fields1527 = fields1526 + fields1530 = (_dollar_dollar.branch, _dollar_dollar.epoch,) + assert fields1530 is not None + unwrapped_fields1531 = fields1530 self.write("(what_if") self.indent_sexp() self.newline() - field1528 = unwrapped_fields1527[0] - self.pretty_name(field1528) + field1532 = unwrapped_fields1531[0] + self.pretty_name(field1532) self.newline() - field1529 = unwrapped_fields1527[1] - self.pretty_epoch(field1529) + field1533 = unwrapped_fields1531[1] + self.pretty_epoch(field1533) self.dedent() self.write(")") def pretty_abort(self, msg: transactions_pb2.Abort): - flat1536 = self._try_flat(msg, self.pretty_abort) - if flat1536 is not None: - assert flat1536 is not None - self.write(flat1536) + flat1540 = self._try_flat(msg, self.pretty_abort) + if flat1540 is not None: + assert flat1540 is not None + self.write(flat1540) return None else: _dollar_dollar = msg if _dollar_dollar.name != "abort": - _t1728 = _dollar_dollar.name + _t1732 = _dollar_dollar.name else: - _t1728 = None - fields1531 = (_t1728, _dollar_dollar.relation_id,) - assert fields1531 is not None - unwrapped_fields1532 = fields1531 + _t1732 = None + fields1535 = (_t1732, _dollar_dollar.relation_id,) + assert fields1535 is not None + unwrapped_fields1536 = fields1535 self.write("(abort") self.indent_sexp() - field1533 = unwrapped_fields1532[0] - if field1533 is not None: + field1537 = unwrapped_fields1536[0] + if field1537 is not None: self.newline() - assert field1533 is not None - opt_val1534 = field1533 - self.pretty_name(opt_val1534) + assert field1537 is not None + opt_val1538 = field1537 + self.pretty_name(opt_val1538) self.newline() - field1535 = unwrapped_fields1532[1] - self.pretty_relation_id(field1535) + field1539 = unwrapped_fields1536[1] + self.pretty_relation_id(field1539) self.dedent() self.write(")") def pretty_export(self, msg: transactions_pb2.Export): - flat1541 = self._try_flat(msg, self.pretty_export) - if flat1541 is not None: - assert flat1541 is not None - self.write(flat1541) + flat1545 = self._try_flat(msg, self.pretty_export) + if flat1545 is not None: + assert flat1545 is not None + self.write(flat1545) return None else: _dollar_dollar = msg if _dollar_dollar.HasField("csv_config"): - _t1729 = _dollar_dollar.csv_config + _t1733 = _dollar_dollar.csv_config else: - _t1729 = None - deconstruct_result1539 = _t1729 - if deconstruct_result1539 is not None: - assert deconstruct_result1539 is not None - unwrapped1540 = deconstruct_result1539 + _t1733 = None + deconstruct_result1543 = _t1733 + if deconstruct_result1543 is not None: + assert deconstruct_result1543 is not None + unwrapped1544 = deconstruct_result1543 self.write("(export") self.indent_sexp() self.newline() - self.pretty_export_csv_config(unwrapped1540) + self.pretty_export_csv_config(unwrapped1544) self.dedent() self.write(")") else: _dollar_dollar = msg if _dollar_dollar.HasField("iceberg_config"): - _t1730 = _dollar_dollar.iceberg_config + _t1734 = _dollar_dollar.iceberg_config else: - _t1730 = None - deconstruct_result1537 = _t1730 - if deconstruct_result1537 is not None: - assert deconstruct_result1537 is not None - unwrapped1538 = deconstruct_result1537 + _t1734 = None + deconstruct_result1541 = _t1734 + if deconstruct_result1541 is not None: + assert deconstruct_result1541 is not None + unwrapped1542 = deconstruct_result1541 self.write("(export_iceberg") self.indent_sexp() self.newline() - self.pretty_export_iceberg_config(unwrapped1538) + self.pretty_export_iceberg_config(unwrapped1542) self.dedent() self.write(")") else: raise ParseError("No matching rule for export") def pretty_export_csv_config(self, msg: transactions_pb2.ExportCSVConfig): - flat1552 = self._try_flat(msg, self.pretty_export_csv_config) - if flat1552 is not None: - assert flat1552 is not None - self.write(flat1552) + flat1556 = self._try_flat(msg, self.pretty_export_csv_config) + if flat1556 is not None: + assert flat1556 is not None + self.write(flat1556) return None else: _dollar_dollar = msg if len(_dollar_dollar.data_columns) == 0: - _t1731 = (_dollar_dollar.path, _dollar_dollar.csv_source, _dollar_dollar.csv_config,) + _t1735 = (_dollar_dollar.path, _dollar_dollar.csv_source, _dollar_dollar.csv_config,) else: - _t1731 = None - deconstruct_result1547 = _t1731 - if deconstruct_result1547 is not None: - assert deconstruct_result1547 is not None - unwrapped1548 = deconstruct_result1547 + _t1735 = None + deconstruct_result1551 = _t1735 + if deconstruct_result1551 is not None: + assert deconstruct_result1551 is not None + unwrapped1552 = deconstruct_result1551 self.write("(export_csv_config_v2") self.indent_sexp() self.newline() - field1549 = unwrapped1548[0] - self.pretty_export_csv_path(field1549) + field1553 = unwrapped1552[0] + self.pretty_export_csv_path(field1553) self.newline() - field1550 = unwrapped1548[1] - self.pretty_export_csv_source(field1550) + field1554 = unwrapped1552[1] + self.pretty_export_csv_source(field1554) self.newline() - field1551 = unwrapped1548[2] - self.pretty_csv_config(field1551) + field1555 = unwrapped1552[2] + self.pretty_csv_config(field1555) self.dedent() self.write(")") else: _dollar_dollar = msg if len(_dollar_dollar.data_columns) != 0: - _t1733 = self.deconstruct_export_csv_config(_dollar_dollar) - _t1732 = (_dollar_dollar.path, _dollar_dollar.data_columns, _t1733,) + _t1737 = self.deconstruct_export_csv_config(_dollar_dollar) + _t1736 = (_dollar_dollar.path, _dollar_dollar.data_columns, _t1737,) else: - _t1732 = None - deconstruct_result1542 = _t1732 - if deconstruct_result1542 is not None: - assert deconstruct_result1542 is not None - unwrapped1543 = deconstruct_result1542 + _t1736 = None + deconstruct_result1546 = _t1736 + if deconstruct_result1546 is not None: + assert deconstruct_result1546 is not None + unwrapped1547 = deconstruct_result1546 self.write("(export_csv_config") self.indent_sexp() self.newline() - field1544 = unwrapped1543[0] - self.pretty_export_csv_path(field1544) + field1548 = unwrapped1547[0] + self.pretty_export_csv_path(field1548) self.newline() - field1545 = unwrapped1543[1] - self.pretty_export_csv_columns_list(field1545) + field1549 = unwrapped1547[1] + self.pretty_export_csv_columns_list(field1549) self.newline() - field1546 = unwrapped1543[2] - self.pretty_config_dict(field1546) + field1550 = unwrapped1547[2] + self.pretty_config_dict(field1550) self.dedent() self.write(")") else: raise ParseError("No matching rule for export_csv_config") def pretty_export_csv_path(self, msg: str): - flat1554 = self._try_flat(msg, self.pretty_export_csv_path) - if flat1554 is not None: - assert flat1554 is not None - self.write(flat1554) + flat1558 = self._try_flat(msg, self.pretty_export_csv_path) + if flat1558 is not None: + assert flat1558 is not None + self.write(flat1558) return None else: - fields1553 = msg + fields1557 = msg self.write("(path") self.indent_sexp() self.newline() - self.write(self.format_string_value(fields1553)) + self.write(self.format_string_value(fields1557)) self.dedent() self.write(")") def pretty_export_csv_source(self, msg: transactions_pb2.ExportCSVSource): - flat1561 = self._try_flat(msg, self.pretty_export_csv_source) - if flat1561 is not None: - assert flat1561 is not None - self.write(flat1561) + flat1565 = self._try_flat(msg, self.pretty_export_csv_source) + if flat1565 is not None: + assert flat1565 is not None + self.write(flat1565) return None else: _dollar_dollar = msg if _dollar_dollar.HasField("gnf_columns"): - _t1734 = _dollar_dollar.gnf_columns.columns + _t1738 = _dollar_dollar.gnf_columns.columns else: - _t1734 = None - deconstruct_result1557 = _t1734 - if deconstruct_result1557 is not None: - assert deconstruct_result1557 is not None - unwrapped1558 = deconstruct_result1557 + _t1738 = None + deconstruct_result1561 = _t1738 + if deconstruct_result1561 is not None: + assert deconstruct_result1561 is not None + unwrapped1562 = deconstruct_result1561 self.write("(gnf_columns") self.indent_sexp() - if not len(unwrapped1558) == 0: + if not len(unwrapped1562) == 0: self.newline() - for i1560, elem1559 in enumerate(unwrapped1558): - if (i1560 > 0): + for i1564, elem1563 in enumerate(unwrapped1562): + if (i1564 > 0): self.newline() - self.pretty_export_csv_column(elem1559) + self.pretty_export_csv_column(elem1563) self.dedent() self.write(")") else: _dollar_dollar = msg if _dollar_dollar.HasField("table_def"): - _t1735 = _dollar_dollar.table_def + _t1739 = _dollar_dollar.table_def else: - _t1735 = None - deconstruct_result1555 = _t1735 - if deconstruct_result1555 is not None: - assert deconstruct_result1555 is not None - unwrapped1556 = deconstruct_result1555 + _t1739 = None + deconstruct_result1559 = _t1739 + if deconstruct_result1559 is not None: + assert deconstruct_result1559 is not None + unwrapped1560 = deconstruct_result1559 self.write("(table_def") self.indent_sexp() self.newline() - self.pretty_relation_id(unwrapped1556) + self.pretty_relation_id(unwrapped1560) self.dedent() self.write(")") else: raise ParseError("No matching rule for export_csv_source") def pretty_export_csv_column(self, msg: transactions_pb2.ExportCSVColumn): - flat1566 = self._try_flat(msg, self.pretty_export_csv_column) - if flat1566 is not None: - assert flat1566 is not None - self.write(flat1566) + flat1570 = self._try_flat(msg, self.pretty_export_csv_column) + if flat1570 is not None: + assert flat1570 is not None + self.write(flat1570) return None else: _dollar_dollar = msg - fields1562 = (_dollar_dollar.column_name, _dollar_dollar.column_data,) - assert fields1562 is not None - unwrapped_fields1563 = fields1562 + fields1566 = (_dollar_dollar.column_name, _dollar_dollar.column_data,) + assert fields1566 is not None + unwrapped_fields1567 = fields1566 self.write("(column") self.indent_sexp() self.newline() - field1564 = unwrapped_fields1563[0] - self.write(self.format_string_value(field1564)) + field1568 = unwrapped_fields1567[0] + self.write(self.format_string_value(field1568)) self.newline() - field1565 = unwrapped_fields1563[1] - self.pretty_relation_id(field1565) + field1569 = unwrapped_fields1567[1] + self.pretty_relation_id(field1569) self.dedent() self.write(")") def pretty_export_csv_columns_list(self, msg: Sequence[transactions_pb2.ExportCSVColumn]): - flat1570 = self._try_flat(msg, self.pretty_export_csv_columns_list) - if flat1570 is not None: - assert flat1570 is not None - self.write(flat1570) + flat1574 = self._try_flat(msg, self.pretty_export_csv_columns_list) + if flat1574 is not None: + assert flat1574 is not None + self.write(flat1574) return None else: - fields1567 = msg + fields1571 = msg self.write("(columns") self.indent_sexp() - if not len(fields1567) == 0: + if not len(fields1571) == 0: self.newline() - for i1569, elem1568 in enumerate(fields1567): - if (i1569 > 0): + for i1573, elem1572 in enumerate(fields1571): + if (i1573 > 0): self.newline() - self.pretty_export_csv_column(elem1568) + self.pretty_export_csv_column(elem1572) self.dedent() self.write(")") def pretty_export_iceberg_config(self, msg: transactions_pb2.ExportIcebergConfig): - flat1580 = self._try_flat(msg, self.pretty_export_iceberg_config) - if flat1580 is not None: - assert flat1580 is not None - self.write(flat1580) + flat1584 = self._try_flat(msg, self.pretty_export_iceberg_config) + if flat1584 is not None: + assert flat1584 is not None + self.write(flat1584) return None else: _dollar_dollar = msg - _t1736 = self.deconstruct_export_iceberg_config_optional(_dollar_dollar) - fields1571 = (_dollar_dollar.locator, _dollar_dollar.config, _dollar_dollar.table_def, _dollar_dollar.columns, sorted(_dollar_dollar.table_properties.items()), _t1736,) - assert fields1571 is not None - unwrapped_fields1572 = fields1571 + _t1740 = self.deconstruct_export_iceberg_config_optional(_dollar_dollar) + fields1575 = (_dollar_dollar.locator, _dollar_dollar.config, _dollar_dollar.table_def, _dollar_dollar.columns, sorted(_dollar_dollar.table_properties.items()), _t1740,) + assert fields1575 is not None + unwrapped_fields1576 = fields1575 self.write("(export_iceberg_config") self.indent_sexp() self.newline() - field1573 = unwrapped_fields1572[0] - self.pretty_iceberg_locator(field1573) + field1577 = unwrapped_fields1576[0] + self.pretty_iceberg_locator(field1577) self.newline() - field1574 = unwrapped_fields1572[1] - self.pretty_iceberg_catalog_config(field1574) + field1578 = unwrapped_fields1576[1] + self.pretty_iceberg_catalog_config(field1578) self.newline() - field1575 = unwrapped_fields1572[2] - self.pretty_export_iceberg_table_def(field1575) + field1579 = unwrapped_fields1576[2] + self.pretty_export_iceberg_table_def(field1579) self.newline() - field1576 = unwrapped_fields1572[3] - self.pretty_export_iceberg_columns(field1576) + field1580 = unwrapped_fields1576[3] + self.pretty_export_iceberg_columns(field1580) self.newline() - field1577 = unwrapped_fields1572[4] - self.pretty_iceberg_table_properties(field1577) - field1578 = unwrapped_fields1572[5] - if field1578 is not None: + field1581 = unwrapped_fields1576[4] + self.pretty_iceberg_table_properties(field1581) + field1582 = unwrapped_fields1576[5] + if field1582 is not None: self.newline() - assert field1578 is not None - opt_val1579 = field1578 - self.pretty_config_dict(opt_val1579) + assert field1582 is not None + opt_val1583 = field1582 + self.pretty_config_dict(opt_val1583) self.dedent() self.write(")") def pretty_export_iceberg_table_def(self, msg: logic_pb2.RelationId): - flat1582 = self._try_flat(msg, self.pretty_export_iceberg_table_def) - if flat1582 is not None: - assert flat1582 is not None - self.write(flat1582) + flat1586 = self._try_flat(msg, self.pretty_export_iceberg_table_def) + if flat1586 is not None: + assert flat1586 is not None + self.write(flat1586) return None else: - fields1581 = msg + fields1585 = msg self.write("(table_def") self.indent_sexp() self.newline() - self.pretty_relation_id(fields1581) + self.pretty_relation_id(fields1585) self.dedent() self.write(")") def pretty_export_iceberg_columns(self, msg: Sequence[transactions_pb2.ExportColumn]): - flat1586 = self._try_flat(msg, self.pretty_export_iceberg_columns) - if flat1586 is not None: - assert flat1586 is not None - self.write(flat1586) + flat1590 = self._try_flat(msg, self.pretty_export_iceberg_columns) + if flat1590 is not None: + assert flat1590 is not None + self.write(flat1590) return None else: - fields1583 = msg + fields1587 = msg self.write("(columns") self.indent_sexp() - if not len(fields1583) == 0: + if not len(fields1587) == 0: self.newline() - for i1585, elem1584 in enumerate(fields1583): - if (i1585 > 0): + for i1589, elem1588 in enumerate(fields1587): + if (i1589 > 0): self.newline() - self.pretty_export_iceberg_column(elem1584) + self.pretty_export_iceberg_column(elem1588) self.dedent() self.write(")") def pretty_export_iceberg_column(self, msg: transactions_pb2.ExportColumn): - flat1591 = self._try_flat(msg, self.pretty_export_iceberg_column) - if flat1591 is not None: - assert flat1591 is not None - self.write(flat1591) + flat1595 = self._try_flat(msg, self.pretty_export_iceberg_column) + if flat1595 is not None: + assert flat1595 is not None + self.write(flat1595) return None else: _dollar_dollar = msg - fields1587 = (_dollar_dollar.name, _dollar_dollar.nullable,) - assert fields1587 is not None - unwrapped_fields1588 = fields1587 + fields1591 = (_dollar_dollar.name, _dollar_dollar.nullable,) + assert fields1591 is not None + unwrapped_fields1592 = fields1591 self.write("(column") self.indent_sexp() self.newline() - field1589 = unwrapped_fields1588[0] - self.write(self.format_string_value(field1589)) + field1593 = unwrapped_fields1592[0] + self.write(self.format_string_value(field1593)) self.newline() - field1590 = unwrapped_fields1588[1] - self.pretty_boolean_value(field1590) + field1594 = unwrapped_fields1592[1] + self.pretty_boolean_value(field1594) self.dedent() self.write(")") def pretty_iceberg_table_properties(self, msg: Sequence[tuple[str, str]]): - flat1595 = self._try_flat(msg, self.pretty_iceberg_table_properties) - if flat1595 is not None: - assert flat1595 is not None - self.write(flat1595) + flat1599 = self._try_flat(msg, self.pretty_iceberg_table_properties) + if flat1599 is not None: + assert flat1599 is not None + self.write(flat1599) return None else: - fields1592 = msg + fields1596 = msg self.write("(table_properties") self.indent_sexp() - if not len(fields1592) == 0: + if not len(fields1596) == 0: self.newline() - for i1594, elem1593 in enumerate(fields1592): - if (i1594 > 0): + for i1598, elem1597 in enumerate(fields1596): + if (i1598 > 0): self.newline() - self.pretty_iceberg_property_entry(elem1593) + self.pretty_iceberg_property_entry(elem1597) self.dedent() self.write(")") @@ -4362,8 +4366,8 @@ def pretty_debug_info(self, msg: fragments_pb2.DebugInfo): for _idx, _rid in enumerate(msg.ids): self.newline() self.write("(") - _t1782 = logic_pb2.UInt128Value(low=_rid.id_low, high=_rid.id_high) - self.pprint_dispatch(_t1782) + _t1786 = logic_pb2.UInt128Value(low=_rid.id_low, high=_rid.id_high) + self.pprint_dispatch(_t1786) self.write(" ") self.write(self.format_string_value(msg.orig_names[_idx])) self.write(")") diff --git a/sdks/python/src/lqp/proto/v1/fragments_pb2.pyi b/sdks/python/src/lqp/proto/v1/fragments_pb2.pyi index dd183608..b4115517 100644 --- a/sdks/python/src/lqp/proto/v1/fragments_pb2.pyi +++ b/sdks/python/src/lqp/proto/v1/fragments_pb2.pyi @@ -2,7 +2,8 @@ from lqp.proto.v1 import logic_pb2 as _logic_pb2 from google.protobuf.internal import containers as _containers from google.protobuf import descriptor as _descriptor from google.protobuf import message as _message -from typing import ClassVar as _ClassVar, Iterable as _Iterable, Mapping as _Mapping, Optional as _Optional, Union as _Union +from collections.abc import Iterable as _Iterable, Mapping as _Mapping +from typing import ClassVar as _ClassVar, Optional as _Optional, Union as _Union DESCRIPTOR: _descriptor.FileDescriptor diff --git a/sdks/python/src/lqp/proto/v1/logic_pb2.pyi b/sdks/python/src/lqp/proto/v1/logic_pb2.pyi index 1a34aaf9..c9d08eb4 100644 --- a/sdks/python/src/lqp/proto/v1/logic_pb2.pyi +++ b/sdks/python/src/lqp/proto/v1/logic_pb2.pyi @@ -1,7 +1,8 @@ from google.protobuf.internal import containers as _containers from google.protobuf import descriptor as _descriptor from google.protobuf import message as _message -from typing import ClassVar as _ClassVar, Iterable as _Iterable, Mapping as _Mapping, Optional as _Optional, Union as _Union +from collections.abc import Iterable as _Iterable, Mapping as _Mapping +from typing import ClassVar as _ClassVar, Optional as _Optional, Union as _Union DESCRIPTOR: _descriptor.FileDescriptor @@ -463,7 +464,7 @@ class IcebergData(_message.Message): from_snapshot: str to_snapshot: str returns_delta: bool - def __init__(self, locator: _Optional[_Union[IcebergLocator, _Mapping]] = ..., config: _Optional[_Union[IcebergCatalogConfig, _Mapping]] = ..., columns: _Optional[_Iterable[_Union[GNFColumn, _Mapping]]] = ..., from_snapshot: _Optional[str] = ..., to_snapshot: _Optional[str] = ..., returns_delta: bool = ...) -> None: ... + def __init__(self, locator: _Optional[_Union[IcebergLocator, _Mapping]] = ..., config: _Optional[_Union[IcebergCatalogConfig, _Mapping]] = ..., columns: _Optional[_Iterable[_Union[GNFColumn, _Mapping]]] = ..., from_snapshot: _Optional[str] = ..., to_snapshot: _Optional[str] = ..., returns_delta: _Optional[bool] = ...) -> None: ... class IcebergLocator(_message.Message): __slots__ = ("table_name", "namespace", "warehouse") @@ -639,7 +640,7 @@ class Value(_message.Message): int32_value: int float32_value: float uint32_value: int - def __init__(self, string_value: _Optional[str] = ..., int_value: _Optional[int] = ..., float_value: _Optional[float] = ..., uint128_value: _Optional[_Union[UInt128Value, _Mapping]] = ..., int128_value: _Optional[_Union[Int128Value, _Mapping]] = ..., missing_value: _Optional[_Union[MissingValue, _Mapping]] = ..., date_value: _Optional[_Union[DateValue, _Mapping]] = ..., datetime_value: _Optional[_Union[DateTimeValue, _Mapping]] = ..., decimal_value: _Optional[_Union[DecimalValue, _Mapping]] = ..., boolean_value: bool = ..., int32_value: _Optional[int] = ..., float32_value: _Optional[float] = ..., uint32_value: _Optional[int] = ...) -> None: ... + def __init__(self, string_value: _Optional[str] = ..., int_value: _Optional[int] = ..., float_value: _Optional[float] = ..., uint128_value: _Optional[_Union[UInt128Value, _Mapping]] = ..., int128_value: _Optional[_Union[Int128Value, _Mapping]] = ..., missing_value: _Optional[_Union[MissingValue, _Mapping]] = ..., date_value: _Optional[_Union[DateValue, _Mapping]] = ..., datetime_value: _Optional[_Union[DateTimeValue, _Mapping]] = ..., decimal_value: _Optional[_Union[DecimalValue, _Mapping]] = ..., boolean_value: _Optional[bool] = ..., int32_value: _Optional[int] = ..., float32_value: _Optional[float] = ..., uint32_value: _Optional[int] = ...) -> None: ... class UInt128Value(_message.Message): __slots__ = ("low", "high") diff --git a/sdks/python/src/lqp/proto/v1/transactions_pb2.py b/sdks/python/src/lqp/proto/v1/transactions_pb2.py index 5602c903..aa962e0c 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\"L\n\x08Snapshot\x12@\n\x08mappings\x18\x01 \x03(\x0b\x32$.relationalai.lqp.v1.SnapshotMappingR\x08mappings\"\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\">\n\x0c\x45xportColumn\x12\x12\n\x04name\x18\x01 \x01(\tR\x04name\x12\x1a\n\x08nullable\x18\x02 \x01(\x08R\x08nullable\"\xdf\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;\n\x07\x63olumns\x18\x04 \x03(\x0b\x32!.relationalai.lqp.v1.ExportColumnR\x07\x63olumns\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_bytes\"\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\">\n\x0c\x45xportColumn\x12\x12\n\x04name\x18\x01 \x01(\tR\x04name\x12\x1a\n\x08nullable\x18\x02 \x01(\x08R\x08nullable\"\xdf\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;\n\x07\x63olumns\x18\x04 \x03(\x0b\x32!.relationalai.lqp.v1.ExportColumnR\x07\x63olumns\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_bytes\"\xa4\x02\n\x04Read\x12\x35\n\x06\x64\x65mand\x18\x01 \x01(\x0b\x32\x1b.relationalai.lqp.v1.DemandH\x00R\x06\x64\x65mand\x12\x35\n\x06output\x18\x02 \x01(\x0b\x32\x1b.relationalai.lqp.v1.OutputH\x00R\x06output\x12\x36\n\x07what_if\x18\x03 \x01(\x0b\x32\x1b.relationalai.lqp.v1.WhatIfH\x00R\x06whatIf\x12\x32\n\x05\x61\x62ort\x18\x04 \x01(\x0b\x32\x1a.relationalai.lqp.v1.AbortH\x00R\x05\x61\x62ort\x12\x35\n\x06\x65xport\x18\x05 \x01(\x0b\x32\x1b.relationalai.lqp.v1.ExportH\x00R\x06\x65xportB\x0b\n\tread_type\"J\n\x06\x44\x65mand\x12@\n\x0brelation_id\x18\x01 \x01(\x0b\x32\x1f.relationalai.lqp.v1.RelationIdR\nrelationId\"^\n\x06Output\x12\x12\n\x04name\x18\x01 \x01(\tR\x04name\x12@\n\x0brelation_id\x18\x02 \x01(\x0b\x32\x1f.relationalai.lqp.v1.RelationIdR\nrelationId\"\xb3\x01\n\x06\x45xport\x12\x45\n\ncsv_config\x18\x01 \x01(\x0b\x32$.relationalai.lqp.v1.ExportCSVConfigH\x00R\tcsvConfig\x12Q\n\x0eiceberg_config\x18\x02 \x01(\x0b\x32(.relationalai.lqp.v1.ExportIcebergConfigH\x00R\ricebergConfigB\x0f\n\rexport_config\"R\n\x06WhatIf\x12\x16\n\x06\x62ranch\x18\x01 \x01(\tR\x06\x62ranch\x12\x30\n\x05\x65poch\x18\x02 \x01(\x0b\x32\x1a.relationalai.lqp.v1.EpochR\x05\x65poch\"]\n\x05\x41\x62ort\x12\x12\n\x04name\x18\x01 \x01(\tR\x04name\x12@\n\x0brelation_id\x18\x02 \x01(\x0b\x32\x1f.relationalai.lqp.v1.RelationIdR\nrelationId*\x87\x01\n\x10MaintenanceLevel\x12!\n\x1dMAINTENANCE_LEVEL_UNSPECIFIED\x10\x00\x12\x19\n\x15MAINTENANCE_LEVEL_OFF\x10\x01\x12\x1a\n\x16MAINTENANCE_LEVEL_AUTO\x10\x02\x12\x19\n\x15MAINTENANCE_LEVEL_ALL\x10\x03\x42\x43ZAgithub.com/RelationalAI/logical-query-protocol/sdks/go/src/lqp/v1b\x06proto3') _globals = globals() _builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) @@ -36,8 +36,8 @@ _globals['DESCRIPTOR']._serialized_options = b'ZAgithub.com/RelationalAI/logical-query-protocol/sdks/go/src/lqp/v1' _globals['_EXPORTICEBERGCONFIG_TABLEPROPERTIESENTRY']._loaded_options = None _globals['_EXPORTICEBERGCONFIG_TABLEPROPERTIESENTRY']._serialized_options = b'8\001' - _globals['_MAINTENANCELEVEL']._serialized_start=3993 - _globals['_MAINTENANCELEVEL']._serialized_end=4128 + _globals['_MAINTENANCELEVEL']._serialized_start=4017 + _globals['_MAINTENANCELEVEL']._serialized_end=4152 _globals['_TRANSACTION']._serialized_start=134 _globals['_TRANSACTION']._serialized_end=322 _globals['_CONFIGURE']._serialized_start=324 @@ -59,31 +59,31 @@ _globals['_SNAPSHOTMAPPING']._serialized_start=1187 _globals['_SNAPSHOTMAPPING']._serialized_end=1321 _globals['_SNAPSHOT']._serialized_start=1323 - _globals['_SNAPSHOT']._serialized_end=1399 - _globals['_EXPORTCSVCONFIG']._serialized_start=1402 - _globals['_EXPORTCSVCONFIG']._serialized_end=2114 - _globals['_EXPORTCSVCOLUMN']._serialized_start=2116 - _globals['_EXPORTCSVCOLUMN']._serialized_end=2232 - _globals['_EXPORTCSVCOLUMNS']._serialized_start=2234 - _globals['_EXPORTCSVCOLUMNS']._serialized_end=2316 - _globals['_EXPORTCSVSOURCE']._serialized_start=2319 - _globals['_EXPORTCSVSOURCE']._serialized_end=2488 - _globals['_EXPORTCOLUMN']._serialized_start=2490 - _globals['_EXPORTCOLUMN']._serialized_end=2552 - _globals['_EXPORTICEBERGCONFIG']._serialized_start=2555 - _globals['_EXPORTICEBERGCONFIG']._serialized_end=3162 - _globals['_EXPORTICEBERGCONFIG_TABLEPROPERTIESENTRY']._serialized_start=3058 - _globals['_EXPORTICEBERGCONFIG_TABLEPROPERTIESENTRY']._serialized_end=3124 - _globals['_READ']._serialized_start=3165 - _globals['_READ']._serialized_end=3457 - _globals['_DEMAND']._serialized_start=3459 - _globals['_DEMAND']._serialized_end=3533 - _globals['_OUTPUT']._serialized_start=3535 - _globals['_OUTPUT']._serialized_end=3629 - _globals['_EXPORT']._serialized_start=3632 - _globals['_EXPORT']._serialized_end=3811 - _globals['_WHATIF']._serialized_start=3813 - _globals['_WHATIF']._serialized_end=3895 - _globals['_ABORT']._serialized_start=3897 - _globals['_ABORT']._serialized_end=3990 + _globals['_SNAPSHOT']._serialized_end=1423 + _globals['_EXPORTCSVCONFIG']._serialized_start=1426 + _globals['_EXPORTCSVCONFIG']._serialized_end=2138 + _globals['_EXPORTCSVCOLUMN']._serialized_start=2140 + _globals['_EXPORTCSVCOLUMN']._serialized_end=2256 + _globals['_EXPORTCSVCOLUMNS']._serialized_start=2258 + _globals['_EXPORTCSVCOLUMNS']._serialized_end=2340 + _globals['_EXPORTCSVSOURCE']._serialized_start=2343 + _globals['_EXPORTCSVSOURCE']._serialized_end=2512 + _globals['_EXPORTCOLUMN']._serialized_start=2514 + _globals['_EXPORTCOLUMN']._serialized_end=2576 + _globals['_EXPORTICEBERGCONFIG']._serialized_start=2579 + _globals['_EXPORTICEBERGCONFIG']._serialized_end=3186 + _globals['_EXPORTICEBERGCONFIG_TABLEPROPERTIESENTRY']._serialized_start=3082 + _globals['_EXPORTICEBERGCONFIG_TABLEPROPERTIESENTRY']._serialized_end=3148 + _globals['_READ']._serialized_start=3189 + _globals['_READ']._serialized_end=3481 + _globals['_DEMAND']._serialized_start=3483 + _globals['_DEMAND']._serialized_end=3557 + _globals['_OUTPUT']._serialized_start=3559 + _globals['_OUTPUT']._serialized_end=3653 + _globals['_EXPORT']._serialized_start=3656 + _globals['_EXPORT']._serialized_end=3835 + _globals['_WHATIF']._serialized_start=3837 + _globals['_WHATIF']._serialized_end=3919 + _globals['_ABORT']._serialized_start=3921 + _globals['_ABORT']._serialized_end=4014 # @@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 098ffef2..e76fffd7 100644 --- a/sdks/python/src/lqp/proto/v1/transactions_pb2.pyi +++ b/sdks/python/src/lqp/proto/v1/transactions_pb2.pyi @@ -4,7 +4,8 @@ from google.protobuf.internal import containers as _containers from google.protobuf.internal import enum_type_wrapper as _enum_type_wrapper from google.protobuf import descriptor as _descriptor from google.protobuf import message as _message -from typing import ClassVar as _ClassVar, Iterable as _Iterable, Mapping as _Mapping, Optional as _Optional, Union as _Union +from collections.abc import Iterable as _Iterable, Mapping as _Mapping +from typing import ClassVar as _ClassVar, Optional as _Optional, Union as _Union DESCRIPTOR: _descriptor.FileDescriptor @@ -96,10 +97,12 @@ class SnapshotMapping(_message.Message): def __init__(self, destination_path: _Optional[_Iterable[str]] = ..., source_relation: _Optional[_Union[_logic_pb2.RelationId, _Mapping]] = ...) -> None: ... class Snapshot(_message.Message): - __slots__ = ("mappings",) + __slots__ = ("mappings", "prefix") MAPPINGS_FIELD_NUMBER: _ClassVar[int] + PREFIX_FIELD_NUMBER: _ClassVar[int] mappings: _containers.RepeatedCompositeFieldContainer[SnapshotMapping] - def __init__(self, mappings: _Optional[_Iterable[_Union[SnapshotMapping, _Mapping]]] = ...) -> None: ... + prefix: _containers.RepeatedScalarFieldContainer[str] + def __init__(self, mappings: _Optional[_Iterable[_Union[SnapshotMapping, _Mapping]]] = ..., prefix: _Optional[_Iterable[str]] = ...) -> None: ... class ExportCSVConfig(_message.Message): __slots__ = ("path", "csv_source", "csv_config", "data_columns", "partition_size", "compression", "syntax_header_row", "syntax_missing_string", "syntax_delim", "syntax_quotechar", "syntax_escapechar") @@ -125,7 +128,7 @@ class ExportCSVConfig(_message.Message): syntax_delim: str syntax_quotechar: str syntax_escapechar: str - def __init__(self, path: _Optional[str] = ..., csv_source: _Optional[_Union[ExportCSVSource, _Mapping]] = ..., csv_config: _Optional[_Union[_logic_pb2.CSVConfig, _Mapping]] = ..., data_columns: _Optional[_Iterable[_Union[ExportCSVColumn, _Mapping]]] = ..., partition_size: _Optional[int] = ..., compression: _Optional[str] = ..., syntax_header_row: bool = ..., syntax_missing_string: _Optional[str] = ..., syntax_delim: _Optional[str] = ..., syntax_quotechar: _Optional[str] = ..., syntax_escapechar: _Optional[str] = ...) -> None: ... + def __init__(self, path: _Optional[str] = ..., csv_source: _Optional[_Union[ExportCSVSource, _Mapping]] = ..., csv_config: _Optional[_Union[_logic_pb2.CSVConfig, _Mapping]] = ..., data_columns: _Optional[_Iterable[_Union[ExportCSVColumn, _Mapping]]] = ..., partition_size: _Optional[int] = ..., compression: _Optional[str] = ..., syntax_header_row: _Optional[bool] = ..., syntax_missing_string: _Optional[str] = ..., syntax_delim: _Optional[str] = ..., syntax_quotechar: _Optional[str] = ..., syntax_escapechar: _Optional[str] = ...) -> None: ... class ExportCSVColumn(_message.Message): __slots__ = ("column_name", "column_data") @@ -155,7 +158,7 @@ class ExportColumn(_message.Message): NULLABLE_FIELD_NUMBER: _ClassVar[int] name: str nullable: bool - def __init__(self, name: _Optional[str] = ..., nullable: bool = ...) -> None: ... + def __init__(self, name: _Optional[str] = ..., nullable: _Optional[bool] = ...) -> None: ... class ExportIcebergConfig(_message.Message): __slots__ = ("locator", "config", "table_def", "columns", "prefix", "target_file_size_bytes", "compression", "table_properties") diff --git a/tests/bin/snapshot.bin b/tests/bin/snapshot.bin index 7886bdf0..4e4ef09f 100644 Binary files a/tests/bin/snapshot.bin and b/tests/bin/snapshot.bin differ diff --git a/tests/lqp/snapshot.lqp b/tests/lqp/snapshot.lqp index 25a50479..ed952de9 100644 --- a/tests/lqp/snapshot.lqp +++ b/tests/lqp/snapshot.lqp @@ -45,7 +45,7 @@ ;; Snapshot the defined relations as EDBs (epoch (writes - (snapshot + (snapshot [] ["my_edb"] :my_rel ["database" "table"] :computed ["schema" "namespace" "relation"] :big_signed)) @@ -53,4 +53,22 @@ (reads (output :snapshot1 :snapshot1) (output :snapshot2 :snapshot2) - (output :snapshot3 :snapshot3)))) + (output :snapshot3 :snapshot3))) + + ;; Snapshot with a prefix: express that all EDBs under "lineitem" are captured. + (epoch + (writes + (snapshot ["lineitem"] + ["l_orderkey"] :my_rel + ["l_partkey"] :computed + ["l_quantity"] :big_signed))) + + ;; Same snapshot with prefix redundantly included in mappings for backwards + ;; compatibility: an older engine that ignores the prefix field can still + ;; interpret the full paths. + (epoch + (writes + (snapshot ["lineitem"] + ["lineitem" "l_orderkey"] :my_rel + ["lineitem" "l_partkey"] :computed + ["lineitem" "l_quantity"] :big_signed)))) diff --git a/tests/pretty/snapshot.lqp b/tests/pretty/snapshot.lqp index f2728e9c..0624a9a5 100644 --- a/tests/pretty/snapshot.lqp +++ b/tests/pretty/snapshot.lqp @@ -42,10 +42,25 @@ (epoch (writes (snapshot + [] ["my_edb"] :my_rel ["database" "table"] :computed ["schema" "namespace" "relation"] :big_signed)) (reads (output :snapshot1 :snapshot1) (output :snapshot2 :snapshot2) - (output :snapshot3 :snapshot3)))) + (output :snapshot3 :snapshot3))) + (epoch + (writes + (snapshot + ["lineitem"] + ["l_orderkey"] :my_rel + ["l_partkey"] :computed + ["l_quantity"] :big_signed))) + (epoch + (writes + (snapshot + ["lineitem"] + ["lineitem" "l_orderkey"] :my_rel + ["lineitem" "l_partkey"] :computed + ["lineitem" "l_quantity"] :big_signed)))) diff --git a/tests/pretty_debug/snapshot.lqp b/tests/pretty_debug/snapshot.lqp index 4894580a..18c7db4f 100644 --- a/tests/pretty_debug/snapshot.lqp +++ b/tests/pretty_debug/snapshot.lqp @@ -47,13 +47,28 @@ (epoch (writes (snapshot + [] ["my_edb"] 0x6a1bb464a40d07263ff95ce83517a614 ["database" "table"] 0x80ad6fa1421c555c156fcefb75cfa12f ["schema" "namespace" "relation"] 0xc00744ac4c3b7e574fb72f89046b65c)) (reads (output :snapshot1 0x3624e471390d4119e743ba2750262197) (output :snapshot2 0xceba74ef3d3b0152a90894dc7ae1c114) - (output :snapshot3 0xc772efb99999f4e6a9aefdc272b64ec8)))) + (output :snapshot3 0xc772efb99999f4e6a9aefdc272b64ec8))) + (epoch + (writes + (snapshot + ["lineitem"] + ["l_orderkey"] 0x6a1bb464a40d07263ff95ce83517a614 + ["l_partkey"] 0x80ad6fa1421c555c156fcefb75cfa12f + ["l_quantity"] 0xc00744ac4c3b7e574fb72f89046b65c))) + (epoch + (writes + (snapshot + ["lineitem"] + ["lineitem" "l_orderkey"] 0x6a1bb464a40d07263ff95ce83517a614 + ["lineitem" "l_partkey"] 0x80ad6fa1421c555c156fcefb75cfa12f + ["lineitem" "l_quantity"] 0xc00744ac4c3b7e574fb72f89046b65c)))) ;; Debug information ;; -----------------------