diff --git a/meta/src/meta/grammar.y b/meta/src/meta/grammar.y index f1fcf6ec..6736b751 100644 --- a/meta/src/meta/grammar.y +++ b/meta/src/meta/grammar.y @@ -147,6 +147,7 @@ %nonterm false logic.Disjunction %nonterm ffi logic.FFI %nonterm ffi_args Sequence[logic.Abstraction] +%nonterm fixed_type logic.FixedType %nonterm float_type logic.FloatType %nonterm float32_type logic.Float32Type %nonterm formula logic.Formula @@ -579,6 +580,10 @@ type construct: $$ = logic.Type(uint32_type=$1) deconstruct if builtin.has_proto_field($$, 'uint32_type'): $1: logic.UInt32Type = $$.uint32_type + | fixed_type + construct: $$ = logic.Type(fixed_type=$1) + deconstruct if builtin.has_proto_field($$, 'fixed_type'): + $1: logic.FixedType = $$.fixed_type unspecified_type : "UNKNOWN" @@ -635,6 +640,12 @@ decimal_type $3: Int64 = builtin.int32_to_int64($$.precision) $4: Int64 = builtin.int32_to_int64($$.scale) +fixed_type + : "(" "FIXED" INT ")" + construct: $$ = logic.FixedType(length=builtin.int64_to_int32($3)) + deconstruct: + $3: Int64 = builtin.int32_to_int64($$.length) + boolean_type : "BOOLEAN" construct: $$ = logic.BooleanType() diff --git a/proto/relationalai/lqp/v1/logic.proto b/proto/relationalai/lqp/v1/logic.proto index ca8c3dae..92a4d219 100644 --- a/proto/relationalai/lqp/v1/logic.proto +++ b/proto/relationalai/lqp/v1/logic.proto @@ -425,6 +425,7 @@ message Type { Int32Type int32_type = 12; Float32Type float32_type = 13; UInt32Type uint32_type = 14; + FixedType fixed_type = 15; } } @@ -459,6 +460,11 @@ message Float32Type {} message UInt32Type {} +// A fixed-length byte array of `length` bytes. +message FixedType { + int32 length = 1; +} + message Value { oneof value { string string_value = 1; diff --git a/sdks/go/src/lqp/v1/logic.pb.go b/sdks/go/src/lqp/v1/logic.pb.go index befa9580..e0ac6aed 100644 --- a/sdks/go/src/lqp/v1/logic.pb.go +++ b/sdks/go/src/lqp/v1/logic.pb.go @@ -3951,6 +3951,7 @@ type Type struct { // *Type_Int32Type // *Type_Float32Type // *Type_Uint32Type + // *Type_FixedType Type isType_Type `protobuf_oneof:"type"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache @@ -4119,6 +4120,15 @@ func (x *Type) GetUint32Type() *UInt32Type { return nil } +func (x *Type) GetFixedType() *FixedType { + if x != nil { + if x, ok := x.Type.(*Type_FixedType); ok { + return x.FixedType + } + } + return nil +} + type isType_Type interface { isType_Type() } @@ -4179,6 +4189,10 @@ type Type_Uint32Type struct { Uint32Type *UInt32Type `protobuf:"bytes,14,opt,name=uint32_type,json=uint32Type,proto3,oneof"` } +type Type_FixedType struct { + FixedType *FixedType `protobuf:"bytes,15,opt,name=fixed_type,json=fixedType,proto3,oneof"` +} + func (*Type_UnspecifiedType) isType_Type() {} func (*Type_StringType) isType_Type() {} @@ -4207,6 +4221,8 @@ func (*Type_Float32Type) isType_Type() {} func (*Type_Uint32Type) isType_Type() {} +func (*Type_FixedType) isType_Type() {} + type UnspecifiedType struct { state protoimpl.MessageState `protogen:"open.v1"` unknownFields protoimpl.UnknownFields @@ -4727,6 +4743,52 @@ func (*UInt32Type) Descriptor() ([]byte, []int) { return file_relationalai_lqp_v1_logic_proto_rawDescGZIP(), []int{71} } +// A fixed-length byte array of `length` bytes. In CSV data, a value is written as +// 2 * `length` hex digits, most significant byte first. +type FixedType struct { + state protoimpl.MessageState `protogen:"open.v1"` + Length int32 `protobuf:"varint,1,opt,name=length,proto3" json:"length,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *FixedType) Reset() { + *x = FixedType{} + mi := &file_relationalai_lqp_v1_logic_proto_msgTypes[72] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *FixedType) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*FixedType) ProtoMessage() {} + +func (x *FixedType) ProtoReflect() protoreflect.Message { + mi := &file_relationalai_lqp_v1_logic_proto_msgTypes[72] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use FixedType.ProtoReflect.Descriptor instead. +func (*FixedType) Descriptor() ([]byte, []int) { + return file_relationalai_lqp_v1_logic_proto_rawDescGZIP(), []int{72} +} + +func (x *FixedType) GetLength() int32 { + if x != nil { + return x.Length + } + return 0 +} + type Value struct { state protoimpl.MessageState `protogen:"open.v1"` // Types that are valid to be assigned to Value: @@ -4751,7 +4813,7 @@ type Value struct { func (x *Value) Reset() { *x = Value{} - mi := &file_relationalai_lqp_v1_logic_proto_msgTypes[72] + mi := &file_relationalai_lqp_v1_logic_proto_msgTypes[73] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4763,7 +4825,7 @@ func (x *Value) String() string { func (*Value) ProtoMessage() {} func (x *Value) ProtoReflect() protoreflect.Message { - mi := &file_relationalai_lqp_v1_logic_proto_msgTypes[72] + mi := &file_relationalai_lqp_v1_logic_proto_msgTypes[73] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4776,7 +4838,7 @@ func (x *Value) ProtoReflect() protoreflect.Message { // Deprecated: Use Value.ProtoReflect.Descriptor instead. func (*Value) Descriptor() ([]byte, []int) { - return file_relationalai_lqp_v1_logic_proto_rawDescGZIP(), []int{72} + return file_relationalai_lqp_v1_logic_proto_rawDescGZIP(), []int{73} } func (x *Value) GetValue() isValue_Value { @@ -4995,7 +5057,7 @@ type UInt128Value struct { func (x *UInt128Value) Reset() { *x = UInt128Value{} - mi := &file_relationalai_lqp_v1_logic_proto_msgTypes[73] + mi := &file_relationalai_lqp_v1_logic_proto_msgTypes[74] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5007,7 +5069,7 @@ func (x *UInt128Value) String() string { func (*UInt128Value) ProtoMessage() {} func (x *UInt128Value) ProtoReflect() protoreflect.Message { - mi := &file_relationalai_lqp_v1_logic_proto_msgTypes[73] + mi := &file_relationalai_lqp_v1_logic_proto_msgTypes[74] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5020,7 +5082,7 @@ func (x *UInt128Value) ProtoReflect() protoreflect.Message { // Deprecated: Use UInt128Value.ProtoReflect.Descriptor instead. func (*UInt128Value) Descriptor() ([]byte, []int) { - return file_relationalai_lqp_v1_logic_proto_rawDescGZIP(), []int{73} + return file_relationalai_lqp_v1_logic_proto_rawDescGZIP(), []int{74} } func (x *UInt128Value) GetLow() uint64 { @@ -5047,7 +5109,7 @@ type Int128Value struct { func (x *Int128Value) Reset() { *x = Int128Value{} - mi := &file_relationalai_lqp_v1_logic_proto_msgTypes[74] + mi := &file_relationalai_lqp_v1_logic_proto_msgTypes[75] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5059,7 +5121,7 @@ func (x *Int128Value) String() string { func (*Int128Value) ProtoMessage() {} func (x *Int128Value) ProtoReflect() protoreflect.Message { - mi := &file_relationalai_lqp_v1_logic_proto_msgTypes[74] + mi := &file_relationalai_lqp_v1_logic_proto_msgTypes[75] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5072,7 +5134,7 @@ func (x *Int128Value) ProtoReflect() protoreflect.Message { // Deprecated: Use Int128Value.ProtoReflect.Descriptor instead. func (*Int128Value) Descriptor() ([]byte, []int) { - return file_relationalai_lqp_v1_logic_proto_rawDescGZIP(), []int{74} + return file_relationalai_lqp_v1_logic_proto_rawDescGZIP(), []int{75} } func (x *Int128Value) GetLow() uint64 { @@ -5097,7 +5159,7 @@ type MissingValue struct { func (x *MissingValue) Reset() { *x = MissingValue{} - mi := &file_relationalai_lqp_v1_logic_proto_msgTypes[75] + mi := &file_relationalai_lqp_v1_logic_proto_msgTypes[76] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5109,7 +5171,7 @@ func (x *MissingValue) String() string { func (*MissingValue) ProtoMessage() {} func (x *MissingValue) ProtoReflect() protoreflect.Message { - mi := &file_relationalai_lqp_v1_logic_proto_msgTypes[75] + mi := &file_relationalai_lqp_v1_logic_proto_msgTypes[76] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5122,7 +5184,7 @@ func (x *MissingValue) ProtoReflect() protoreflect.Message { // Deprecated: Use MissingValue.ProtoReflect.Descriptor instead. func (*MissingValue) Descriptor() ([]byte, []int) { - return file_relationalai_lqp_v1_logic_proto_rawDescGZIP(), []int{75} + return file_relationalai_lqp_v1_logic_proto_rawDescGZIP(), []int{76} } type DateValue struct { @@ -5136,7 +5198,7 @@ type DateValue struct { func (x *DateValue) Reset() { *x = DateValue{} - mi := &file_relationalai_lqp_v1_logic_proto_msgTypes[76] + mi := &file_relationalai_lqp_v1_logic_proto_msgTypes[77] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5148,7 +5210,7 @@ func (x *DateValue) String() string { func (*DateValue) ProtoMessage() {} func (x *DateValue) ProtoReflect() protoreflect.Message { - mi := &file_relationalai_lqp_v1_logic_proto_msgTypes[76] + mi := &file_relationalai_lqp_v1_logic_proto_msgTypes[77] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5161,7 +5223,7 @@ func (x *DateValue) ProtoReflect() protoreflect.Message { // Deprecated: Use DateValue.ProtoReflect.Descriptor instead. func (*DateValue) Descriptor() ([]byte, []int) { - return file_relationalai_lqp_v1_logic_proto_rawDescGZIP(), []int{76} + return file_relationalai_lqp_v1_logic_proto_rawDescGZIP(), []int{77} } func (x *DateValue) GetYear() int32 { @@ -5202,7 +5264,7 @@ type DateTimeValue struct { func (x *DateTimeValue) Reset() { *x = DateTimeValue{} - mi := &file_relationalai_lqp_v1_logic_proto_msgTypes[77] + mi := &file_relationalai_lqp_v1_logic_proto_msgTypes[78] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5214,7 +5276,7 @@ func (x *DateTimeValue) String() string { func (*DateTimeValue) ProtoMessage() {} func (x *DateTimeValue) ProtoReflect() protoreflect.Message { - mi := &file_relationalai_lqp_v1_logic_proto_msgTypes[77] + mi := &file_relationalai_lqp_v1_logic_proto_msgTypes[78] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5227,7 +5289,7 @@ func (x *DateTimeValue) ProtoReflect() protoreflect.Message { // Deprecated: Use DateTimeValue.ProtoReflect.Descriptor instead. func (*DateTimeValue) Descriptor() ([]byte, []int) { - return file_relationalai_lqp_v1_logic_proto_rawDescGZIP(), []int{77} + return file_relationalai_lqp_v1_logic_proto_rawDescGZIP(), []int{78} } func (x *DateTimeValue) GetYear() int32 { @@ -5290,7 +5352,7 @@ type DecimalValue struct { func (x *DecimalValue) Reset() { *x = DecimalValue{} - mi := &file_relationalai_lqp_v1_logic_proto_msgTypes[78] + mi := &file_relationalai_lqp_v1_logic_proto_msgTypes[79] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5302,7 +5364,7 @@ func (x *DecimalValue) String() string { func (*DecimalValue) ProtoMessage() {} func (x *DecimalValue) ProtoReflect() protoreflect.Message { - mi := &file_relationalai_lqp_v1_logic_proto_msgTypes[78] + mi := &file_relationalai_lqp_v1_logic_proto_msgTypes[79] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5315,7 +5377,7 @@ func (x *DecimalValue) ProtoReflect() protoreflect.Message { // Deprecated: Use DecimalValue.ProtoReflect.Descriptor instead. func (*DecimalValue) Descriptor() ([]byte, []int) { - return file_relationalai_lqp_v1_logic_proto_rawDescGZIP(), []int{78} + return file_relationalai_lqp_v1_logic_proto_rawDescGZIP(), []int{79} } func (x *DecimalValue) GetPrecision() int32 { @@ -5948,7 +6010,7 @@ var file_relationalai_lqp_v1_logic_proto_rawDesc = string([]byte{ 0x15, 0x0a, 0x06, 0x69, 0x64, 0x5f, 0x6c, 0x6f, 0x77, 0x18, 0x01, 0x20, 0x01, 0x28, 0x06, 0x52, 0x05, 0x69, 0x64, 0x4c, 0x6f, 0x77, 0x12, 0x17, 0x0a, 0x07, 0x69, 0x64, 0x5f, 0x68, 0x69, 0x67, 0x68, 0x18, 0x02, 0x20, 0x01, 0x28, 0x06, 0x52, 0x06, 0x69, 0x64, 0x48, 0x69, 0x67, 0x68, 0x22, - 0xd5, 0x07, 0x0a, 0x04, 0x54, 0x79, 0x70, 0x65, 0x12, 0x51, 0x0a, 0x10, 0x75, 0x6e, 0x73, 0x70, + 0x96, 0x08, 0x0a, 0x04, 0x54, 0x79, 0x70, 0x65, 0x12, 0x51, 0x0a, 0x10, 0x75, 0x6e, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x55, 0x6e, 0x73, 0x70, 0x65, 0x63, 0x69, @@ -6008,104 +6070,110 @@ var file_relationalai_lqp_v1_logic_proto_rawDesc = string([]byte{ 0x69, 0x6e, 0x74, 0x33, 0x32, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x0e, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x55, 0x49, 0x6e, 0x74, 0x33, 0x32, 0x54, 0x79, 0x70, - 0x65, 0x48, 0x00, 0x52, 0x0a, 0x75, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x54, 0x79, 0x70, 0x65, 0x42, - 0x06, 0x0a, 0x04, 0x74, 0x79, 0x70, 0x65, 0x22, 0x11, 0x0a, 0x0f, 0x55, 0x6e, 0x73, 0x70, 0x65, - 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x54, 0x79, 0x70, 0x65, 0x22, 0x0c, 0x0a, 0x0a, 0x53, 0x74, - 0x72, 0x69, 0x6e, 0x67, 0x54, 0x79, 0x70, 0x65, 0x22, 0x09, 0x0a, 0x07, 0x49, 0x6e, 0x74, 0x54, - 0x79, 0x70, 0x65, 0x22, 0x0b, 0x0a, 0x09, 0x46, 0x6c, 0x6f, 0x61, 0x74, 0x54, 0x79, 0x70, 0x65, - 0x22, 0x0d, 0x0a, 0x0b, 0x55, 0x49, 0x6e, 0x74, 0x31, 0x32, 0x38, 0x54, 0x79, 0x70, 0x65, 0x22, - 0x0c, 0x0a, 0x0a, 0x49, 0x6e, 0x74, 0x31, 0x32, 0x38, 0x54, 0x79, 0x70, 0x65, 0x22, 0x0a, 0x0a, - 0x08, 0x44, 0x61, 0x74, 0x65, 0x54, 0x79, 0x70, 0x65, 0x22, 0x0e, 0x0a, 0x0c, 0x44, 0x61, 0x74, - 0x65, 0x54, 0x69, 0x6d, 0x65, 0x54, 0x79, 0x70, 0x65, 0x22, 0x0d, 0x0a, 0x0b, 0x4d, 0x69, 0x73, - 0x73, 0x69, 0x6e, 0x67, 0x54, 0x79, 0x70, 0x65, 0x22, 0x41, 0x0a, 0x0b, 0x44, 0x65, 0x63, 0x69, - 0x6d, 0x61, 0x6c, 0x54, 0x79, 0x70, 0x65, 0x12, 0x1c, 0x0a, 0x09, 0x70, 0x72, 0x65, 0x63, 0x69, - 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x70, 0x72, 0x65, 0x63, - 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x14, 0x0a, 0x05, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x18, 0x02, - 0x20, 0x01, 0x28, 0x05, 0x52, 0x05, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x22, 0x0d, 0x0a, 0x0b, 0x42, - 0x6f, 0x6f, 0x6c, 0x65, 0x61, 0x6e, 0x54, 0x79, 0x70, 0x65, 0x22, 0x0b, 0x0a, 0x09, 0x49, 0x6e, - 0x74, 0x33, 0x32, 0x54, 0x79, 0x70, 0x65, 0x22, 0x0d, 0x0a, 0x0b, 0x46, 0x6c, 0x6f, 0x61, 0x74, - 0x33, 0x32, 0x54, 0x79, 0x70, 0x65, 0x22, 0x0c, 0x0a, 0x0a, 0x55, 0x49, 0x6e, 0x74, 0x33, 0x32, - 0x54, 0x79, 0x70, 0x65, 0x22, 0xc0, 0x05, 0x0a, 0x05, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x23, - 0x0a, 0x0c, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x01, - 0x20, 0x01, 0x28, 0x09, 0x48, 0x00, 0x52, 0x0b, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x56, 0x61, - 0x6c, 0x75, 0x65, 0x12, 0x1d, 0x0a, 0x09, 0x69, 0x6e, 0x74, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, - 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x48, 0x00, 0x52, 0x08, 0x69, 0x6e, 0x74, 0x56, 0x61, 0x6c, - 0x75, 0x65, 0x12, 0x21, 0x0a, 0x0b, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x5f, 0x76, 0x61, 0x6c, 0x75, - 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x01, 0x48, 0x00, 0x52, 0x0a, 0x66, 0x6c, 0x6f, 0x61, 0x74, - 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x48, 0x0a, 0x0d, 0x75, 0x69, 0x6e, 0x74, 0x31, 0x32, 0x38, - 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x21, 0x2e, 0x72, - 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, - 0x76, 0x31, 0x2e, 0x55, 0x49, 0x6e, 0x74, 0x31, 0x32, 0x38, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, - 0x00, 0x52, 0x0c, 0x75, 0x69, 0x6e, 0x74, 0x31, 0x32, 0x38, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, - 0x45, 0x0a, 0x0c, 0x69, 0x6e, 0x74, 0x31, 0x32, 0x38, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, - 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, - 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x49, 0x6e, 0x74, 0x31, - 0x32, 0x38, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x00, 0x52, 0x0b, 0x69, 0x6e, 0x74, 0x31, 0x32, - 0x38, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x48, 0x0a, 0x0d, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6e, - 0x67, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x21, 0x2e, - 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, - 0x2e, 0x76, 0x31, 0x2e, 0x4d, 0x69, 0x73, 0x73, 0x69, 0x6e, 0x67, 0x56, 0x61, 0x6c, 0x75, 0x65, - 0x48, 0x00, 0x52, 0x0c, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6e, 0x67, 0x56, 0x61, 0x6c, 0x75, 0x65, - 0x12, 0x3f, 0x0a, 0x0a, 0x64, 0x61, 0x74, 0x65, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x07, - 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, - 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x61, 0x74, 0x65, 0x56, - 0x61, 0x6c, 0x75, 0x65, 0x48, 0x00, 0x52, 0x09, 0x64, 0x61, 0x74, 0x65, 0x56, 0x61, 0x6c, 0x75, - 0x65, 0x12, 0x4b, 0x0a, 0x0e, 0x64, 0x61, 0x74, 0x65, 0x74, 0x69, 0x6d, 0x65, 0x5f, 0x76, 0x61, - 0x6c, 0x75, 0x65, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x72, 0x65, 0x6c, 0x61, - 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, - 0x44, 0x61, 0x74, 0x65, 0x54, 0x69, 0x6d, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x00, 0x52, - 0x0d, 0x64, 0x61, 0x74, 0x65, 0x74, 0x69, 0x6d, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x48, - 0x0a, 0x0d, 0x64, 0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, - 0x09, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x21, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, - 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x65, 0x63, 0x69, - 0x6d, 0x61, 0x6c, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x00, 0x52, 0x0c, 0x64, 0x65, 0x63, 0x69, - 0x6d, 0x61, 0x6c, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x25, 0x0a, 0x0d, 0x62, 0x6f, 0x6f, 0x6c, - 0x65, 0x61, 0x6e, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x08, 0x48, - 0x00, 0x52, 0x0c, 0x62, 0x6f, 0x6f, 0x6c, 0x65, 0x61, 0x6e, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, - 0x21, 0x0a, 0x0b, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x0b, - 0x20, 0x01, 0x28, 0x05, 0x48, 0x00, 0x52, 0x0a, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x56, 0x61, 0x6c, - 0x75, 0x65, 0x12, 0x25, 0x0a, 0x0d, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x33, 0x32, 0x5f, 0x76, 0x61, - 0x6c, 0x75, 0x65, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x02, 0x48, 0x00, 0x52, 0x0c, 0x66, 0x6c, 0x6f, - 0x61, 0x74, 0x33, 0x32, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x23, 0x0a, 0x0c, 0x75, 0x69, 0x6e, - 0x74, 0x33, 0x32, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x0d, 0x48, - 0x00, 0x52, 0x0b, 0x75, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x42, 0x07, - 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x34, 0x0a, 0x0c, 0x55, 0x49, 0x6e, 0x74, 0x31, - 0x32, 0x38, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x10, 0x0a, 0x03, 0x6c, 0x6f, 0x77, 0x18, 0x01, - 0x20, 0x01, 0x28, 0x06, 0x52, 0x03, 0x6c, 0x6f, 0x77, 0x12, 0x12, 0x0a, 0x04, 0x68, 0x69, 0x67, - 0x68, 0x18, 0x02, 0x20, 0x01, 0x28, 0x06, 0x52, 0x04, 0x68, 0x69, 0x67, 0x68, 0x22, 0x33, 0x0a, - 0x0b, 0x49, 0x6e, 0x74, 0x31, 0x32, 0x38, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x10, 0x0a, 0x03, - 0x6c, 0x6f, 0x77, 0x18, 0x01, 0x20, 0x01, 0x28, 0x06, 0x52, 0x03, 0x6c, 0x6f, 0x77, 0x12, 0x12, - 0x0a, 0x04, 0x68, 0x69, 0x67, 0x68, 0x18, 0x02, 0x20, 0x01, 0x28, 0x06, 0x52, 0x04, 0x68, 0x69, - 0x67, 0x68, 0x22, 0x0e, 0x0a, 0x0c, 0x4d, 0x69, 0x73, 0x73, 0x69, 0x6e, 0x67, 0x56, 0x61, 0x6c, - 0x75, 0x65, 0x22, 0x47, 0x0a, 0x09, 0x44, 0x61, 0x74, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, - 0x12, 0x0a, 0x04, 0x79, 0x65, 0x61, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x04, 0x79, - 0x65, 0x61, 0x72, 0x12, 0x14, 0x0a, 0x05, 0x6d, 0x6f, 0x6e, 0x74, 0x68, 0x18, 0x02, 0x20, 0x01, - 0x28, 0x05, 0x52, 0x05, 0x6d, 0x6f, 0x6e, 0x74, 0x68, 0x12, 0x10, 0x0a, 0x03, 0x64, 0x61, 0x79, - 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x03, 0x64, 0x61, 0x79, 0x22, 0xb1, 0x01, 0x0a, 0x0d, - 0x44, 0x61, 0x74, 0x65, 0x54, 0x69, 0x6d, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x12, 0x0a, - 0x04, 0x79, 0x65, 0x61, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x04, 0x79, 0x65, 0x61, - 0x72, 0x12, 0x14, 0x0a, 0x05, 0x6d, 0x6f, 0x6e, 0x74, 0x68, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, - 0x52, 0x05, 0x6d, 0x6f, 0x6e, 0x74, 0x68, 0x12, 0x10, 0x0a, 0x03, 0x64, 0x61, 0x79, 0x18, 0x03, - 0x20, 0x01, 0x28, 0x05, 0x52, 0x03, 0x64, 0x61, 0x79, 0x12, 0x12, 0x0a, 0x04, 0x68, 0x6f, 0x75, - 0x72, 0x18, 0x04, 0x20, 0x01, 0x28, 0x05, 0x52, 0x04, 0x68, 0x6f, 0x75, 0x72, 0x12, 0x16, 0x0a, - 0x06, 0x6d, 0x69, 0x6e, 0x75, 0x74, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x05, 0x52, 0x06, 0x6d, - 0x69, 0x6e, 0x75, 0x74, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x73, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x18, - 0x06, 0x20, 0x01, 0x28, 0x05, 0x52, 0x06, 0x73, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x12, 0x20, 0x0a, - 0x0b, 0x6d, 0x69, 0x63, 0x72, 0x6f, 0x73, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x18, 0x07, 0x20, 0x01, - 0x28, 0x05, 0x52, 0x0b, 0x6d, 0x69, 0x63, 0x72, 0x6f, 0x73, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x22, - 0x7a, 0x0a, 0x0c, 0x44, 0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, - 0x1c, 0x0a, 0x09, 0x70, 0x72, 0x65, 0x63, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, - 0x28, 0x05, 0x52, 0x09, 0x70, 0x72, 0x65, 0x63, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x14, 0x0a, - 0x05, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x05, 0x73, 0x63, - 0x61, 0x6c, 0x65, 0x12, 0x36, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x03, 0x20, 0x01, - 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, - 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x49, 0x6e, 0x74, 0x31, 0x32, 0x38, 0x56, - 0x61, 0x6c, 0x75, 0x65, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x42, 0x43, 0x5a, 0x41, 0x67, - 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x52, 0x65, 0x6c, 0x61, 0x74, 0x69, - 0x6f, 0x6e, 0x61, 0x6c, 0x41, 0x49, 0x2f, 0x6c, 0x6f, 0x67, 0x69, 0x63, 0x61, 0x6c, 0x2d, 0x71, - 0x75, 0x65, 0x72, 0x79, 0x2d, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x2f, 0x73, 0x64, - 0x6b, 0x73, 0x2f, 0x67, 0x6f, 0x2f, 0x73, 0x72, 0x63, 0x2f, 0x6c, 0x71, 0x70, 0x2f, 0x76, 0x31, - 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, + 0x65, 0x48, 0x00, 0x52, 0x0a, 0x75, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x54, 0x79, 0x70, 0x65, 0x12, + 0x3f, 0x0a, 0x0a, 0x66, 0x69, 0x78, 0x65, 0x64, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x0f, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, + 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x46, 0x69, 0x78, 0x65, 0x64, 0x54, + 0x79, 0x70, 0x65, 0x48, 0x00, 0x52, 0x09, 0x66, 0x69, 0x78, 0x65, 0x64, 0x54, 0x79, 0x70, 0x65, + 0x42, 0x06, 0x0a, 0x04, 0x74, 0x79, 0x70, 0x65, 0x22, 0x11, 0x0a, 0x0f, 0x55, 0x6e, 0x73, 0x70, + 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x54, 0x79, 0x70, 0x65, 0x22, 0x0c, 0x0a, 0x0a, 0x53, + 0x74, 0x72, 0x69, 0x6e, 0x67, 0x54, 0x79, 0x70, 0x65, 0x22, 0x09, 0x0a, 0x07, 0x49, 0x6e, 0x74, + 0x54, 0x79, 0x70, 0x65, 0x22, 0x0b, 0x0a, 0x09, 0x46, 0x6c, 0x6f, 0x61, 0x74, 0x54, 0x79, 0x70, + 0x65, 0x22, 0x0d, 0x0a, 0x0b, 0x55, 0x49, 0x6e, 0x74, 0x31, 0x32, 0x38, 0x54, 0x79, 0x70, 0x65, + 0x22, 0x0c, 0x0a, 0x0a, 0x49, 0x6e, 0x74, 0x31, 0x32, 0x38, 0x54, 0x79, 0x70, 0x65, 0x22, 0x0a, + 0x0a, 0x08, 0x44, 0x61, 0x74, 0x65, 0x54, 0x79, 0x70, 0x65, 0x22, 0x0e, 0x0a, 0x0c, 0x44, 0x61, + 0x74, 0x65, 0x54, 0x69, 0x6d, 0x65, 0x54, 0x79, 0x70, 0x65, 0x22, 0x0d, 0x0a, 0x0b, 0x4d, 0x69, + 0x73, 0x73, 0x69, 0x6e, 0x67, 0x54, 0x79, 0x70, 0x65, 0x22, 0x41, 0x0a, 0x0b, 0x44, 0x65, 0x63, + 0x69, 0x6d, 0x61, 0x6c, 0x54, 0x79, 0x70, 0x65, 0x12, 0x1c, 0x0a, 0x09, 0x70, 0x72, 0x65, 0x63, + 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x70, 0x72, 0x65, + 0x63, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x14, 0x0a, 0x05, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x18, + 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x05, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x22, 0x0d, 0x0a, 0x0b, + 0x42, 0x6f, 0x6f, 0x6c, 0x65, 0x61, 0x6e, 0x54, 0x79, 0x70, 0x65, 0x22, 0x0b, 0x0a, 0x09, 0x49, + 0x6e, 0x74, 0x33, 0x32, 0x54, 0x79, 0x70, 0x65, 0x22, 0x0d, 0x0a, 0x0b, 0x46, 0x6c, 0x6f, 0x61, + 0x74, 0x33, 0x32, 0x54, 0x79, 0x70, 0x65, 0x22, 0x0c, 0x0a, 0x0a, 0x55, 0x49, 0x6e, 0x74, 0x33, + 0x32, 0x54, 0x79, 0x70, 0x65, 0x22, 0x23, 0x0a, 0x09, 0x46, 0x69, 0x78, 0x65, 0x64, 0x54, 0x79, + 0x70, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x6c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x05, 0x52, 0x06, 0x6c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x22, 0xc0, 0x05, 0x0a, 0x05, 0x56, + 0x61, 0x6c, 0x75, 0x65, 0x12, 0x23, 0x0a, 0x0c, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x5f, 0x76, + 0x61, 0x6c, 0x75, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x48, 0x00, 0x52, 0x0b, 0x73, 0x74, + 0x72, 0x69, 0x6e, 0x67, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x1d, 0x0a, 0x09, 0x69, 0x6e, 0x74, + 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x48, 0x00, 0x52, 0x08, + 0x69, 0x6e, 0x74, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x21, 0x0a, 0x0b, 0x66, 0x6c, 0x6f, 0x61, + 0x74, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x01, 0x48, 0x00, 0x52, + 0x0a, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x48, 0x0a, 0x0d, 0x75, + 0x69, 0x6e, 0x74, 0x31, 0x32, 0x38, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x04, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x21, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, + 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x55, 0x49, 0x6e, 0x74, 0x31, 0x32, 0x38, + 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x00, 0x52, 0x0c, 0x75, 0x69, 0x6e, 0x74, 0x31, 0x32, 0x38, + 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x45, 0x0a, 0x0c, 0x69, 0x6e, 0x74, 0x31, 0x32, 0x38, 0x5f, + 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x72, 0x65, + 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, + 0x31, 0x2e, 0x49, 0x6e, 0x74, 0x31, 0x32, 0x38, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x00, 0x52, + 0x0b, 0x69, 0x6e, 0x74, 0x31, 0x32, 0x38, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x48, 0x0a, 0x0d, + 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6e, 0x67, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x06, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x21, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, + 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x4d, 0x69, 0x73, 0x73, 0x69, 0x6e, + 0x67, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x00, 0x52, 0x0c, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6e, + 0x67, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x3f, 0x0a, 0x0a, 0x64, 0x61, 0x74, 0x65, 0x5f, 0x76, + 0x61, 0x6c, 0x75, 0x65, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x72, 0x65, 0x6c, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, + 0x2e, 0x44, 0x61, 0x74, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x00, 0x52, 0x09, 0x64, 0x61, + 0x74, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x4b, 0x0a, 0x0e, 0x64, 0x61, 0x74, 0x65, 0x74, + 0x69, 0x6d, 0x65, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x22, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, + 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x61, 0x74, 0x65, 0x54, 0x69, 0x6d, 0x65, 0x56, 0x61, + 0x6c, 0x75, 0x65, 0x48, 0x00, 0x52, 0x0d, 0x64, 0x61, 0x74, 0x65, 0x74, 0x69, 0x6d, 0x65, 0x56, + 0x61, 0x6c, 0x75, 0x65, 0x12, 0x48, 0x0a, 0x0d, 0x64, 0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x5f, + 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x09, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x21, 0x2e, 0x72, 0x65, + 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, + 0x31, 0x2e, 0x44, 0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x00, + 0x52, 0x0c, 0x64, 0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x25, + 0x0a, 0x0d, 0x62, 0x6f, 0x6f, 0x6c, 0x65, 0x61, 0x6e, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, + 0x0a, 0x20, 0x01, 0x28, 0x08, 0x48, 0x00, 0x52, 0x0c, 0x62, 0x6f, 0x6f, 0x6c, 0x65, 0x61, 0x6e, + 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x21, 0x0a, 0x0b, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x5f, 0x76, + 0x61, 0x6c, 0x75, 0x65, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x05, 0x48, 0x00, 0x52, 0x0a, 0x69, 0x6e, + 0x74, 0x33, 0x32, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x25, 0x0a, 0x0d, 0x66, 0x6c, 0x6f, 0x61, + 0x74, 0x33, 0x32, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x02, 0x48, + 0x00, 0x52, 0x0c, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x33, 0x32, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, + 0x23, 0x0a, 0x0c, 0x75, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, + 0x0d, 0x20, 0x01, 0x28, 0x0d, 0x48, 0x00, 0x52, 0x0b, 0x75, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x56, + 0x61, 0x6c, 0x75, 0x65, 0x42, 0x07, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x34, 0x0a, + 0x0c, 0x55, 0x49, 0x6e, 0x74, 0x31, 0x32, 0x38, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x10, 0x0a, + 0x03, 0x6c, 0x6f, 0x77, 0x18, 0x01, 0x20, 0x01, 0x28, 0x06, 0x52, 0x03, 0x6c, 0x6f, 0x77, 0x12, + 0x12, 0x0a, 0x04, 0x68, 0x69, 0x67, 0x68, 0x18, 0x02, 0x20, 0x01, 0x28, 0x06, 0x52, 0x04, 0x68, + 0x69, 0x67, 0x68, 0x22, 0x33, 0x0a, 0x0b, 0x49, 0x6e, 0x74, 0x31, 0x32, 0x38, 0x56, 0x61, 0x6c, + 0x75, 0x65, 0x12, 0x10, 0x0a, 0x03, 0x6c, 0x6f, 0x77, 0x18, 0x01, 0x20, 0x01, 0x28, 0x06, 0x52, + 0x03, 0x6c, 0x6f, 0x77, 0x12, 0x12, 0x0a, 0x04, 0x68, 0x69, 0x67, 0x68, 0x18, 0x02, 0x20, 0x01, + 0x28, 0x06, 0x52, 0x04, 0x68, 0x69, 0x67, 0x68, 0x22, 0x0e, 0x0a, 0x0c, 0x4d, 0x69, 0x73, 0x73, + 0x69, 0x6e, 0x67, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x47, 0x0a, 0x09, 0x44, 0x61, 0x74, 0x65, + 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x79, 0x65, 0x61, 0x72, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x05, 0x52, 0x04, 0x79, 0x65, 0x61, 0x72, 0x12, 0x14, 0x0a, 0x05, 0x6d, 0x6f, 0x6e, + 0x74, 0x68, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x05, 0x6d, 0x6f, 0x6e, 0x74, 0x68, 0x12, + 0x10, 0x0a, 0x03, 0x64, 0x61, 0x79, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x03, 0x64, 0x61, + 0x79, 0x22, 0xb1, 0x01, 0x0a, 0x0d, 0x44, 0x61, 0x74, 0x65, 0x54, 0x69, 0x6d, 0x65, 0x56, 0x61, + 0x6c, 0x75, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x79, 0x65, 0x61, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x05, 0x52, 0x04, 0x79, 0x65, 0x61, 0x72, 0x12, 0x14, 0x0a, 0x05, 0x6d, 0x6f, 0x6e, 0x74, 0x68, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x05, 0x6d, 0x6f, 0x6e, 0x74, 0x68, 0x12, 0x10, 0x0a, + 0x03, 0x64, 0x61, 0x79, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x03, 0x64, 0x61, 0x79, 0x12, + 0x12, 0x0a, 0x04, 0x68, 0x6f, 0x75, 0x72, 0x18, 0x04, 0x20, 0x01, 0x28, 0x05, 0x52, 0x04, 0x68, + 0x6f, 0x75, 0x72, 0x12, 0x16, 0x0a, 0x06, 0x6d, 0x69, 0x6e, 0x75, 0x74, 0x65, 0x18, 0x05, 0x20, + 0x01, 0x28, 0x05, 0x52, 0x06, 0x6d, 0x69, 0x6e, 0x75, 0x74, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x73, + 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x18, 0x06, 0x20, 0x01, 0x28, 0x05, 0x52, 0x06, 0x73, 0x65, 0x63, + 0x6f, 0x6e, 0x64, 0x12, 0x20, 0x0a, 0x0b, 0x6d, 0x69, 0x63, 0x72, 0x6f, 0x73, 0x65, 0x63, 0x6f, + 0x6e, 0x64, 0x18, 0x07, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0b, 0x6d, 0x69, 0x63, 0x72, 0x6f, 0x73, + 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x22, 0x7a, 0x0a, 0x0c, 0x44, 0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, + 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x1c, 0x0a, 0x09, 0x70, 0x72, 0x65, 0x63, 0x69, 0x73, 0x69, + 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x70, 0x72, 0x65, 0x63, 0x69, 0x73, + 0x69, 0x6f, 0x6e, 0x12, 0x14, 0x0a, 0x05, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x18, 0x02, 0x20, 0x01, + 0x28, 0x05, 0x52, 0x05, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x12, 0x36, 0x0a, 0x05, 0x76, 0x61, 0x6c, + 0x75, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, + 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x49, + 0x6e, 0x74, 0x31, 0x32, 0x38, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, + 0x65, 0x42, 0x43, 0x5a, 0x41, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, + 0x52, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x41, 0x49, 0x2f, 0x6c, 0x6f, 0x67, + 0x69, 0x63, 0x61, 0x6c, 0x2d, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2d, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x63, 0x6f, 0x6c, 0x2f, 0x73, 0x64, 0x6b, 0x73, 0x2f, 0x67, 0x6f, 0x2f, 0x73, 0x72, 0x63, 0x2f, + 0x6c, 0x71, 0x70, 0x2f, 0x76, 0x31, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, }) var ( @@ -6120,7 +6188,7 @@ func file_relationalai_lqp_v1_logic_proto_rawDescGZIP() []byte { return file_relationalai_lqp_v1_logic_proto_rawDescData } -var file_relationalai_lqp_v1_logic_proto_msgTypes = make([]protoimpl.MessageInfo, 81) +var file_relationalai_lqp_v1_logic_proto_msgTypes = make([]protoimpl.MessageInfo, 82) var file_relationalai_lqp_v1_logic_proto_goTypes = []any{ (*Declaration)(nil), // 0: relationalai.lqp.v1.Declaration (*Def)(nil), // 1: relationalai.lqp.v1.Def @@ -6194,15 +6262,16 @@ var file_relationalai_lqp_v1_logic_proto_goTypes = []any{ (*Int32Type)(nil), // 69: relationalai.lqp.v1.Int32Type (*Float32Type)(nil), // 70: relationalai.lqp.v1.Float32Type (*UInt32Type)(nil), // 71: relationalai.lqp.v1.UInt32Type - (*Value)(nil), // 72: relationalai.lqp.v1.Value - (*UInt128Value)(nil), // 73: relationalai.lqp.v1.UInt128Value - (*Int128Value)(nil), // 74: relationalai.lqp.v1.Int128Value - (*MissingValue)(nil), // 75: relationalai.lqp.v1.MissingValue - (*DateValue)(nil), // 76: relationalai.lqp.v1.DateValue - (*DateTimeValue)(nil), // 77: relationalai.lqp.v1.DateTimeValue - (*DecimalValue)(nil), // 78: relationalai.lqp.v1.DecimalValue - nil, // 79: relationalai.lqp.v1.IcebergCatalogConfig.PropertiesEntry - nil, // 80: relationalai.lqp.v1.IcebergCatalogConfig.AuthPropertiesEntry + (*FixedType)(nil), // 72: relationalai.lqp.v1.FixedType + (*Value)(nil), // 73: relationalai.lqp.v1.Value + (*UInt128Value)(nil), // 74: relationalai.lqp.v1.UInt128Value + (*Int128Value)(nil), // 75: relationalai.lqp.v1.Int128Value + (*MissingValue)(nil), // 76: relationalai.lqp.v1.MissingValue + (*DateValue)(nil), // 77: relationalai.lqp.v1.DateValue + (*DateTimeValue)(nil), // 78: relationalai.lqp.v1.DateTimeValue + (*DecimalValue)(nil), // 79: relationalai.lqp.v1.DecimalValue + nil, // 80: relationalai.lqp.v1.IcebergCatalogConfig.PropertiesEntry + nil, // 81: relationalai.lqp.v1.IcebergCatalogConfig.AuthPropertiesEntry } var file_relationalai_lqp_v1_logic_proto_depIdxs = []int32{ 1, // 0: relationalai.lqp.v1.Declaration.def:type_name -> relationalai.lqp.v1.Def @@ -6286,11 +6355,11 @@ var file_relationalai_lqp_v1_logic_proto_depIdxs = []int32{ 33, // 78: relationalai.lqp.v1.RelAtom.terms:type_name -> relationalai.lqp.v1.RelTerm 34, // 79: relationalai.lqp.v1.Cast.input:type_name -> relationalai.lqp.v1.Term 34, // 80: relationalai.lqp.v1.Cast.result:type_name -> relationalai.lqp.v1.Term - 72, // 81: relationalai.lqp.v1.RelTerm.specialized_value:type_name -> relationalai.lqp.v1.Value + 73, // 81: relationalai.lqp.v1.RelTerm.specialized_value:type_name -> relationalai.lqp.v1.Value 34, // 82: relationalai.lqp.v1.RelTerm.term:type_name -> relationalai.lqp.v1.Term 35, // 83: relationalai.lqp.v1.Term.var:type_name -> relationalai.lqp.v1.Var - 72, // 84: relationalai.lqp.v1.Term.constant:type_name -> relationalai.lqp.v1.Value - 72, // 85: relationalai.lqp.v1.Attribute.args:type_name -> relationalai.lqp.v1.Value + 73, // 84: relationalai.lqp.v1.Term.constant:type_name -> relationalai.lqp.v1.Value + 73, // 85: relationalai.lqp.v1.Attribute.args:type_name -> relationalai.lqp.v1.Value 38, // 86: relationalai.lqp.v1.Data.edb:type_name -> relationalai.lqp.v1.EDB 39, // 87: relationalai.lqp.v1.Data.betree_relation:type_name -> relationalai.lqp.v1.BeTreeRelation 49, // 88: relationalai.lqp.v1.Data.csv_data:type_name -> relationalai.lqp.v1.CSVData @@ -6303,7 +6372,7 @@ var file_relationalai_lqp_v1_logic_proto_depIdxs = []int32{ 57, // 95: relationalai.lqp.v1.BeTreeInfo.value_types:type_name -> relationalai.lqp.v1.Type 41, // 96: relationalai.lqp.v1.BeTreeInfo.storage_config:type_name -> relationalai.lqp.v1.BeTreeConfig 42, // 97: relationalai.lqp.v1.BeTreeInfo.relation_locator:type_name -> relationalai.lqp.v1.BeTreeLocator - 73, // 98: relationalai.lqp.v1.BeTreeLocator.root_pageid:type_name -> relationalai.lqp.v1.UInt128Value + 74, // 98: relationalai.lqp.v1.BeTreeLocator.root_pageid:type_name -> relationalai.lqp.v1.UInt128Value 57, // 99: relationalai.lqp.v1.NamedColumn.type:type_name -> relationalai.lqp.v1.Type 56, // 100: relationalai.lqp.v1.TargetRelation.target_id:type_name -> relationalai.lqp.v1.RelationId 44, // 101: relationalai.lqp.v1.TargetRelation.values:type_name -> relationalai.lqp.v1.NamedColumn @@ -6322,8 +6391,8 @@ var file_relationalai_lqp_v1_logic_proto_depIdxs = []int32{ 53, // 114: relationalai.lqp.v1.IcebergData.locator:type_name -> relationalai.lqp.v1.IcebergLocator 54, // 115: relationalai.lqp.v1.IcebergData.config:type_name -> relationalai.lqp.v1.IcebergCatalogConfig 55, // 116: relationalai.lqp.v1.IcebergData.columns:type_name -> relationalai.lqp.v1.GNFColumn - 79, // 117: relationalai.lqp.v1.IcebergCatalogConfig.properties:type_name -> relationalai.lqp.v1.IcebergCatalogConfig.PropertiesEntry - 80, // 118: relationalai.lqp.v1.IcebergCatalogConfig.auth_properties:type_name -> relationalai.lqp.v1.IcebergCatalogConfig.AuthPropertiesEntry + 80, // 117: relationalai.lqp.v1.IcebergCatalogConfig.properties:type_name -> relationalai.lqp.v1.IcebergCatalogConfig.PropertiesEntry + 81, // 118: relationalai.lqp.v1.IcebergCatalogConfig.auth_properties:type_name -> relationalai.lqp.v1.IcebergCatalogConfig.AuthPropertiesEntry 56, // 119: relationalai.lqp.v1.GNFColumn.target_id:type_name -> relationalai.lqp.v1.RelationId 57, // 120: relationalai.lqp.v1.GNFColumn.types:type_name -> relationalai.lqp.v1.Type 58, // 121: relationalai.lqp.v1.Type.unspecified_type:type_name -> relationalai.lqp.v1.UnspecifiedType @@ -6340,18 +6409,19 @@ var file_relationalai_lqp_v1_logic_proto_depIdxs = []int32{ 69, // 132: relationalai.lqp.v1.Type.int32_type:type_name -> relationalai.lqp.v1.Int32Type 70, // 133: relationalai.lqp.v1.Type.float32_type:type_name -> relationalai.lqp.v1.Float32Type 71, // 134: relationalai.lqp.v1.Type.uint32_type:type_name -> relationalai.lqp.v1.UInt32Type - 73, // 135: relationalai.lqp.v1.Value.uint128_value:type_name -> relationalai.lqp.v1.UInt128Value - 74, // 136: relationalai.lqp.v1.Value.int128_value:type_name -> relationalai.lqp.v1.Int128Value - 75, // 137: relationalai.lqp.v1.Value.missing_value:type_name -> relationalai.lqp.v1.MissingValue - 76, // 138: relationalai.lqp.v1.Value.date_value:type_name -> relationalai.lqp.v1.DateValue - 77, // 139: relationalai.lqp.v1.Value.datetime_value:type_name -> relationalai.lqp.v1.DateTimeValue - 78, // 140: relationalai.lqp.v1.Value.decimal_value:type_name -> relationalai.lqp.v1.DecimalValue - 74, // 141: relationalai.lqp.v1.DecimalValue.value:type_name -> relationalai.lqp.v1.Int128Value - 142, // [142:142] is the sub-list for method output_type - 142, // [142:142] is the sub-list for method input_type - 142, // [142:142] is the sub-list for extension type_name - 142, // [142:142] is the sub-list for extension extendee - 0, // [0:142] is the sub-list for field type_name + 72, // 135: relationalai.lqp.v1.Type.fixed_type:type_name -> relationalai.lqp.v1.FixedType + 74, // 136: relationalai.lqp.v1.Value.uint128_value:type_name -> relationalai.lqp.v1.UInt128Value + 75, // 137: relationalai.lqp.v1.Value.int128_value:type_name -> relationalai.lqp.v1.Int128Value + 76, // 138: relationalai.lqp.v1.Value.missing_value:type_name -> relationalai.lqp.v1.MissingValue + 77, // 139: relationalai.lqp.v1.Value.date_value:type_name -> relationalai.lqp.v1.DateValue + 78, // 140: relationalai.lqp.v1.Value.datetime_value:type_name -> relationalai.lqp.v1.DateTimeValue + 79, // 141: relationalai.lqp.v1.Value.decimal_value:type_name -> relationalai.lqp.v1.DecimalValue + 75, // 142: relationalai.lqp.v1.DecimalValue.value:type_name -> relationalai.lqp.v1.Int128Value + 143, // [143:143] is the sub-list for method output_type + 143, // [143:143] is the sub-list for method input_type + 143, // [143:143] is the sub-list for extension type_name + 143, // [143:143] is the sub-list for extension extendee + 0, // [0:143] is the sub-list for field type_name } func init() { file_relationalai_lqp_v1_logic_proto_init() } @@ -6440,8 +6510,9 @@ func file_relationalai_lqp_v1_logic_proto_init() { (*Type_Int32Type)(nil), (*Type_Float32Type)(nil), (*Type_Uint32Type)(nil), + (*Type_FixedType)(nil), } - file_relationalai_lqp_v1_logic_proto_msgTypes[72].OneofWrappers = []any{ + file_relationalai_lqp_v1_logic_proto_msgTypes[73].OneofWrappers = []any{ (*Value_StringValue)(nil), (*Value_IntValue)(nil), (*Value_FloatValue)(nil), @@ -6462,7 +6533,7 @@ func file_relationalai_lqp_v1_logic_proto_init() { GoPackagePath: reflect.TypeOf(x{}).PkgPath(), RawDescriptor: unsafe.Slice(unsafe.StringData(file_relationalai_lqp_v1_logic_proto_rawDesc), len(file_relationalai_lqp_v1_logic_proto_rawDesc)), NumEnums: 0, - NumMessages: 81, + NumMessages: 82, NumExtensions: 0, NumServices: 0, }, diff --git a/sdks/go/src/parser.go b/sdks/go/src/parser.go index 7d36dc42..401dc3db 100644 --- a/sdks/go/src/parser.go +++ b/sdks/go/src/parser.go @@ -668,211 +668,211 @@ func toPascalCase(s string) string { // --- Helper functions --- func (p *Parser) _extract_value_int32(value *pb.Value, default_ int64) int32 { - var _t2232 interface{} + var _t2246 interface{} if value == nil { return int32(default_) } - _ = _t2232 - var _t2233 interface{} + _ = _t2246 + var _t2247 interface{} if hasProtoField(value, "int32_value") { return value.GetInt32Value() } - _ = _t2233 + _ = _t2247 panic(ParseError{msg: "expected an int32 value (e.g. `1i32`) for this config field"}) } func (p *Parser) _extract_value_int64(value *pb.Value, default_ int64) int64 { - var _t2234 interface{} + var _t2248 interface{} if (value != nil && hasProtoField(value, "int_value")) { return value.GetIntValue() } - _ = _t2234 + _ = _t2248 return default_ } func (p *Parser) _extract_value_string(value *pb.Value, default_ string) string { - var _t2235 interface{} + var _t2249 interface{} if (value != nil && hasProtoField(value, "string_value")) { return value.GetStringValue() } - _ = _t2235 + _ = _t2249 return default_ } func (p *Parser) _extract_value_boolean(value *pb.Value, default_ bool) bool { - var _t2236 interface{} + var _t2250 interface{} if (value != nil && hasProtoField(value, "boolean_value")) { return value.GetBooleanValue() } - _ = _t2236 + _ = _t2250 return default_ } func (p *Parser) _extract_value_string_list(value *pb.Value, default_ []string) []string { - var _t2237 interface{} + var _t2251 interface{} if (value != nil && hasProtoField(value, "string_value")) { return []string{value.GetStringValue()} } - _ = _t2237 + _ = _t2251 return default_ } func (p *Parser) _try_extract_value_int64(value *pb.Value) *int64 { - var _t2238 interface{} + var _t2252 interface{} if (value != nil && hasProtoField(value, "int_value")) { return ptr(value.GetIntValue()) } - _ = _t2238 + _ = _t2252 return nil } func (p *Parser) _try_extract_value_float64(value *pb.Value) *float64 { - var _t2239 interface{} + var _t2253 interface{} if (value != nil && hasProtoField(value, "float_value")) { return ptr(value.GetFloatValue()) } - _ = _t2239 + _ = _t2253 return nil } func (p *Parser) _try_extract_value_bytes(value *pb.Value) []byte { - var _t2240 interface{} + var _t2254 interface{} if (value != nil && hasProtoField(value, "string_value")) { return []byte(value.GetStringValue()) } - _ = _t2240 + _ = _t2254 return nil } func (p *Parser) _try_extract_value_uint128(value *pb.Value) *pb.UInt128Value { - var _t2241 interface{} + var _t2255 interface{} if (value != nil && hasProtoField(value, "uint128_value")) { return value.GetUint128Value() } - _ = _t2241 + _ = _t2255 return nil } func (p *Parser) construct_non_cdc_relations(targets []*pb.TargetRelation) *pb.TargetRelations { - _t2242 := &pb.PlainTargets{Targets: targets} - _t2243 := &pb.TargetRelations{Keys: []*pb.NamedColumn{}} - _t2243.Body = &pb.TargetRelations_Plain{Plain: _t2242} - return _t2243 + _t2256 := &pb.PlainTargets{Targets: targets} + _t2257 := &pb.TargetRelations{Keys: []*pb.NamedColumn{}} + _t2257.Body = &pb.TargetRelations_Plain{Plain: _t2256} + return _t2257 } func (p *Parser) construct_cdc_relations(inserts []*pb.TargetRelation, deletes []*pb.TargetRelation) *pb.TargetRelations { - _t2244 := &pb.CDCTargets{Inserts: inserts, Deletes: deletes} - _t2245 := &pb.TargetRelations{Keys: []*pb.NamedColumn{}} - _t2245.Body = &pb.TargetRelations_Cdc{Cdc: _t2244} - return _t2245 + _t2258 := &pb.CDCTargets{Inserts: inserts, Deletes: deletes} + _t2259 := &pb.TargetRelations{Keys: []*pb.NamedColumn{}} + _t2259.Body = &pb.TargetRelations_Cdc{Cdc: _t2258} + return _t2259 } func (p *Parser) construct_relations(keys []interface{}, body *pb.TargetRelations, load_errors_opt *pb.RelationId) *pb.TargetRelations { - var _t2246 interface{} + var _t2260 interface{} if hasProtoField(body, "plain") { - _t2247 := &pb.TargetRelations{Keys: keys[0].([]*pb.NamedColumn), SyntheticKey: keys[1].(bool), LoadErrors: load_errors_opt} - _t2247.Body = &pb.TargetRelations_Plain{Plain: body.GetPlain()} - return _t2247 + _t2261 := &pb.TargetRelations{Keys: keys[0].([]*pb.NamedColumn), SyntheticKey: keys[1].(bool), LoadErrors: load_errors_opt} + _t2261.Body = &pb.TargetRelations_Plain{Plain: body.GetPlain()} + return _t2261 } - _ = _t2246 - _t2248 := &pb.TargetRelations{Keys: keys[0].([]*pb.NamedColumn), SyntheticKey: keys[1].(bool), LoadErrors: load_errors_opt} - _t2248.Body = &pb.TargetRelations_Cdc{Cdc: body.GetCdc()} - return _t2248 + _ = _t2260 + _t2262 := &pb.TargetRelations{Keys: keys[0].([]*pb.NamedColumn), SyntheticKey: keys[1].(bool), LoadErrors: load_errors_opt} + _t2262.Body = &pb.TargetRelations_Cdc{Cdc: body.GetCdc()} + return _t2262 } func (p *Parser) construct_csv_data(locator *pb.CSVLocator, config *pb.CSVConfig, columns_opt []*pb.GNFColumn, relations_opt *pb.TargetRelations, asof string) *pb.CSVData { - _t2249 := columns_opt + _t2263 := columns_opt if columns_opt == nil { - _t2249 = []*pb.GNFColumn{} + _t2263 = []*pb.GNFColumn{} } - _t2250 := &pb.CSVData{Locator: locator, Config: config, Columns: _t2249, Asof: asof, Relations: relations_opt} - return _t2250 + _t2264 := &pb.CSVData{Locator: locator, Config: config, Columns: _t2263, Asof: asof, Relations: relations_opt} + return _t2264 } func (p *Parser) construct_csv_config(config_dict [][]interface{}, storage_integration_opt [][]interface{}) *pb.CSVConfig { config := dictFromList(config_dict) - _t2251 := p._extract_value_int32(dictGetValue(config, "csv_header_row"), 1) - header_row := _t2251 - _t2252 := p._extract_value_int64(dictGetValue(config, "csv_skip"), 0) - skip := _t2252 - _t2253 := p._extract_value_string(dictGetValue(config, "csv_new_line"), "") - new_line := _t2253 - _t2254 := p._extract_value_string(dictGetValue(config, "csv_delimiter"), ",") - delimiter := _t2254 - _t2255 := p._extract_value_string(dictGetValue(config, "csv_quotechar"), "\"") - quotechar := _t2255 - _t2256 := p._extract_value_string(dictGetValue(config, "csv_escapechar"), "\"") - escapechar := _t2256 - _t2257 := p._extract_value_string(dictGetValue(config, "csv_comment"), "") - comment := _t2257 - _t2258 := p._extract_value_string_list(dictGetValue(config, "csv_missing_strings"), []string{}) - missing_strings := _t2258 - _t2259 := p._extract_value_string(dictGetValue(config, "csv_decimal_separator"), ".") - decimal_separator := _t2259 - _t2260 := p._extract_value_string(dictGetValue(config, "csv_encoding"), "utf-8") - encoding := _t2260 - _t2261 := p._extract_value_string(dictGetValue(config, "csv_compression"), "") - compression := _t2261 - _t2262 := p._extract_value_int64(dictGetValue(config, "csv_partition_size_mb"), 0) - partition_size_mb := _t2262 - _t2263 := p.construct_csv_storage_integration(storage_integration_opt) - storage_integration := _t2263 - _t2264 := &pb.CSVConfig{HeaderRow: header_row, Skip: skip, NewLine: new_line, Delimiter: delimiter, Quotechar: quotechar, Escapechar: escapechar, Comment: comment, MissingStrings: missing_strings, DecimalSeparator: decimal_separator, Encoding: encoding, Compression: compression, PartitionSizeMb: partition_size_mb, StorageIntegration: storage_integration} - return _t2264 + _t2265 := p._extract_value_int32(dictGetValue(config, "csv_header_row"), 1) + header_row := _t2265 + _t2266 := p._extract_value_int64(dictGetValue(config, "csv_skip"), 0) + skip := _t2266 + _t2267 := p._extract_value_string(dictGetValue(config, "csv_new_line"), "") + new_line := _t2267 + _t2268 := p._extract_value_string(dictGetValue(config, "csv_delimiter"), ",") + delimiter := _t2268 + _t2269 := p._extract_value_string(dictGetValue(config, "csv_quotechar"), "\"") + quotechar := _t2269 + _t2270 := p._extract_value_string(dictGetValue(config, "csv_escapechar"), "\"") + escapechar := _t2270 + _t2271 := p._extract_value_string(dictGetValue(config, "csv_comment"), "") + comment := _t2271 + _t2272 := p._extract_value_string_list(dictGetValue(config, "csv_missing_strings"), []string{}) + missing_strings := _t2272 + _t2273 := p._extract_value_string(dictGetValue(config, "csv_decimal_separator"), ".") + decimal_separator := _t2273 + _t2274 := p._extract_value_string(dictGetValue(config, "csv_encoding"), "utf-8") + encoding := _t2274 + _t2275 := p._extract_value_string(dictGetValue(config, "csv_compression"), "") + compression := _t2275 + _t2276 := p._extract_value_int64(dictGetValue(config, "csv_partition_size_mb"), 0) + partition_size_mb := _t2276 + _t2277 := p.construct_csv_storage_integration(storage_integration_opt) + storage_integration := _t2277 + _t2278 := &pb.CSVConfig{HeaderRow: header_row, Skip: skip, NewLine: new_line, Delimiter: delimiter, Quotechar: quotechar, Escapechar: escapechar, Comment: comment, MissingStrings: missing_strings, DecimalSeparator: decimal_separator, Encoding: encoding, Compression: compression, PartitionSizeMb: partition_size_mb, StorageIntegration: storage_integration} + return _t2278 } func (p *Parser) construct_csv_storage_integration(storage_integration_opt [][]interface{}) *pb.StorageIntegration { - var _t2265 interface{} + var _t2279 interface{} if storage_integration_opt == nil { return nil } - _ = _t2265 + _ = _t2279 config := dictFromList(storage_integration_opt) - _t2266 := p._extract_value_string(dictGetValue(config, "provider"), "") - _t2267 := p._extract_value_string(dictGetValue(config, "azure_sas_token"), "") - _t2268 := p._extract_value_string(dictGetValue(config, "s3_region"), "") - _t2269 := p._extract_value_string(dictGetValue(config, "s3_access_key_id"), "") - _t2270 := p._extract_value_string(dictGetValue(config, "s3_secret_access_key"), "") - _t2271 := &pb.StorageIntegration{Provider: _t2266, AzureSasToken: _t2267, S3Region: _t2268, S3AccessKeyId: _t2269, S3SecretAccessKey: _t2270} - return _t2271 + _t2280 := p._extract_value_string(dictGetValue(config, "provider"), "") + _t2281 := p._extract_value_string(dictGetValue(config, "azure_sas_token"), "") + _t2282 := p._extract_value_string(dictGetValue(config, "s3_region"), "") + _t2283 := p._extract_value_string(dictGetValue(config, "s3_access_key_id"), "") + _t2284 := p._extract_value_string(dictGetValue(config, "s3_secret_access_key"), "") + _t2285 := &pb.StorageIntegration{Provider: _t2280, AzureSasToken: _t2281, S3Region: _t2282, S3AccessKeyId: _t2283, S3SecretAccessKey: _t2284} + return _t2285 } func (p *Parser) construct_betree_info(key_types []*pb.Type, value_types []*pb.Type, config_dict [][]interface{}) *pb.BeTreeInfo { config := dictFromList(config_dict) - _t2272 := p._try_extract_value_float64(dictGetValue(config, "betree_config_epsilon")) - epsilon := _t2272 - _t2273 := p._try_extract_value_int64(dictGetValue(config, "betree_config_max_pivots")) - max_pivots := _t2273 - _t2274 := p._try_extract_value_int64(dictGetValue(config, "betree_config_max_deltas")) - max_deltas := _t2274 - _t2275 := p._try_extract_value_int64(dictGetValue(config, "betree_config_max_leaf")) - max_leaf := _t2275 - _t2276 := &pb.BeTreeConfig{Epsilon: deref(epsilon, 0.0), MaxPivots: deref(max_pivots, 0), MaxDeltas: deref(max_deltas, 0), MaxLeaf: deref(max_leaf, 0)} - storage_config := _t2276 - _t2277 := p._try_extract_value_uint128(dictGetValue(config, "betree_locator_root_pageid")) - root_pageid := _t2277 - _t2278 := p._try_extract_value_bytes(dictGetValue(config, "betree_locator_inline_data")) - inline_data := _t2278 - _t2279 := p._try_extract_value_int64(dictGetValue(config, "betree_locator_element_count")) - element_count := _t2279 - _t2280 := p._try_extract_value_int64(dictGetValue(config, "betree_locator_tree_height")) - tree_height := _t2280 - _t2281 := &pb.BeTreeLocator{ElementCount: deref(element_count, 0), TreeHeight: deref(tree_height, 0)} + _t2286 := p._try_extract_value_float64(dictGetValue(config, "betree_config_epsilon")) + epsilon := _t2286 + _t2287 := p._try_extract_value_int64(dictGetValue(config, "betree_config_max_pivots")) + max_pivots := _t2287 + _t2288 := p._try_extract_value_int64(dictGetValue(config, "betree_config_max_deltas")) + max_deltas := _t2288 + _t2289 := p._try_extract_value_int64(dictGetValue(config, "betree_config_max_leaf")) + max_leaf := _t2289 + _t2290 := &pb.BeTreeConfig{Epsilon: deref(epsilon, 0.0), MaxPivots: deref(max_pivots, 0), MaxDeltas: deref(max_deltas, 0), MaxLeaf: deref(max_leaf, 0)} + storage_config := _t2290 + _t2291 := p._try_extract_value_uint128(dictGetValue(config, "betree_locator_root_pageid")) + root_pageid := _t2291 + _t2292 := p._try_extract_value_bytes(dictGetValue(config, "betree_locator_inline_data")) + inline_data := _t2292 + _t2293 := p._try_extract_value_int64(dictGetValue(config, "betree_locator_element_count")) + element_count := _t2293 + _t2294 := p._try_extract_value_int64(dictGetValue(config, "betree_locator_tree_height")) + tree_height := _t2294 + _t2295 := &pb.BeTreeLocator{ElementCount: deref(element_count, 0), TreeHeight: deref(tree_height, 0)} if root_pageid != nil { - _t2281.Location = &pb.BeTreeLocator_RootPageid{RootPageid: root_pageid} + _t2295.Location = &pb.BeTreeLocator_RootPageid{RootPageid: root_pageid} } else { - _t2281.Location = &pb.BeTreeLocator_InlineData{InlineData: inline_data} + _t2295.Location = &pb.BeTreeLocator_InlineData{InlineData: inline_data} } - relation_locator := _t2281 - _t2282 := &pb.BeTreeInfo{KeyTypes: key_types, ValueTypes: value_types, StorageConfig: storage_config, RelationLocator: relation_locator} - return _t2282 + relation_locator := _t2295 + _t2296 := &pb.BeTreeInfo{KeyTypes: key_types, ValueTypes: value_types, StorageConfig: storage_config, RelationLocator: relation_locator} + return _t2296 } func (p *Parser) default_configure() *pb.Configure { - _t2283 := &pb.IVMConfig{Level: pb.MaintenanceLevel_MAINTENANCE_LEVEL_OFF} - ivm_config := _t2283 - _t2284 := &pb.Configure{SemanticsVersion: 0, IvmConfig: ivm_config} - return _t2284 + _t2297 := &pb.IVMConfig{Level: pb.MaintenanceLevel_MAINTENANCE_LEVEL_OFF} + ivm_config := _t2297 + _t2298 := &pb.Configure{SemanticsVersion: 0, IvmConfig: ivm_config} + return _t2298 } func (p *Parser) construct_configure(config_dict [][]interface{}) *pb.Configure { @@ -894,10 +894,10 @@ func (p *Parser) construct_configure(config_dict [][]interface{}) *pb.Configure } } } - _t2285 := &pb.IVMConfig{Level: maintenance_level} - ivm_config := _t2285 - _t2286 := p._extract_value_int64(dictGetValue(config, "semantics_version"), 0) - semantics_version := _t2286 + _t2299 := &pb.IVMConfig{Level: maintenance_level} + ivm_config := _t2299 + _t2300 := p._extract_value_int64(dictGetValue(config, "semantics_version"), 0) + semantics_version := _t2300 config_values_pairs := [][]interface{}{} for _, pair := range config_dict { if (pair[0].(string) != "semantics_version" && pair[0].(string) != "ivm.maintenance_level") { @@ -905,4546 +905,4580 @@ func (p *Parser) construct_configure(config_dict [][]interface{}) *pb.Configure } } configuration_values := valueMapFromPairs(config_values_pairs) - _t2287 := &pb.Configure{SemanticsVersion: semantics_version, IvmConfig: ivm_config, ConfigurationValues: configuration_values} - return _t2287 + _t2301 := &pb.Configure{SemanticsVersion: semantics_version, IvmConfig: ivm_config, ConfigurationValues: configuration_values} + return _t2301 } func (p *Parser) construct_export_csv_config(path string, columns []*pb.ExportCSVColumn, config_dict [][]interface{}) *pb.ExportCSVConfig { config := dictFromList(config_dict) - _t2288 := p._extract_value_int64(dictGetValue(config, "partition_size"), 0) - partition_size := _t2288 - _t2289 := p._extract_value_string(dictGetValue(config, "compression"), "") - compression := _t2289 - _t2290 := p._extract_value_boolean(dictGetValue(config, "syntax_header_row"), true) - syntax_header_row := _t2290 - _t2291 := p._extract_value_string(dictGetValue(config, "syntax_missing_string"), "") - syntax_missing_string := _t2291 - _t2292 := p._extract_value_string(dictGetValue(config, "syntax_delim"), ",") - syntax_delim := _t2292 - _t2293 := p._extract_value_string(dictGetValue(config, "syntax_quotechar"), "\"") - syntax_quotechar := _t2293 - _t2294 := p._extract_value_string(dictGetValue(config, "syntax_escapechar"), "\\") - syntax_escapechar := _t2294 - _t2295 := &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 _t2295 + _t2302 := p._extract_value_int64(dictGetValue(config, "partition_size"), 0) + partition_size := _t2302 + _t2303 := p._extract_value_string(dictGetValue(config, "compression"), "") + compression := _t2303 + _t2304 := p._extract_value_boolean(dictGetValue(config, "syntax_header_row"), true) + syntax_header_row := _t2304 + _t2305 := p._extract_value_string(dictGetValue(config, "syntax_missing_string"), "") + syntax_missing_string := _t2305 + _t2306 := p._extract_value_string(dictGetValue(config, "syntax_delim"), ",") + syntax_delim := _t2306 + _t2307 := p._extract_value_string(dictGetValue(config, "syntax_quotechar"), "\"") + syntax_quotechar := _t2307 + _t2308 := p._extract_value_string(dictGetValue(config, "syntax_escapechar"), "\\") + syntax_escapechar := _t2308 + _t2309 := &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 _t2309 } func (p *Parser) construct_export_csv_config_with_location(location []interface{}, csv_source *pb.ExportCSVSource, csv_config *pb.CSVConfig) *pb.ExportCSVConfig { - _t2296 := &pb.ExportCSVConfig{Path: location[0].(string), TransactionOutputName: location[1].(string), CsvSource: csv_source, CsvConfig: csv_config} - return _t2296 + _t2310 := &pb.ExportCSVConfig{Path: location[0].(string), TransactionOutputName: location[1].(string), CsvSource: csv_source, CsvConfig: csv_config} + return _t2310 } 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) - _t2297 := &pb.IcebergCatalogConfig{CatalogUri: catalog_uri, Scope: ptr(deref(scope_opt, "")), Properties: props, AuthProperties: auth_props} - return _t2297 + _t2311 := &pb.IcebergCatalogConfig{CatalogUri: catalog_uri, Scope: ptr(deref(scope_opt, "")), Properties: props, AuthProperties: auth_props} + return _t2311 } 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 { - _t2298 := &pb.IcebergData{Locator: locator, Config: config, Columns: columns, FromSnapshot: ptr(deref(from_snapshot_opt, "")), ToSnapshot: ptr(deref(to_snapshot_opt, "")), ReturnsDelta: returns_delta} - return _t2298 + _t2312 := &pb.IcebergData{Locator: locator, Config: config, Columns: columns, FromSnapshot: ptr(deref(from_snapshot_opt, "")), ToSnapshot: ptr(deref(to_snapshot_opt, "")), ReturnsDelta: returns_delta} + return _t2312 } func (p *Parser) construct_export_iceberg_config_full(locator *pb.IcebergLocator, config *pb.IcebergCatalogConfig, table_def *pb.RelationId, table_property_pairs [][]interface{}, config_dict [][]interface{}) *pb.ExportIcebergConfig { - _t2299 := config_dict + _t2313 := config_dict if config_dict == nil { - _t2299 = [][]interface{}{} - } - cfg := dictFromList(_t2299) - _t2300 := p._extract_value_string(dictGetValue(cfg, "prefix"), "") - prefix := _t2300 - _t2301 := p._extract_value_int64(dictGetValue(cfg, "target_file_size_bytes"), 0) - target_file_size_bytes := _t2301 - _t2302 := p._extract_value_string(dictGetValue(cfg, "compression"), "") - compression := _t2302 + _t2313 = [][]interface{}{} + } + cfg := dictFromList(_t2313) + _t2314 := p._extract_value_string(dictGetValue(cfg, "prefix"), "") + prefix := _t2314 + _t2315 := p._extract_value_int64(dictGetValue(cfg, "target_file_size_bytes"), 0) + target_file_size_bytes := _t2315 + _t2316 := p._extract_value_string(dictGetValue(cfg, "compression"), "") + compression := _t2316 table_props := stringMapFromPairs(table_property_pairs) - _t2303 := &pb.ExportIcebergConfig{Locator: locator, Config: config, TableDef: table_def, Prefix: ptr(prefix), TargetFileSizeBytes: ptr(target_file_size_bytes), Compression: compression, TableProperties: table_props} - return _t2303 + _t2317 := &pb.ExportIcebergConfig{Locator: locator, Config: config, TableDef: table_def, Prefix: ptr(prefix), TargetFileSizeBytes: ptr(target_file_size_bytes), Compression: compression, TableProperties: table_props} + return _t2317 } // --- Parse functions --- func (p *Parser) parse_transaction() *pb.Transaction { - span_start718 := int64(p.spanStart()) + span_start722 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("transaction") - var _t1424 *pb.Configure + var _t1432 *pb.Configure if (p.matchLookaheadLiteral("(", 0) && p.matchLookaheadLiteral("configure", 1)) { - _t1425 := p.parse_configure() - _t1424 = _t1425 + _t1433 := p.parse_configure() + _t1432 = _t1433 } - configure712 := _t1424 - var _t1426 *pb.Sync + configure716 := _t1432 + var _t1434 *pb.Sync if (p.matchLookaheadLiteral("(", 0) && p.matchLookaheadLiteral("sync", 1)) { - _t1427 := p.parse_sync() - _t1426 = _t1427 - } - sync713 := _t1426 - xs714 := []*pb.Epoch{} - cond715 := p.matchLookaheadLiteral("(", 0) - for cond715 { - _t1428 := p.parse_epoch() - item716 := _t1428 - xs714 = append(xs714, item716) - cond715 = p.matchLookaheadLiteral("(", 0) - } - epochs717 := xs714 + _t1435 := p.parse_sync() + _t1434 = _t1435 + } + sync717 := _t1434 + xs718 := []*pb.Epoch{} + cond719 := p.matchLookaheadLiteral("(", 0) + for cond719 { + _t1436 := p.parse_epoch() + item720 := _t1436 + xs718 = append(xs718, item720) + cond719 = p.matchLookaheadLiteral("(", 0) + } + epochs721 := xs718 p.consumeLiteral(")") - _t1429 := p.default_configure() - _t1430 := configure712 - if configure712 == nil { - _t1430 = _t1429 + _t1437 := p.default_configure() + _t1438 := configure716 + if configure716 == nil { + _t1438 = _t1437 } - _t1431 := &pb.Transaction{Epochs: epochs717, Configure: _t1430, Sync: sync713} - result719 := _t1431 - p.recordSpan(int(span_start718), "Transaction") - return result719 + _t1439 := &pb.Transaction{Epochs: epochs721, Configure: _t1438, Sync: sync717} + result723 := _t1439 + p.recordSpan(int(span_start722), "Transaction") + return result723 } func (p *Parser) parse_configure() *pb.Configure { - span_start721 := int64(p.spanStart()) + span_start725 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("configure") - _t1432 := p.parse_config_dict() - config_dict720 := _t1432 + _t1440 := p.parse_config_dict() + config_dict724 := _t1440 p.consumeLiteral(")") - _t1433 := p.construct_configure(config_dict720) - result722 := _t1433 - p.recordSpan(int(span_start721), "Configure") - return result722 + _t1441 := p.construct_configure(config_dict724) + result726 := _t1441 + p.recordSpan(int(span_start725), "Configure") + return result726 } func (p *Parser) parse_config_dict() [][]interface{} { p.consumeLiteral("{") - xs723 := [][]interface{}{} - cond724 := p.matchLookaheadLiteral(":", 0) - for cond724 { - _t1434 := p.parse_config_key_value() - item725 := _t1434 - xs723 = append(xs723, item725) - cond724 = p.matchLookaheadLiteral(":", 0) - } - config_key_values726 := xs723 + xs727 := [][]interface{}{} + cond728 := p.matchLookaheadLiteral(":", 0) + for cond728 { + _t1442 := p.parse_config_key_value() + item729 := _t1442 + xs727 = append(xs727, item729) + cond728 = p.matchLookaheadLiteral(":", 0) + } + config_key_values730 := xs727 p.consumeLiteral("}") - return config_key_values726 + return config_key_values730 } func (p *Parser) parse_config_key_value() []interface{} { p.consumeLiteral(":") - symbol727 := p.consumeTerminal("SYMBOL").Value.str - _t1435 := p.parse_raw_value() - raw_value728 := _t1435 - return []interface{}{symbol727, raw_value728} + symbol731 := p.consumeTerminal("SYMBOL").Value.str + _t1443 := p.parse_raw_value() + raw_value732 := _t1443 + return []interface{}{symbol731, raw_value732} } func (p *Parser) parse_raw_value() *pb.Value { - span_start742 := int64(p.spanStart()) - var _t1436 int64 + span_start746 := int64(p.spanStart()) + var _t1444 int64 if p.matchLookaheadLiteral("true", 0) { - _t1436 = 12 + _t1444 = 12 } else { - var _t1437 int64 + var _t1445 int64 if p.matchLookaheadLiteral("missing", 0) { - _t1437 = 11 + _t1445 = 11 } else { - var _t1438 int64 + var _t1446 int64 if p.matchLookaheadLiteral("false", 0) { - _t1438 = 12 + _t1446 = 12 } else { - var _t1439 int64 + var _t1447 int64 if p.matchLookaheadLiteral("(", 0) { - var _t1440 int64 + var _t1448 int64 if p.matchLookaheadLiteral("datetime", 1) { - _t1440 = 1 + _t1448 = 1 } else { - var _t1441 int64 + var _t1449 int64 if p.matchLookaheadLiteral("date", 1) { - _t1441 = 0 + _t1449 = 0 } else { - _t1441 = -1 + _t1449 = -1 } - _t1440 = _t1441 + _t1448 = _t1449 } - _t1439 = _t1440 + _t1447 = _t1448 } else { - var _t1442 int64 + var _t1450 int64 if p.matchLookaheadTerminal("UINT32", 0) { - _t1442 = 7 + _t1450 = 7 } else { - var _t1443 int64 + var _t1451 int64 if p.matchLookaheadTerminal("UINT128", 0) { - _t1443 = 8 + _t1451 = 8 } else { - var _t1444 int64 + var _t1452 int64 if p.matchLookaheadTerminal("STRING", 0) { - _t1444 = 2 + _t1452 = 2 } else { - var _t1445 int64 + var _t1453 int64 if p.matchLookaheadTerminal("INT32", 0) { - _t1445 = 3 + _t1453 = 3 } else { - var _t1446 int64 + var _t1454 int64 if p.matchLookaheadTerminal("INT128", 0) { - _t1446 = 9 + _t1454 = 9 } else { - var _t1447 int64 + var _t1455 int64 if p.matchLookaheadTerminal("INT", 0) { - _t1447 = 4 + _t1455 = 4 } else { - var _t1448 int64 + var _t1456 int64 if p.matchLookaheadTerminal("FLOAT32", 0) { - _t1448 = 5 + _t1456 = 5 } else { - var _t1449 int64 + var _t1457 int64 if p.matchLookaheadTerminal("FLOAT", 0) { - _t1449 = 6 + _t1457 = 6 } else { - var _t1450 int64 + var _t1458 int64 if p.matchLookaheadTerminal("DECIMAL", 0) { - _t1450 = 10 + _t1458 = 10 } else { - _t1450 = -1 + _t1458 = -1 } - _t1449 = _t1450 + _t1457 = _t1458 } - _t1448 = _t1449 + _t1456 = _t1457 } - _t1447 = _t1448 + _t1455 = _t1456 } - _t1446 = _t1447 + _t1454 = _t1455 } - _t1445 = _t1446 + _t1453 = _t1454 } - _t1444 = _t1445 + _t1452 = _t1453 } - _t1443 = _t1444 + _t1451 = _t1452 } - _t1442 = _t1443 + _t1450 = _t1451 } - _t1439 = _t1442 + _t1447 = _t1450 } - _t1438 = _t1439 + _t1446 = _t1447 } - _t1437 = _t1438 + _t1445 = _t1446 } - _t1436 = _t1437 - } - prediction729 := _t1436 - var _t1451 *pb.Value - if prediction729 == 12 { - _t1452 := p.parse_boolean_value() - boolean_value741 := _t1452 - _t1453 := &pb.Value{} - _t1453.Value = &pb.Value_BooleanValue{BooleanValue: boolean_value741} - _t1451 = _t1453 + _t1444 = _t1445 + } + prediction733 := _t1444 + var _t1459 *pb.Value + if prediction733 == 12 { + _t1460 := p.parse_boolean_value() + boolean_value745 := _t1460 + _t1461 := &pb.Value{} + _t1461.Value = &pb.Value_BooleanValue{BooleanValue: boolean_value745} + _t1459 = _t1461 } else { - var _t1454 *pb.Value - if prediction729 == 11 { + var _t1462 *pb.Value + if prediction733 == 11 { p.consumeLiteral("missing") - _t1455 := &pb.MissingValue{} - _t1456 := &pb.Value{} - _t1456.Value = &pb.Value_MissingValue{MissingValue: _t1455} - _t1454 = _t1456 + _t1463 := &pb.MissingValue{} + _t1464 := &pb.Value{} + _t1464.Value = &pb.Value_MissingValue{MissingValue: _t1463} + _t1462 = _t1464 } else { - var _t1457 *pb.Value - if prediction729 == 10 { - decimal740 := p.consumeTerminal("DECIMAL").Value.decimal - _t1458 := &pb.Value{} - _t1458.Value = &pb.Value_DecimalValue{DecimalValue: decimal740} - _t1457 = _t1458 + var _t1465 *pb.Value + if prediction733 == 10 { + decimal744 := p.consumeTerminal("DECIMAL").Value.decimal + _t1466 := &pb.Value{} + _t1466.Value = &pb.Value_DecimalValue{DecimalValue: decimal744} + _t1465 = _t1466 } else { - var _t1459 *pb.Value - if prediction729 == 9 { - int128739 := p.consumeTerminal("INT128").Value.int128 - _t1460 := &pb.Value{} - _t1460.Value = &pb.Value_Int128Value{Int128Value: int128739} - _t1459 = _t1460 + var _t1467 *pb.Value + if prediction733 == 9 { + int128743 := p.consumeTerminal("INT128").Value.int128 + _t1468 := &pb.Value{} + _t1468.Value = &pb.Value_Int128Value{Int128Value: int128743} + _t1467 = _t1468 } else { - var _t1461 *pb.Value - if prediction729 == 8 { - uint128738 := p.consumeTerminal("UINT128").Value.uint128 - _t1462 := &pb.Value{} - _t1462.Value = &pb.Value_Uint128Value{Uint128Value: uint128738} - _t1461 = _t1462 + var _t1469 *pb.Value + if prediction733 == 8 { + uint128742 := p.consumeTerminal("UINT128").Value.uint128 + _t1470 := &pb.Value{} + _t1470.Value = &pb.Value_Uint128Value{Uint128Value: uint128742} + _t1469 = _t1470 } else { - var _t1463 *pb.Value - if prediction729 == 7 { - uint32737 := p.consumeTerminal("UINT32").Value.u32 - _t1464 := &pb.Value{} - _t1464.Value = &pb.Value_Uint32Value{Uint32Value: uint32737} - _t1463 = _t1464 + var _t1471 *pb.Value + if prediction733 == 7 { + uint32741 := p.consumeTerminal("UINT32").Value.u32 + _t1472 := &pb.Value{} + _t1472.Value = &pb.Value_Uint32Value{Uint32Value: uint32741} + _t1471 = _t1472 } else { - var _t1465 *pb.Value - if prediction729 == 6 { - float736 := p.consumeTerminal("FLOAT").Value.f64 - _t1466 := &pb.Value{} - _t1466.Value = &pb.Value_FloatValue{FloatValue: float736} - _t1465 = _t1466 + var _t1473 *pb.Value + if prediction733 == 6 { + float740 := p.consumeTerminal("FLOAT").Value.f64 + _t1474 := &pb.Value{} + _t1474.Value = &pb.Value_FloatValue{FloatValue: float740} + _t1473 = _t1474 } else { - var _t1467 *pb.Value - if prediction729 == 5 { - float32735 := p.consumeTerminal("FLOAT32").Value.f32 - _t1468 := &pb.Value{} - _t1468.Value = &pb.Value_Float32Value{Float32Value: float32735} - _t1467 = _t1468 + var _t1475 *pb.Value + if prediction733 == 5 { + float32739 := p.consumeTerminal("FLOAT32").Value.f32 + _t1476 := &pb.Value{} + _t1476.Value = &pb.Value_Float32Value{Float32Value: float32739} + _t1475 = _t1476 } else { - var _t1469 *pb.Value - if prediction729 == 4 { - int734 := p.consumeTerminal("INT").Value.i64 - _t1470 := &pb.Value{} - _t1470.Value = &pb.Value_IntValue{IntValue: int734} - _t1469 = _t1470 + var _t1477 *pb.Value + if prediction733 == 4 { + int738 := p.consumeTerminal("INT").Value.i64 + _t1478 := &pb.Value{} + _t1478.Value = &pb.Value_IntValue{IntValue: int738} + _t1477 = _t1478 } else { - var _t1471 *pb.Value - if prediction729 == 3 { - int32733 := p.consumeTerminal("INT32").Value.i32 - _t1472 := &pb.Value{} - _t1472.Value = &pb.Value_Int32Value{Int32Value: int32733} - _t1471 = _t1472 + var _t1479 *pb.Value + if prediction733 == 3 { + int32737 := p.consumeTerminal("INT32").Value.i32 + _t1480 := &pb.Value{} + _t1480.Value = &pb.Value_Int32Value{Int32Value: int32737} + _t1479 = _t1480 } else { - var _t1473 *pb.Value - if prediction729 == 2 { - string732 := p.consumeTerminal("STRING").Value.str - _t1474 := &pb.Value{} - _t1474.Value = &pb.Value_StringValue{StringValue: string732} - _t1473 = _t1474 + var _t1481 *pb.Value + if prediction733 == 2 { + string736 := p.consumeTerminal("STRING").Value.str + _t1482 := &pb.Value{} + _t1482.Value = &pb.Value_StringValue{StringValue: string736} + _t1481 = _t1482 } else { - var _t1475 *pb.Value - if prediction729 == 1 { - _t1476 := p.parse_raw_datetime() - raw_datetime731 := _t1476 - _t1477 := &pb.Value{} - _t1477.Value = &pb.Value_DatetimeValue{DatetimeValue: raw_datetime731} - _t1475 = _t1477 + var _t1483 *pb.Value + if prediction733 == 1 { + _t1484 := p.parse_raw_datetime() + raw_datetime735 := _t1484 + _t1485 := &pb.Value{} + _t1485.Value = &pb.Value_DatetimeValue{DatetimeValue: raw_datetime735} + _t1483 = _t1485 } else { - var _t1478 *pb.Value - if prediction729 == 0 { - _t1479 := p.parse_raw_date() - raw_date730 := _t1479 - _t1480 := &pb.Value{} - _t1480.Value = &pb.Value_DateValue{DateValue: raw_date730} - _t1478 = _t1480 + var _t1486 *pb.Value + if prediction733 == 0 { + _t1487 := p.parse_raw_date() + raw_date734 := _t1487 + _t1488 := &pb.Value{} + _t1488.Value = &pb.Value_DateValue{DateValue: raw_date734} + _t1486 = _t1488 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in raw_value", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1475 = _t1478 + _t1483 = _t1486 } - _t1473 = _t1475 + _t1481 = _t1483 } - _t1471 = _t1473 + _t1479 = _t1481 } - _t1469 = _t1471 + _t1477 = _t1479 } - _t1467 = _t1469 + _t1475 = _t1477 } - _t1465 = _t1467 + _t1473 = _t1475 } - _t1463 = _t1465 + _t1471 = _t1473 } - _t1461 = _t1463 + _t1469 = _t1471 } - _t1459 = _t1461 + _t1467 = _t1469 } - _t1457 = _t1459 + _t1465 = _t1467 } - _t1454 = _t1457 + _t1462 = _t1465 } - _t1451 = _t1454 + _t1459 = _t1462 } - result743 := _t1451 - p.recordSpan(int(span_start742), "Value") - return result743 + result747 := _t1459 + p.recordSpan(int(span_start746), "Value") + return result747 } func (p *Parser) parse_raw_date() *pb.DateValue { - span_start747 := int64(p.spanStart()) + span_start751 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("date") - int744 := p.consumeTerminal("INT").Value.i64 - int_3745 := p.consumeTerminal("INT").Value.i64 - int_4746 := p.consumeTerminal("INT").Value.i64 + int748 := p.consumeTerminal("INT").Value.i64 + int_3749 := p.consumeTerminal("INT").Value.i64 + int_4750 := p.consumeTerminal("INT").Value.i64 p.consumeLiteral(")") - _t1481 := &pb.DateValue{Year: int32(int744), Month: int32(int_3745), Day: int32(int_4746)} - result748 := _t1481 - p.recordSpan(int(span_start747), "DateValue") - return result748 + _t1489 := &pb.DateValue{Year: int32(int748), Month: int32(int_3749), Day: int32(int_4750)} + result752 := _t1489 + p.recordSpan(int(span_start751), "DateValue") + return result752 } func (p *Parser) parse_raw_datetime() *pb.DateTimeValue { - span_start756 := int64(p.spanStart()) + span_start760 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("datetime") - int749 := p.consumeTerminal("INT").Value.i64 - int_3750 := p.consumeTerminal("INT").Value.i64 - int_4751 := p.consumeTerminal("INT").Value.i64 - int_5752 := p.consumeTerminal("INT").Value.i64 - int_6753 := p.consumeTerminal("INT").Value.i64 - int_7754 := p.consumeTerminal("INT").Value.i64 - var _t1482 *int64 + int753 := p.consumeTerminal("INT").Value.i64 + int_3754 := p.consumeTerminal("INT").Value.i64 + int_4755 := p.consumeTerminal("INT").Value.i64 + int_5756 := p.consumeTerminal("INT").Value.i64 + int_6757 := p.consumeTerminal("INT").Value.i64 + int_7758 := p.consumeTerminal("INT").Value.i64 + var _t1490 *int64 if p.matchLookaheadTerminal("INT", 0) { - _t1482 = ptr(p.consumeTerminal("INT").Value.i64) + _t1490 = ptr(p.consumeTerminal("INT").Value.i64) } - int_8755 := _t1482 + int_8759 := _t1490 p.consumeLiteral(")") - _t1483 := &pb.DateTimeValue{Year: int32(int749), Month: int32(int_3750), Day: int32(int_4751), Hour: int32(int_5752), Minute: int32(int_6753), Second: int32(int_7754), Microsecond: int32(deref(int_8755, 0))} - result757 := _t1483 - p.recordSpan(int(span_start756), "DateTimeValue") - return result757 + _t1491 := &pb.DateTimeValue{Year: int32(int753), Month: int32(int_3754), Day: int32(int_4755), Hour: int32(int_5756), Minute: int32(int_6757), Second: int32(int_7758), Microsecond: int32(deref(int_8759, 0))} + result761 := _t1491 + p.recordSpan(int(span_start760), "DateTimeValue") + return result761 } func (p *Parser) parse_boolean_value() bool { - var _t1484 int64 + var _t1492 int64 if p.matchLookaheadLiteral("true", 0) { - _t1484 = 0 + _t1492 = 0 } else { - var _t1485 int64 + var _t1493 int64 if p.matchLookaheadLiteral("false", 0) { - _t1485 = 1 + _t1493 = 1 } else { - _t1485 = -1 + _t1493 = -1 } - _t1484 = _t1485 + _t1492 = _t1493 } - prediction758 := _t1484 - var _t1486 bool - if prediction758 == 1 { + prediction762 := _t1492 + var _t1494 bool + if prediction762 == 1 { p.consumeLiteral("false") - _t1486 = false + _t1494 = false } else { - var _t1487 bool - if prediction758 == 0 { + var _t1495 bool + if prediction762 == 0 { p.consumeLiteral("true") - _t1487 = true + _t1495 = true } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in boolean_value", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1486 = _t1487 + _t1494 = _t1495 } - return _t1486 + return _t1494 } func (p *Parser) parse_sync() *pb.Sync { - span_start763 := int64(p.spanStart()) + span_start767 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("sync") - xs759 := []*pb.FragmentId{} - cond760 := p.matchLookaheadLiteral(":", 0) - for cond760 { - _t1488 := p.parse_fragment_id() - item761 := _t1488 - xs759 = append(xs759, item761) - cond760 = p.matchLookaheadLiteral(":", 0) - } - fragment_ids762 := xs759 + xs763 := []*pb.FragmentId{} + cond764 := p.matchLookaheadLiteral(":", 0) + for cond764 { + _t1496 := p.parse_fragment_id() + item765 := _t1496 + xs763 = append(xs763, item765) + cond764 = p.matchLookaheadLiteral(":", 0) + } + fragment_ids766 := xs763 p.consumeLiteral(")") - _t1489 := &pb.Sync{Fragments: fragment_ids762} - result764 := _t1489 - p.recordSpan(int(span_start763), "Sync") - return result764 + _t1497 := &pb.Sync{Fragments: fragment_ids766} + result768 := _t1497 + p.recordSpan(int(span_start767), "Sync") + return result768 } func (p *Parser) parse_fragment_id() *pb.FragmentId { - span_start766 := int64(p.spanStart()) + span_start770 := int64(p.spanStart()) p.consumeLiteral(":") - symbol765 := p.consumeTerminal("SYMBOL").Value.str - result767 := &pb.FragmentId{Id: []byte(symbol765)} - p.recordSpan(int(span_start766), "FragmentId") - return result767 + symbol769 := p.consumeTerminal("SYMBOL").Value.str + result771 := &pb.FragmentId{Id: []byte(symbol769)} + p.recordSpan(int(span_start770), "FragmentId") + return result771 } func (p *Parser) parse_epoch() *pb.Epoch { - span_start770 := int64(p.spanStart()) + span_start774 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("epoch") - var _t1490 []*pb.Write + var _t1498 []*pb.Write if (p.matchLookaheadLiteral("(", 0) && p.matchLookaheadLiteral("writes", 1)) { - _t1491 := p.parse_epoch_writes() - _t1490 = _t1491 + _t1499 := p.parse_epoch_writes() + _t1498 = _t1499 } - epoch_writes768 := _t1490 - var _t1492 []*pb.Read + epoch_writes772 := _t1498 + var _t1500 []*pb.Read if p.matchLookaheadLiteral("(", 0) { - _t1493 := p.parse_epoch_reads() - _t1492 = _t1493 + _t1501 := p.parse_epoch_reads() + _t1500 = _t1501 } - epoch_reads769 := _t1492 + epoch_reads773 := _t1500 p.consumeLiteral(")") - _t1494 := epoch_writes768 - if epoch_writes768 == nil { - _t1494 = []*pb.Write{} + _t1502 := epoch_writes772 + if epoch_writes772 == nil { + _t1502 = []*pb.Write{} } - _t1495 := epoch_reads769 - if epoch_reads769 == nil { - _t1495 = []*pb.Read{} + _t1503 := epoch_reads773 + if epoch_reads773 == nil { + _t1503 = []*pb.Read{} } - _t1496 := &pb.Epoch{Writes: _t1494, Reads: _t1495} - result771 := _t1496 - p.recordSpan(int(span_start770), "Epoch") - return result771 + _t1504 := &pb.Epoch{Writes: _t1502, Reads: _t1503} + result775 := _t1504 + p.recordSpan(int(span_start774), "Epoch") + return result775 } func (p *Parser) parse_epoch_writes() []*pb.Write { p.consumeLiteral("(") p.consumeLiteral("writes") - xs772 := []*pb.Write{} - cond773 := p.matchLookaheadLiteral("(", 0) - for cond773 { - _t1497 := p.parse_write() - item774 := _t1497 - xs772 = append(xs772, item774) - cond773 = p.matchLookaheadLiteral("(", 0) - } - writes775 := xs772 + xs776 := []*pb.Write{} + cond777 := p.matchLookaheadLiteral("(", 0) + for cond777 { + _t1505 := p.parse_write() + item778 := _t1505 + xs776 = append(xs776, item778) + cond777 = p.matchLookaheadLiteral("(", 0) + } + writes779 := xs776 p.consumeLiteral(")") - return writes775 + return writes779 } func (p *Parser) parse_write() *pb.Write { - span_start781 := int64(p.spanStart()) - var _t1498 int64 + span_start785 := int64(p.spanStart()) + var _t1506 int64 if p.matchLookaheadLiteral("(", 0) { - var _t1499 int64 + var _t1507 int64 if p.matchLookaheadLiteral("undefine", 1) { - _t1499 = 1 + _t1507 = 1 } else { - var _t1500 int64 + var _t1508 int64 if p.matchLookaheadLiteral("snapshot", 1) { - _t1500 = 3 + _t1508 = 3 } else { - var _t1501 int64 + var _t1509 int64 if p.matchLookaheadLiteral("define", 1) { - _t1501 = 0 + _t1509 = 0 } else { - var _t1502 int64 + var _t1510 int64 if p.matchLookaheadLiteral("context", 1) { - _t1502 = 2 + _t1510 = 2 } else { - _t1502 = -1 + _t1510 = -1 } - _t1501 = _t1502 + _t1509 = _t1510 } - _t1500 = _t1501 + _t1508 = _t1509 } - _t1499 = _t1500 + _t1507 = _t1508 } - _t1498 = _t1499 + _t1506 = _t1507 } else { - _t1498 = -1 - } - prediction776 := _t1498 - var _t1503 *pb.Write - if prediction776 == 3 { - _t1504 := p.parse_snapshot() - snapshot780 := _t1504 - _t1505 := &pb.Write{} - _t1505.WriteType = &pb.Write_Snapshot{Snapshot: snapshot780} - _t1503 = _t1505 + _t1506 = -1 + } + prediction780 := _t1506 + var _t1511 *pb.Write + if prediction780 == 3 { + _t1512 := p.parse_snapshot() + snapshot784 := _t1512 + _t1513 := &pb.Write{} + _t1513.WriteType = &pb.Write_Snapshot{Snapshot: snapshot784} + _t1511 = _t1513 } else { - var _t1506 *pb.Write - if prediction776 == 2 { - _t1507 := p.parse_context() - context779 := _t1507 - _t1508 := &pb.Write{} - _t1508.WriteType = &pb.Write_Context{Context: context779} - _t1506 = _t1508 + var _t1514 *pb.Write + if prediction780 == 2 { + _t1515 := p.parse_context() + context783 := _t1515 + _t1516 := &pb.Write{} + _t1516.WriteType = &pb.Write_Context{Context: context783} + _t1514 = _t1516 } else { - var _t1509 *pb.Write - if prediction776 == 1 { - _t1510 := p.parse_undefine() - undefine778 := _t1510 - _t1511 := &pb.Write{} - _t1511.WriteType = &pb.Write_Undefine{Undefine: undefine778} - _t1509 = _t1511 + var _t1517 *pb.Write + if prediction780 == 1 { + _t1518 := p.parse_undefine() + undefine782 := _t1518 + _t1519 := &pb.Write{} + _t1519.WriteType = &pb.Write_Undefine{Undefine: undefine782} + _t1517 = _t1519 } else { - var _t1512 *pb.Write - if prediction776 == 0 { - _t1513 := p.parse_define() - define777 := _t1513 - _t1514 := &pb.Write{} - _t1514.WriteType = &pb.Write_Define{Define: define777} - _t1512 = _t1514 + var _t1520 *pb.Write + if prediction780 == 0 { + _t1521 := p.parse_define() + define781 := _t1521 + _t1522 := &pb.Write{} + _t1522.WriteType = &pb.Write_Define{Define: define781} + _t1520 = _t1522 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in write", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1509 = _t1512 + _t1517 = _t1520 } - _t1506 = _t1509 + _t1514 = _t1517 } - _t1503 = _t1506 + _t1511 = _t1514 } - result782 := _t1503 - p.recordSpan(int(span_start781), "Write") - return result782 + result786 := _t1511 + p.recordSpan(int(span_start785), "Write") + return result786 } func (p *Parser) parse_define() *pb.Define { - span_start784 := int64(p.spanStart()) + span_start788 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("define") - _t1515 := p.parse_fragment() - fragment783 := _t1515 + _t1523 := p.parse_fragment() + fragment787 := _t1523 p.consumeLiteral(")") - _t1516 := &pb.Define{Fragment: fragment783} - result785 := _t1516 - p.recordSpan(int(span_start784), "Define") - return result785 + _t1524 := &pb.Define{Fragment: fragment787} + result789 := _t1524 + p.recordSpan(int(span_start788), "Define") + return result789 } func (p *Parser) parse_fragment() *pb.Fragment { - span_start791 := int64(p.spanStart()) + span_start795 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("fragment") - _t1517 := p.parse_new_fragment_id() - new_fragment_id786 := _t1517 - xs787 := []*pb.Declaration{} - cond788 := p.matchLookaheadLiteral("(", 0) - for cond788 { - _t1518 := p.parse_declaration() - item789 := _t1518 - xs787 = append(xs787, item789) - cond788 = p.matchLookaheadLiteral("(", 0) - } - declarations790 := xs787 + _t1525 := p.parse_new_fragment_id() + new_fragment_id790 := _t1525 + xs791 := []*pb.Declaration{} + cond792 := p.matchLookaheadLiteral("(", 0) + for cond792 { + _t1526 := p.parse_declaration() + item793 := _t1526 + xs791 = append(xs791, item793) + cond792 = p.matchLookaheadLiteral("(", 0) + } + declarations794 := xs791 p.consumeLiteral(")") - result792 := p.constructFragment(new_fragment_id786, declarations790) - p.recordSpan(int(span_start791), "Fragment") - return result792 + result796 := p.constructFragment(new_fragment_id790, declarations794) + p.recordSpan(int(span_start795), "Fragment") + return result796 } func (p *Parser) parse_new_fragment_id() *pb.FragmentId { - span_start794 := int64(p.spanStart()) - _t1519 := p.parse_fragment_id() - fragment_id793 := _t1519 - p.startFragment(fragment_id793) - result795 := fragment_id793 - p.recordSpan(int(span_start794), "FragmentId") - return result795 + span_start798 := int64(p.spanStart()) + _t1527 := p.parse_fragment_id() + fragment_id797 := _t1527 + p.startFragment(fragment_id797) + result799 := fragment_id797 + p.recordSpan(int(span_start798), "FragmentId") + return result799 } func (p *Parser) parse_declaration() *pb.Declaration { - span_start801 := int64(p.spanStart()) - var _t1520 int64 + span_start805 := int64(p.spanStart()) + var _t1528 int64 if p.matchLookaheadLiteral("(", 0) { - var _t1521 int64 + var _t1529 int64 if p.matchLookaheadLiteral("iceberg_data", 1) { - _t1521 = 3 + _t1529 = 3 } else { - var _t1522 int64 + var _t1530 int64 if p.matchLookaheadLiteral("functional_dependency", 1) { - _t1522 = 2 + _t1530 = 2 } else { - var _t1523 int64 + var _t1531 int64 if p.matchLookaheadLiteral("edb", 1) { - _t1523 = 3 + _t1531 = 3 } else { - var _t1524 int64 + var _t1532 int64 if p.matchLookaheadLiteral("def", 1) { - _t1524 = 0 + _t1532 = 0 } else { - var _t1525 int64 + var _t1533 int64 if p.matchLookaheadLiteral("csv_data", 1) { - _t1525 = 3 + _t1533 = 3 } else { - var _t1526 int64 + var _t1534 int64 if p.matchLookaheadLiteral("betree_relation", 1) { - _t1526 = 3 + _t1534 = 3 } else { - var _t1527 int64 + var _t1535 int64 if p.matchLookaheadLiteral("algorithm", 1) { - _t1527 = 1 + _t1535 = 1 } else { - _t1527 = -1 + _t1535 = -1 } - _t1526 = _t1527 + _t1534 = _t1535 } - _t1525 = _t1526 + _t1533 = _t1534 } - _t1524 = _t1525 + _t1532 = _t1533 } - _t1523 = _t1524 + _t1531 = _t1532 } - _t1522 = _t1523 + _t1530 = _t1531 } - _t1521 = _t1522 + _t1529 = _t1530 } - _t1520 = _t1521 + _t1528 = _t1529 } else { - _t1520 = -1 - } - prediction796 := _t1520 - var _t1528 *pb.Declaration - if prediction796 == 3 { - _t1529 := p.parse_data() - data800 := _t1529 - _t1530 := &pb.Declaration{} - _t1530.DeclarationType = &pb.Declaration_Data{Data: data800} - _t1528 = _t1530 + _t1528 = -1 + } + prediction800 := _t1528 + var _t1536 *pb.Declaration + if prediction800 == 3 { + _t1537 := p.parse_data() + data804 := _t1537 + _t1538 := &pb.Declaration{} + _t1538.DeclarationType = &pb.Declaration_Data{Data: data804} + _t1536 = _t1538 } else { - var _t1531 *pb.Declaration - if prediction796 == 2 { - _t1532 := p.parse_constraint() - constraint799 := _t1532 - _t1533 := &pb.Declaration{} - _t1533.DeclarationType = &pb.Declaration_Constraint{Constraint: constraint799} - _t1531 = _t1533 + var _t1539 *pb.Declaration + if prediction800 == 2 { + _t1540 := p.parse_constraint() + constraint803 := _t1540 + _t1541 := &pb.Declaration{} + _t1541.DeclarationType = &pb.Declaration_Constraint{Constraint: constraint803} + _t1539 = _t1541 } else { - var _t1534 *pb.Declaration - if prediction796 == 1 { - _t1535 := p.parse_algorithm() - algorithm798 := _t1535 - _t1536 := &pb.Declaration{} - _t1536.DeclarationType = &pb.Declaration_Algorithm{Algorithm: algorithm798} - _t1534 = _t1536 + var _t1542 *pb.Declaration + if prediction800 == 1 { + _t1543 := p.parse_algorithm() + algorithm802 := _t1543 + _t1544 := &pb.Declaration{} + _t1544.DeclarationType = &pb.Declaration_Algorithm{Algorithm: algorithm802} + _t1542 = _t1544 } else { - var _t1537 *pb.Declaration - if prediction796 == 0 { - _t1538 := p.parse_def() - def797 := _t1538 - _t1539 := &pb.Declaration{} - _t1539.DeclarationType = &pb.Declaration_Def{Def: def797} - _t1537 = _t1539 + var _t1545 *pb.Declaration + if prediction800 == 0 { + _t1546 := p.parse_def() + def801 := _t1546 + _t1547 := &pb.Declaration{} + _t1547.DeclarationType = &pb.Declaration_Def{Def: def801} + _t1545 = _t1547 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in declaration", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1534 = _t1537 + _t1542 = _t1545 } - _t1531 = _t1534 + _t1539 = _t1542 } - _t1528 = _t1531 + _t1536 = _t1539 } - result802 := _t1528 - p.recordSpan(int(span_start801), "Declaration") - return result802 + result806 := _t1536 + p.recordSpan(int(span_start805), "Declaration") + return result806 } func (p *Parser) parse_def() *pb.Def { - span_start806 := int64(p.spanStart()) + span_start810 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("def") - _t1540 := p.parse_relation_id() - relation_id803 := _t1540 - _t1541 := p.parse_abstraction() - abstraction804 := _t1541 - var _t1542 []*pb.Attribute + _t1548 := p.parse_relation_id() + relation_id807 := _t1548 + _t1549 := p.parse_abstraction() + abstraction808 := _t1549 + var _t1550 []*pb.Attribute if p.matchLookaheadLiteral("(", 0) { - _t1543 := p.parse_attrs() - _t1542 = _t1543 + _t1551 := p.parse_attrs() + _t1550 = _t1551 } - attrs805 := _t1542 + attrs809 := _t1550 p.consumeLiteral(")") - _t1544 := attrs805 - if attrs805 == nil { - _t1544 = []*pb.Attribute{} + _t1552 := attrs809 + if attrs809 == nil { + _t1552 = []*pb.Attribute{} } - _t1545 := &pb.Def{Name: relation_id803, Body: abstraction804, Attrs: _t1544} - result807 := _t1545 - p.recordSpan(int(span_start806), "Def") - return result807 + _t1553 := &pb.Def{Name: relation_id807, Body: abstraction808, Attrs: _t1552} + result811 := _t1553 + p.recordSpan(int(span_start810), "Def") + return result811 } func (p *Parser) parse_relation_id() *pb.RelationId { - span_start811 := int64(p.spanStart()) - var _t1546 int64 + span_start815 := int64(p.spanStart()) + var _t1554 int64 if p.matchLookaheadLiteral(":", 0) { - _t1546 = 0 + _t1554 = 0 } else { - var _t1547 int64 + var _t1555 int64 if p.matchLookaheadTerminal("UINT128", 0) { - _t1547 = 1 + _t1555 = 1 } else { - _t1547 = -1 + _t1555 = -1 } - _t1546 = _t1547 - } - prediction808 := _t1546 - var _t1548 *pb.RelationId - if prediction808 == 1 { - uint128810 := p.consumeTerminal("UINT128").Value.uint128 - _ = uint128810 - _t1548 = &pb.RelationId{IdLow: uint128810.Low, IdHigh: uint128810.High} + _t1554 = _t1555 + } + prediction812 := _t1554 + var _t1556 *pb.RelationId + if prediction812 == 1 { + uint128814 := p.consumeTerminal("UINT128").Value.uint128 + _ = uint128814 + _t1556 = &pb.RelationId{IdLow: uint128814.Low, IdHigh: uint128814.High} } else { - var _t1549 *pb.RelationId - if prediction808 == 0 { + var _t1557 *pb.RelationId + if prediction812 == 0 { p.consumeLiteral(":") - symbol809 := p.consumeTerminal("SYMBOL").Value.str - _t1549 = p.relationIdFromString(symbol809) + symbol813 := p.consumeTerminal("SYMBOL").Value.str + _t1557 = p.relationIdFromString(symbol813) } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in relation_id", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1548 = _t1549 + _t1556 = _t1557 } - result812 := _t1548 - p.recordSpan(int(span_start811), "RelationId") - return result812 + result816 := _t1556 + p.recordSpan(int(span_start815), "RelationId") + return result816 } func (p *Parser) parse_abstraction() *pb.Abstraction { - span_start815 := int64(p.spanStart()) + span_start819 := int64(p.spanStart()) p.consumeLiteral("(") - _t1550 := p.parse_bindings() - bindings813 := _t1550 - _t1551 := p.parse_formula() - formula814 := _t1551 + _t1558 := p.parse_bindings() + bindings817 := _t1558 + _t1559 := p.parse_formula() + formula818 := _t1559 p.consumeLiteral(")") - _t1552 := &pb.Abstraction{Vars: listConcat(bindings813[0].([]*pb.Binding), bindings813[1].([]*pb.Binding)), Value: formula814} - result816 := _t1552 - p.recordSpan(int(span_start815), "Abstraction") - return result816 + _t1560 := &pb.Abstraction{Vars: listConcat(bindings817[0].([]*pb.Binding), bindings817[1].([]*pb.Binding)), Value: formula818} + result820 := _t1560 + p.recordSpan(int(span_start819), "Abstraction") + return result820 } func (p *Parser) parse_bindings() []interface{} { p.consumeLiteral("[") - xs817 := []*pb.Binding{} - cond818 := p.matchLookaheadTerminal("SYMBOL", 0) - for cond818 { - _t1553 := p.parse_binding() - item819 := _t1553 - xs817 = append(xs817, item819) - cond818 = p.matchLookaheadTerminal("SYMBOL", 0) - } - bindings820 := xs817 - var _t1554 []*pb.Binding + xs821 := []*pb.Binding{} + cond822 := p.matchLookaheadTerminal("SYMBOL", 0) + for cond822 { + _t1561 := p.parse_binding() + item823 := _t1561 + xs821 = append(xs821, item823) + cond822 = p.matchLookaheadTerminal("SYMBOL", 0) + } + bindings824 := xs821 + var _t1562 []*pb.Binding if p.matchLookaheadLiteral("|", 0) { - _t1555 := p.parse_value_bindings() - _t1554 = _t1555 + _t1563 := p.parse_value_bindings() + _t1562 = _t1563 } - value_bindings821 := _t1554 + value_bindings825 := _t1562 p.consumeLiteral("]") - _t1556 := value_bindings821 - if value_bindings821 == nil { - _t1556 = []*pb.Binding{} + _t1564 := value_bindings825 + if value_bindings825 == nil { + _t1564 = []*pb.Binding{} } - return []interface{}{bindings820, _t1556} + return []interface{}{bindings824, _t1564} } func (p *Parser) parse_binding() *pb.Binding { - span_start824 := int64(p.spanStart()) - symbol822 := p.consumeTerminal("SYMBOL").Value.str + span_start828 := int64(p.spanStart()) + symbol826 := p.consumeTerminal("SYMBOL").Value.str p.consumeLiteral("::") - _t1557 := p.parse_type() - type823 := _t1557 - _t1558 := &pb.Var{Name: symbol822} - _t1559 := &pb.Binding{Var: _t1558, Type: type823} - result825 := _t1559 - p.recordSpan(int(span_start824), "Binding") - return result825 + _t1565 := p.parse_type() + type827 := _t1565 + _t1566 := &pb.Var{Name: symbol826} + _t1567 := &pb.Binding{Var: _t1566, Type: type827} + result829 := _t1567 + p.recordSpan(int(span_start828), "Binding") + return result829 } func (p *Parser) parse_type() *pb.Type { - span_start841 := int64(p.spanStart()) - var _t1560 int64 + span_start846 := int64(p.spanStart()) + var _t1568 int64 if p.matchLookaheadLiteral("UNKNOWN", 0) { - _t1560 = 0 + _t1568 = 0 } else { - var _t1561 int64 + var _t1569 int64 if p.matchLookaheadLiteral("UINT32", 0) { - _t1561 = 13 + _t1569 = 13 } else { - var _t1562 int64 + var _t1570 int64 if p.matchLookaheadLiteral("UINT128", 0) { - _t1562 = 4 + _t1570 = 4 } else { - var _t1563 int64 + var _t1571 int64 if p.matchLookaheadLiteral("STRING", 0) { - _t1563 = 1 + _t1571 = 1 } else { - var _t1564 int64 + var _t1572 int64 if p.matchLookaheadLiteral("MISSING", 0) { - _t1564 = 8 + _t1572 = 8 } else { - var _t1565 int64 + var _t1573 int64 if p.matchLookaheadLiteral("INT32", 0) { - _t1565 = 11 + _t1573 = 11 } else { - var _t1566 int64 + var _t1574 int64 if p.matchLookaheadLiteral("INT128", 0) { - _t1566 = 5 + _t1574 = 5 } else { - var _t1567 int64 + var _t1575 int64 if p.matchLookaheadLiteral("INT", 0) { - _t1567 = 2 + _t1575 = 2 } else { - var _t1568 int64 + var _t1576 int64 if p.matchLookaheadLiteral("FLOAT32", 0) { - _t1568 = 12 + _t1576 = 12 } else { - var _t1569 int64 + var _t1577 int64 if p.matchLookaheadLiteral("FLOAT", 0) { - _t1569 = 3 + _t1577 = 3 } else { - var _t1570 int64 + var _t1578 int64 if p.matchLookaheadLiteral("DATETIME", 0) { - _t1570 = 7 + _t1578 = 7 } else { - var _t1571 int64 + var _t1579 int64 if p.matchLookaheadLiteral("DATE", 0) { - _t1571 = 6 + _t1579 = 6 } else { - var _t1572 int64 + var _t1580 int64 if p.matchLookaheadLiteral("BOOLEAN", 0) { - _t1572 = 10 + _t1580 = 10 } else { - var _t1573 int64 + var _t1581 int64 if p.matchLookaheadLiteral("(", 0) { - _t1573 = 9 + var _t1582 int64 + if p.matchLookaheadLiteral("FIXED", 1) { + _t1582 = 14 + } else { + var _t1583 int64 + if p.matchLookaheadLiteral("DECIMAL", 1) { + _t1583 = 9 + } else { + _t1583 = -1 + } + _t1582 = _t1583 + } + _t1581 = _t1582 } else { - _t1573 = -1 + _t1581 = -1 } - _t1572 = _t1573 + _t1580 = _t1581 } - _t1571 = _t1572 + _t1579 = _t1580 } - _t1570 = _t1571 + _t1578 = _t1579 } - _t1569 = _t1570 + _t1577 = _t1578 } - _t1568 = _t1569 + _t1576 = _t1577 } - _t1567 = _t1568 + _t1575 = _t1576 } - _t1566 = _t1567 + _t1574 = _t1575 } - _t1565 = _t1566 + _t1573 = _t1574 } - _t1564 = _t1565 + _t1572 = _t1573 } - _t1563 = _t1564 + _t1571 = _t1572 } - _t1562 = _t1563 + _t1570 = _t1571 } - _t1561 = _t1562 + _t1569 = _t1570 } - _t1560 = _t1561 - } - prediction826 := _t1560 - var _t1574 *pb.Type - if prediction826 == 13 { - _t1575 := p.parse_uint32_type() - uint32_type840 := _t1575 - _t1576 := &pb.Type{} - _t1576.Type = &pb.Type_Uint32Type{Uint32Type: uint32_type840} - _t1574 = _t1576 + _t1568 = _t1569 + } + prediction830 := _t1568 + var _t1584 *pb.Type + if prediction830 == 14 { + _t1585 := p.parse_fixed_type() + fixed_type845 := _t1585 + _t1586 := &pb.Type{} + _t1586.Type = &pb.Type_FixedType{FixedType: fixed_type845} + _t1584 = _t1586 } else { - var _t1577 *pb.Type - if prediction826 == 12 { - _t1578 := p.parse_float32_type() - float32_type839 := _t1578 - _t1579 := &pb.Type{} - _t1579.Type = &pb.Type_Float32Type{Float32Type: float32_type839} - _t1577 = _t1579 + var _t1587 *pb.Type + if prediction830 == 13 { + _t1588 := p.parse_uint32_type() + uint32_type844 := _t1588 + _t1589 := &pb.Type{} + _t1589.Type = &pb.Type_Uint32Type{Uint32Type: uint32_type844} + _t1587 = _t1589 } else { - var _t1580 *pb.Type - if prediction826 == 11 { - _t1581 := p.parse_int32_type() - int32_type838 := _t1581 - _t1582 := &pb.Type{} - _t1582.Type = &pb.Type_Int32Type{Int32Type: int32_type838} - _t1580 = _t1582 + var _t1590 *pb.Type + if prediction830 == 12 { + _t1591 := p.parse_float32_type() + float32_type843 := _t1591 + _t1592 := &pb.Type{} + _t1592.Type = &pb.Type_Float32Type{Float32Type: float32_type843} + _t1590 = _t1592 } else { - var _t1583 *pb.Type - if prediction826 == 10 { - _t1584 := p.parse_boolean_type() - boolean_type837 := _t1584 - _t1585 := &pb.Type{} - _t1585.Type = &pb.Type_BooleanType{BooleanType: boolean_type837} - _t1583 = _t1585 + var _t1593 *pb.Type + if prediction830 == 11 { + _t1594 := p.parse_int32_type() + int32_type842 := _t1594 + _t1595 := &pb.Type{} + _t1595.Type = &pb.Type_Int32Type{Int32Type: int32_type842} + _t1593 = _t1595 } else { - var _t1586 *pb.Type - if prediction826 == 9 { - _t1587 := p.parse_decimal_type() - decimal_type836 := _t1587 - _t1588 := &pb.Type{} - _t1588.Type = &pb.Type_DecimalType{DecimalType: decimal_type836} - _t1586 = _t1588 + var _t1596 *pb.Type + if prediction830 == 10 { + _t1597 := p.parse_boolean_type() + boolean_type841 := _t1597 + _t1598 := &pb.Type{} + _t1598.Type = &pb.Type_BooleanType{BooleanType: boolean_type841} + _t1596 = _t1598 } else { - var _t1589 *pb.Type - if prediction826 == 8 { - _t1590 := p.parse_missing_type() - missing_type835 := _t1590 - _t1591 := &pb.Type{} - _t1591.Type = &pb.Type_MissingType{MissingType: missing_type835} - _t1589 = _t1591 + var _t1599 *pb.Type + if prediction830 == 9 { + _t1600 := p.parse_decimal_type() + decimal_type840 := _t1600 + _t1601 := &pb.Type{} + _t1601.Type = &pb.Type_DecimalType{DecimalType: decimal_type840} + _t1599 = _t1601 } else { - var _t1592 *pb.Type - if prediction826 == 7 { - _t1593 := p.parse_datetime_type() - datetime_type834 := _t1593 - _t1594 := &pb.Type{} - _t1594.Type = &pb.Type_DatetimeType{DatetimeType: datetime_type834} - _t1592 = _t1594 + var _t1602 *pb.Type + if prediction830 == 8 { + _t1603 := p.parse_missing_type() + missing_type839 := _t1603 + _t1604 := &pb.Type{} + _t1604.Type = &pb.Type_MissingType{MissingType: missing_type839} + _t1602 = _t1604 } else { - var _t1595 *pb.Type - if prediction826 == 6 { - _t1596 := p.parse_date_type() - date_type833 := _t1596 - _t1597 := &pb.Type{} - _t1597.Type = &pb.Type_DateType{DateType: date_type833} - _t1595 = _t1597 + var _t1605 *pb.Type + if prediction830 == 7 { + _t1606 := p.parse_datetime_type() + datetime_type838 := _t1606 + _t1607 := &pb.Type{} + _t1607.Type = &pb.Type_DatetimeType{DatetimeType: datetime_type838} + _t1605 = _t1607 } else { - var _t1598 *pb.Type - if prediction826 == 5 { - _t1599 := p.parse_int128_type() - int128_type832 := _t1599 - _t1600 := &pb.Type{} - _t1600.Type = &pb.Type_Int128Type{Int128Type: int128_type832} - _t1598 = _t1600 + var _t1608 *pb.Type + if prediction830 == 6 { + _t1609 := p.parse_date_type() + date_type837 := _t1609 + _t1610 := &pb.Type{} + _t1610.Type = &pb.Type_DateType{DateType: date_type837} + _t1608 = _t1610 } else { - var _t1601 *pb.Type - if prediction826 == 4 { - _t1602 := p.parse_uint128_type() - uint128_type831 := _t1602 - _t1603 := &pb.Type{} - _t1603.Type = &pb.Type_Uint128Type{Uint128Type: uint128_type831} - _t1601 = _t1603 + var _t1611 *pb.Type + if prediction830 == 5 { + _t1612 := p.parse_int128_type() + int128_type836 := _t1612 + _t1613 := &pb.Type{} + _t1613.Type = &pb.Type_Int128Type{Int128Type: int128_type836} + _t1611 = _t1613 } else { - var _t1604 *pb.Type - if prediction826 == 3 { - _t1605 := p.parse_float_type() - float_type830 := _t1605 - _t1606 := &pb.Type{} - _t1606.Type = &pb.Type_FloatType{FloatType: float_type830} - _t1604 = _t1606 + var _t1614 *pb.Type + if prediction830 == 4 { + _t1615 := p.parse_uint128_type() + uint128_type835 := _t1615 + _t1616 := &pb.Type{} + _t1616.Type = &pb.Type_Uint128Type{Uint128Type: uint128_type835} + _t1614 = _t1616 } else { - var _t1607 *pb.Type - if prediction826 == 2 { - _t1608 := p.parse_int_type() - int_type829 := _t1608 - _t1609 := &pb.Type{} - _t1609.Type = &pb.Type_IntType{IntType: int_type829} - _t1607 = _t1609 + var _t1617 *pb.Type + if prediction830 == 3 { + _t1618 := p.parse_float_type() + float_type834 := _t1618 + _t1619 := &pb.Type{} + _t1619.Type = &pb.Type_FloatType{FloatType: float_type834} + _t1617 = _t1619 } else { - var _t1610 *pb.Type - if prediction826 == 1 { - _t1611 := p.parse_string_type() - string_type828 := _t1611 - _t1612 := &pb.Type{} - _t1612.Type = &pb.Type_StringType{StringType: string_type828} - _t1610 = _t1612 + var _t1620 *pb.Type + if prediction830 == 2 { + _t1621 := p.parse_int_type() + int_type833 := _t1621 + _t1622 := &pb.Type{} + _t1622.Type = &pb.Type_IntType{IntType: int_type833} + _t1620 = _t1622 } else { - var _t1613 *pb.Type - if prediction826 == 0 { - _t1614 := p.parse_unspecified_type() - unspecified_type827 := _t1614 - _t1615 := &pb.Type{} - _t1615.Type = &pb.Type_UnspecifiedType{UnspecifiedType: unspecified_type827} - _t1613 = _t1615 + var _t1623 *pb.Type + if prediction830 == 1 { + _t1624 := p.parse_string_type() + string_type832 := _t1624 + _t1625 := &pb.Type{} + _t1625.Type = &pb.Type_StringType{StringType: string_type832} + _t1623 = _t1625 } else { - panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in type", p.lookahead(0).Type, p.lookahead(0).Value)}) + var _t1626 *pb.Type + if prediction830 == 0 { + _t1627 := p.parse_unspecified_type() + unspecified_type831 := _t1627 + _t1628 := &pb.Type{} + _t1628.Type = &pb.Type_UnspecifiedType{UnspecifiedType: unspecified_type831} + _t1626 = _t1628 + } else { + panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in type", p.lookahead(0).Type, p.lookahead(0).Value)}) + } + _t1623 = _t1626 } - _t1610 = _t1613 + _t1620 = _t1623 } - _t1607 = _t1610 + _t1617 = _t1620 } - _t1604 = _t1607 + _t1614 = _t1617 } - _t1601 = _t1604 + _t1611 = _t1614 } - _t1598 = _t1601 + _t1608 = _t1611 } - _t1595 = _t1598 + _t1605 = _t1608 } - _t1592 = _t1595 + _t1602 = _t1605 } - _t1589 = _t1592 + _t1599 = _t1602 } - _t1586 = _t1589 + _t1596 = _t1599 } - _t1583 = _t1586 + _t1593 = _t1596 } - _t1580 = _t1583 + _t1590 = _t1593 } - _t1577 = _t1580 + _t1587 = _t1590 } - _t1574 = _t1577 + _t1584 = _t1587 } - result842 := _t1574 - p.recordSpan(int(span_start841), "Type") - return result842 + result847 := _t1584 + p.recordSpan(int(span_start846), "Type") + return result847 } func (p *Parser) parse_unspecified_type() *pb.UnspecifiedType { - span_start843 := int64(p.spanStart()) + span_start848 := int64(p.spanStart()) p.consumeLiteral("UNKNOWN") - _t1616 := &pb.UnspecifiedType{} - result844 := _t1616 - p.recordSpan(int(span_start843), "UnspecifiedType") - return result844 + _t1629 := &pb.UnspecifiedType{} + result849 := _t1629 + p.recordSpan(int(span_start848), "UnspecifiedType") + return result849 } func (p *Parser) parse_string_type() *pb.StringType { - span_start845 := int64(p.spanStart()) + span_start850 := int64(p.spanStart()) p.consumeLiteral("STRING") - _t1617 := &pb.StringType{} - result846 := _t1617 - p.recordSpan(int(span_start845), "StringType") - return result846 + _t1630 := &pb.StringType{} + result851 := _t1630 + p.recordSpan(int(span_start850), "StringType") + return result851 } func (p *Parser) parse_int_type() *pb.IntType { - span_start847 := int64(p.spanStart()) + span_start852 := int64(p.spanStart()) p.consumeLiteral("INT") - _t1618 := &pb.IntType{} - result848 := _t1618 - p.recordSpan(int(span_start847), "IntType") - return result848 + _t1631 := &pb.IntType{} + result853 := _t1631 + p.recordSpan(int(span_start852), "IntType") + return result853 } func (p *Parser) parse_float_type() *pb.FloatType { - span_start849 := int64(p.spanStart()) + span_start854 := int64(p.spanStart()) p.consumeLiteral("FLOAT") - _t1619 := &pb.FloatType{} - result850 := _t1619 - p.recordSpan(int(span_start849), "FloatType") - return result850 + _t1632 := &pb.FloatType{} + result855 := _t1632 + p.recordSpan(int(span_start854), "FloatType") + return result855 } func (p *Parser) parse_uint128_type() *pb.UInt128Type { - span_start851 := int64(p.spanStart()) + span_start856 := int64(p.spanStart()) p.consumeLiteral("UINT128") - _t1620 := &pb.UInt128Type{} - result852 := _t1620 - p.recordSpan(int(span_start851), "UInt128Type") - return result852 + _t1633 := &pb.UInt128Type{} + result857 := _t1633 + p.recordSpan(int(span_start856), "UInt128Type") + return result857 } func (p *Parser) parse_int128_type() *pb.Int128Type { - span_start853 := int64(p.spanStart()) + span_start858 := int64(p.spanStart()) p.consumeLiteral("INT128") - _t1621 := &pb.Int128Type{} - result854 := _t1621 - p.recordSpan(int(span_start853), "Int128Type") - return result854 + _t1634 := &pb.Int128Type{} + result859 := _t1634 + p.recordSpan(int(span_start858), "Int128Type") + return result859 } func (p *Parser) parse_date_type() *pb.DateType { - span_start855 := int64(p.spanStart()) + span_start860 := int64(p.spanStart()) p.consumeLiteral("DATE") - _t1622 := &pb.DateType{} - result856 := _t1622 - p.recordSpan(int(span_start855), "DateType") - return result856 + _t1635 := &pb.DateType{} + result861 := _t1635 + p.recordSpan(int(span_start860), "DateType") + return result861 } func (p *Parser) parse_datetime_type() *pb.DateTimeType { - span_start857 := int64(p.spanStart()) + span_start862 := int64(p.spanStart()) p.consumeLiteral("DATETIME") - _t1623 := &pb.DateTimeType{} - result858 := _t1623 - p.recordSpan(int(span_start857), "DateTimeType") - return result858 + _t1636 := &pb.DateTimeType{} + result863 := _t1636 + p.recordSpan(int(span_start862), "DateTimeType") + return result863 } func (p *Parser) parse_missing_type() *pb.MissingType { - span_start859 := int64(p.spanStart()) + span_start864 := int64(p.spanStart()) p.consumeLiteral("MISSING") - _t1624 := &pb.MissingType{} - result860 := _t1624 - p.recordSpan(int(span_start859), "MissingType") - return result860 + _t1637 := &pb.MissingType{} + result865 := _t1637 + p.recordSpan(int(span_start864), "MissingType") + return result865 } func (p *Parser) parse_decimal_type() *pb.DecimalType { - span_start863 := int64(p.spanStart()) + span_start868 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("DECIMAL") - int861 := p.consumeTerminal("INT").Value.i64 - int_3862 := p.consumeTerminal("INT").Value.i64 + int866 := p.consumeTerminal("INT").Value.i64 + int_3867 := p.consumeTerminal("INT").Value.i64 p.consumeLiteral(")") - _t1625 := &pb.DecimalType{Precision: int32(int861), Scale: int32(int_3862)} - result864 := _t1625 - p.recordSpan(int(span_start863), "DecimalType") - return result864 + _t1638 := &pb.DecimalType{Precision: int32(int866), Scale: int32(int_3867)} + result869 := _t1638 + p.recordSpan(int(span_start868), "DecimalType") + return result869 } func (p *Parser) parse_boolean_type() *pb.BooleanType { - span_start865 := int64(p.spanStart()) + span_start870 := int64(p.spanStart()) p.consumeLiteral("BOOLEAN") - _t1626 := &pb.BooleanType{} - result866 := _t1626 - p.recordSpan(int(span_start865), "BooleanType") - return result866 + _t1639 := &pb.BooleanType{} + result871 := _t1639 + p.recordSpan(int(span_start870), "BooleanType") + return result871 } func (p *Parser) parse_int32_type() *pb.Int32Type { - span_start867 := int64(p.spanStart()) + span_start872 := int64(p.spanStart()) p.consumeLiteral("INT32") - _t1627 := &pb.Int32Type{} - result868 := _t1627 - p.recordSpan(int(span_start867), "Int32Type") - return result868 + _t1640 := &pb.Int32Type{} + result873 := _t1640 + p.recordSpan(int(span_start872), "Int32Type") + return result873 } func (p *Parser) parse_float32_type() *pb.Float32Type { - span_start869 := int64(p.spanStart()) + span_start874 := int64(p.spanStart()) p.consumeLiteral("FLOAT32") - _t1628 := &pb.Float32Type{} - result870 := _t1628 - p.recordSpan(int(span_start869), "Float32Type") - return result870 + _t1641 := &pb.Float32Type{} + result875 := _t1641 + p.recordSpan(int(span_start874), "Float32Type") + return result875 } func (p *Parser) parse_uint32_type() *pb.UInt32Type { - span_start871 := int64(p.spanStart()) + span_start876 := int64(p.spanStart()) p.consumeLiteral("UINT32") - _t1629 := &pb.UInt32Type{} - result872 := _t1629 - p.recordSpan(int(span_start871), "UInt32Type") - return result872 + _t1642 := &pb.UInt32Type{} + result877 := _t1642 + p.recordSpan(int(span_start876), "UInt32Type") + return result877 +} + +func (p *Parser) parse_fixed_type() *pb.FixedType { + span_start879 := int64(p.spanStart()) + p.consumeLiteral("(") + p.consumeLiteral("FIXED") + int878 := p.consumeTerminal("INT").Value.i64 + p.consumeLiteral(")") + _t1643 := &pb.FixedType{Length: int32(int878)} + result880 := _t1643 + p.recordSpan(int(span_start879), "FixedType") + return result880 } func (p *Parser) parse_value_bindings() []*pb.Binding { p.consumeLiteral("|") - xs873 := []*pb.Binding{} - cond874 := p.matchLookaheadTerminal("SYMBOL", 0) - for cond874 { - _t1630 := p.parse_binding() - item875 := _t1630 - xs873 = append(xs873, item875) - cond874 = p.matchLookaheadTerminal("SYMBOL", 0) + xs881 := []*pb.Binding{} + cond882 := p.matchLookaheadTerminal("SYMBOL", 0) + for cond882 { + _t1644 := p.parse_binding() + item883 := _t1644 + xs881 = append(xs881, item883) + cond882 = p.matchLookaheadTerminal("SYMBOL", 0) } - bindings876 := xs873 - return bindings876 + bindings884 := xs881 + return bindings884 } func (p *Parser) parse_formula() *pb.Formula { - span_start891 := int64(p.spanStart()) - var _t1631 int64 + span_start899 := int64(p.spanStart()) + var _t1645 int64 if p.matchLookaheadLiteral("(", 0) { - var _t1632 int64 + var _t1646 int64 if p.matchLookaheadLiteral("true", 1) { - _t1632 = 0 + _t1646 = 0 } else { - var _t1633 int64 + var _t1647 int64 if p.matchLookaheadLiteral("relatom", 1) { - _t1633 = 11 + _t1647 = 11 } else { - var _t1634 int64 + var _t1648 int64 if p.matchLookaheadLiteral("reduce", 1) { - _t1634 = 3 + _t1648 = 3 } else { - var _t1635 int64 + var _t1649 int64 if p.matchLookaheadLiteral("primitive", 1) { - _t1635 = 10 + _t1649 = 10 } else { - var _t1636 int64 + var _t1650 int64 if p.matchLookaheadLiteral("pragma", 1) { - _t1636 = 9 + _t1650 = 9 } else { - var _t1637 int64 + var _t1651 int64 if p.matchLookaheadLiteral("or", 1) { - _t1637 = 5 + _t1651 = 5 } else { - var _t1638 int64 + var _t1652 int64 if p.matchLookaheadLiteral("not", 1) { - _t1638 = 6 + _t1652 = 6 } else { - var _t1639 int64 + var _t1653 int64 if p.matchLookaheadLiteral("ffi", 1) { - _t1639 = 7 + _t1653 = 7 } else { - var _t1640 int64 + var _t1654 int64 if p.matchLookaheadLiteral("false", 1) { - _t1640 = 1 + _t1654 = 1 } else { - var _t1641 int64 + var _t1655 int64 if p.matchLookaheadLiteral("exists", 1) { - _t1641 = 2 + _t1655 = 2 } else { - var _t1642 int64 + var _t1656 int64 if p.matchLookaheadLiteral("cast", 1) { - _t1642 = 12 + _t1656 = 12 } else { - var _t1643 int64 + var _t1657 int64 if p.matchLookaheadLiteral("atom", 1) { - _t1643 = 8 + _t1657 = 8 } else { - var _t1644 int64 + var _t1658 int64 if p.matchLookaheadLiteral("and", 1) { - _t1644 = 4 + _t1658 = 4 } else { - var _t1645 int64 + var _t1659 int64 if p.matchLookaheadLiteral(">=", 1) { - _t1645 = 10 + _t1659 = 10 } else { - var _t1646 int64 + var _t1660 int64 if p.matchLookaheadLiteral(">", 1) { - _t1646 = 10 + _t1660 = 10 } else { - var _t1647 int64 + var _t1661 int64 if p.matchLookaheadLiteral("=", 1) { - _t1647 = 10 + _t1661 = 10 } else { - var _t1648 int64 + var _t1662 int64 if p.matchLookaheadLiteral("<=", 1) { - _t1648 = 10 + _t1662 = 10 } else { - var _t1649 int64 + var _t1663 int64 if p.matchLookaheadLiteral("<", 1) { - _t1649 = 10 + _t1663 = 10 } else { - var _t1650 int64 + var _t1664 int64 if p.matchLookaheadLiteral("/", 1) { - _t1650 = 10 + _t1664 = 10 } else { - var _t1651 int64 + var _t1665 int64 if p.matchLookaheadLiteral("-", 1) { - _t1651 = 10 + _t1665 = 10 } else { - var _t1652 int64 + var _t1666 int64 if p.matchLookaheadLiteral("+", 1) { - _t1652 = 10 + _t1666 = 10 } else { - var _t1653 int64 + var _t1667 int64 if p.matchLookaheadLiteral("*", 1) { - _t1653 = 10 + _t1667 = 10 } else { - _t1653 = -1 + _t1667 = -1 } - _t1652 = _t1653 + _t1666 = _t1667 } - _t1651 = _t1652 + _t1665 = _t1666 } - _t1650 = _t1651 + _t1664 = _t1665 } - _t1649 = _t1650 + _t1663 = _t1664 } - _t1648 = _t1649 + _t1662 = _t1663 } - _t1647 = _t1648 + _t1661 = _t1662 } - _t1646 = _t1647 + _t1660 = _t1661 } - _t1645 = _t1646 + _t1659 = _t1660 } - _t1644 = _t1645 + _t1658 = _t1659 } - _t1643 = _t1644 + _t1657 = _t1658 } - _t1642 = _t1643 + _t1656 = _t1657 } - _t1641 = _t1642 + _t1655 = _t1656 } - _t1640 = _t1641 + _t1654 = _t1655 } - _t1639 = _t1640 + _t1653 = _t1654 } - _t1638 = _t1639 + _t1652 = _t1653 } - _t1637 = _t1638 + _t1651 = _t1652 } - _t1636 = _t1637 + _t1650 = _t1651 } - _t1635 = _t1636 + _t1649 = _t1650 } - _t1634 = _t1635 + _t1648 = _t1649 } - _t1633 = _t1634 + _t1647 = _t1648 } - _t1632 = _t1633 + _t1646 = _t1647 } - _t1631 = _t1632 + _t1645 = _t1646 } else { - _t1631 = -1 - } - prediction877 := _t1631 - var _t1654 *pb.Formula - if prediction877 == 12 { - _t1655 := p.parse_cast() - cast890 := _t1655 - _t1656 := &pb.Formula{} - _t1656.FormulaType = &pb.Formula_Cast{Cast: cast890} - _t1654 = _t1656 + _t1645 = -1 + } + prediction885 := _t1645 + var _t1668 *pb.Formula + if prediction885 == 12 { + _t1669 := p.parse_cast() + cast898 := _t1669 + _t1670 := &pb.Formula{} + _t1670.FormulaType = &pb.Formula_Cast{Cast: cast898} + _t1668 = _t1670 } else { - var _t1657 *pb.Formula - if prediction877 == 11 { - _t1658 := p.parse_rel_atom() - rel_atom889 := _t1658 - _t1659 := &pb.Formula{} - _t1659.FormulaType = &pb.Formula_RelAtom{RelAtom: rel_atom889} - _t1657 = _t1659 + var _t1671 *pb.Formula + if prediction885 == 11 { + _t1672 := p.parse_rel_atom() + rel_atom897 := _t1672 + _t1673 := &pb.Formula{} + _t1673.FormulaType = &pb.Formula_RelAtom{RelAtom: rel_atom897} + _t1671 = _t1673 } else { - var _t1660 *pb.Formula - if prediction877 == 10 { - _t1661 := p.parse_primitive() - primitive888 := _t1661 - _t1662 := &pb.Formula{} - _t1662.FormulaType = &pb.Formula_Primitive{Primitive: primitive888} - _t1660 = _t1662 + var _t1674 *pb.Formula + if prediction885 == 10 { + _t1675 := p.parse_primitive() + primitive896 := _t1675 + _t1676 := &pb.Formula{} + _t1676.FormulaType = &pb.Formula_Primitive{Primitive: primitive896} + _t1674 = _t1676 } else { - var _t1663 *pb.Formula - if prediction877 == 9 { - _t1664 := p.parse_pragma() - pragma887 := _t1664 - _t1665 := &pb.Formula{} - _t1665.FormulaType = &pb.Formula_Pragma{Pragma: pragma887} - _t1663 = _t1665 + var _t1677 *pb.Formula + if prediction885 == 9 { + _t1678 := p.parse_pragma() + pragma895 := _t1678 + _t1679 := &pb.Formula{} + _t1679.FormulaType = &pb.Formula_Pragma{Pragma: pragma895} + _t1677 = _t1679 } else { - var _t1666 *pb.Formula - if prediction877 == 8 { - _t1667 := p.parse_atom() - atom886 := _t1667 - _t1668 := &pb.Formula{} - _t1668.FormulaType = &pb.Formula_Atom{Atom: atom886} - _t1666 = _t1668 + var _t1680 *pb.Formula + if prediction885 == 8 { + _t1681 := p.parse_atom() + atom894 := _t1681 + _t1682 := &pb.Formula{} + _t1682.FormulaType = &pb.Formula_Atom{Atom: atom894} + _t1680 = _t1682 } else { - var _t1669 *pb.Formula - if prediction877 == 7 { - _t1670 := p.parse_ffi() - ffi885 := _t1670 - _t1671 := &pb.Formula{} - _t1671.FormulaType = &pb.Formula_Ffi{Ffi: ffi885} - _t1669 = _t1671 + var _t1683 *pb.Formula + if prediction885 == 7 { + _t1684 := p.parse_ffi() + ffi893 := _t1684 + _t1685 := &pb.Formula{} + _t1685.FormulaType = &pb.Formula_Ffi{Ffi: ffi893} + _t1683 = _t1685 } else { - var _t1672 *pb.Formula - if prediction877 == 6 { - _t1673 := p.parse_not() - not884 := _t1673 - _t1674 := &pb.Formula{} - _t1674.FormulaType = &pb.Formula_Not{Not: not884} - _t1672 = _t1674 + var _t1686 *pb.Formula + if prediction885 == 6 { + _t1687 := p.parse_not() + not892 := _t1687 + _t1688 := &pb.Formula{} + _t1688.FormulaType = &pb.Formula_Not{Not: not892} + _t1686 = _t1688 } else { - var _t1675 *pb.Formula - if prediction877 == 5 { - _t1676 := p.parse_disjunction() - disjunction883 := _t1676 - _t1677 := &pb.Formula{} - _t1677.FormulaType = &pb.Formula_Disjunction{Disjunction: disjunction883} - _t1675 = _t1677 + var _t1689 *pb.Formula + if prediction885 == 5 { + _t1690 := p.parse_disjunction() + disjunction891 := _t1690 + _t1691 := &pb.Formula{} + _t1691.FormulaType = &pb.Formula_Disjunction{Disjunction: disjunction891} + _t1689 = _t1691 } else { - var _t1678 *pb.Formula - if prediction877 == 4 { - _t1679 := p.parse_conjunction() - conjunction882 := _t1679 - _t1680 := &pb.Formula{} - _t1680.FormulaType = &pb.Formula_Conjunction{Conjunction: conjunction882} - _t1678 = _t1680 + var _t1692 *pb.Formula + if prediction885 == 4 { + _t1693 := p.parse_conjunction() + conjunction890 := _t1693 + _t1694 := &pb.Formula{} + _t1694.FormulaType = &pb.Formula_Conjunction{Conjunction: conjunction890} + _t1692 = _t1694 } else { - var _t1681 *pb.Formula - if prediction877 == 3 { - _t1682 := p.parse_reduce() - reduce881 := _t1682 - _t1683 := &pb.Formula{} - _t1683.FormulaType = &pb.Formula_Reduce{Reduce: reduce881} - _t1681 = _t1683 + var _t1695 *pb.Formula + if prediction885 == 3 { + _t1696 := p.parse_reduce() + reduce889 := _t1696 + _t1697 := &pb.Formula{} + _t1697.FormulaType = &pb.Formula_Reduce{Reduce: reduce889} + _t1695 = _t1697 } else { - var _t1684 *pb.Formula - if prediction877 == 2 { - _t1685 := p.parse_exists() - exists880 := _t1685 - _t1686 := &pb.Formula{} - _t1686.FormulaType = &pb.Formula_Exists{Exists: exists880} - _t1684 = _t1686 + var _t1698 *pb.Formula + if prediction885 == 2 { + _t1699 := p.parse_exists() + exists888 := _t1699 + _t1700 := &pb.Formula{} + _t1700.FormulaType = &pb.Formula_Exists{Exists: exists888} + _t1698 = _t1700 } else { - var _t1687 *pb.Formula - if prediction877 == 1 { - _t1688 := p.parse_false() - false879 := _t1688 - _t1689 := &pb.Formula{} - _t1689.FormulaType = &pb.Formula_Disjunction{Disjunction: false879} - _t1687 = _t1689 + var _t1701 *pb.Formula + if prediction885 == 1 { + _t1702 := p.parse_false() + false887 := _t1702 + _t1703 := &pb.Formula{} + _t1703.FormulaType = &pb.Formula_Disjunction{Disjunction: false887} + _t1701 = _t1703 } else { - var _t1690 *pb.Formula - if prediction877 == 0 { - _t1691 := p.parse_true() - true878 := _t1691 - _t1692 := &pb.Formula{} - _t1692.FormulaType = &pb.Formula_Conjunction{Conjunction: true878} - _t1690 = _t1692 + var _t1704 *pb.Formula + if prediction885 == 0 { + _t1705 := p.parse_true() + true886 := _t1705 + _t1706 := &pb.Formula{} + _t1706.FormulaType = &pb.Formula_Conjunction{Conjunction: true886} + _t1704 = _t1706 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in formula", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1687 = _t1690 + _t1701 = _t1704 } - _t1684 = _t1687 + _t1698 = _t1701 } - _t1681 = _t1684 + _t1695 = _t1698 } - _t1678 = _t1681 + _t1692 = _t1695 } - _t1675 = _t1678 + _t1689 = _t1692 } - _t1672 = _t1675 + _t1686 = _t1689 } - _t1669 = _t1672 + _t1683 = _t1686 } - _t1666 = _t1669 + _t1680 = _t1683 } - _t1663 = _t1666 + _t1677 = _t1680 } - _t1660 = _t1663 + _t1674 = _t1677 } - _t1657 = _t1660 + _t1671 = _t1674 } - _t1654 = _t1657 + _t1668 = _t1671 } - result892 := _t1654 - p.recordSpan(int(span_start891), "Formula") - return result892 + result900 := _t1668 + p.recordSpan(int(span_start899), "Formula") + return result900 } func (p *Parser) parse_true() *pb.Conjunction { - span_start893 := int64(p.spanStart()) + span_start901 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("true") p.consumeLiteral(")") - _t1693 := &pb.Conjunction{Args: []*pb.Formula{}} - result894 := _t1693 - p.recordSpan(int(span_start893), "Conjunction") - return result894 + _t1707 := &pb.Conjunction{Args: []*pb.Formula{}} + result902 := _t1707 + p.recordSpan(int(span_start901), "Conjunction") + return result902 } func (p *Parser) parse_false() *pb.Disjunction { - span_start895 := int64(p.spanStart()) + span_start903 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("false") p.consumeLiteral(")") - _t1694 := &pb.Disjunction{Args: []*pb.Formula{}} - result896 := _t1694 - p.recordSpan(int(span_start895), "Disjunction") - return result896 + _t1708 := &pb.Disjunction{Args: []*pb.Formula{}} + result904 := _t1708 + p.recordSpan(int(span_start903), "Disjunction") + return result904 } func (p *Parser) parse_exists() *pb.Exists { - span_start899 := int64(p.spanStart()) + span_start907 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("exists") - _t1695 := p.parse_bindings() - bindings897 := _t1695 - _t1696 := p.parse_formula() - formula898 := _t1696 + _t1709 := p.parse_bindings() + bindings905 := _t1709 + _t1710 := p.parse_formula() + formula906 := _t1710 p.consumeLiteral(")") - _t1697 := &pb.Abstraction{Vars: listConcat(bindings897[0].([]*pb.Binding), bindings897[1].([]*pb.Binding)), Value: formula898} - _t1698 := &pb.Exists{Body: _t1697} - result900 := _t1698 - p.recordSpan(int(span_start899), "Exists") - return result900 + _t1711 := &pb.Abstraction{Vars: listConcat(bindings905[0].([]*pb.Binding), bindings905[1].([]*pb.Binding)), Value: formula906} + _t1712 := &pb.Exists{Body: _t1711} + result908 := _t1712 + p.recordSpan(int(span_start907), "Exists") + return result908 } func (p *Parser) parse_reduce() *pb.Reduce { - span_start904 := int64(p.spanStart()) + span_start912 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("reduce") - _t1699 := p.parse_abstraction() - abstraction901 := _t1699 - _t1700 := p.parse_abstraction() - abstraction_3902 := _t1700 - _t1701 := p.parse_terms() - terms903 := _t1701 + _t1713 := p.parse_abstraction() + abstraction909 := _t1713 + _t1714 := p.parse_abstraction() + abstraction_3910 := _t1714 + _t1715 := p.parse_terms() + terms911 := _t1715 p.consumeLiteral(")") - _t1702 := &pb.Reduce{Op: abstraction901, Body: abstraction_3902, Terms: terms903} - result905 := _t1702 - p.recordSpan(int(span_start904), "Reduce") - return result905 + _t1716 := &pb.Reduce{Op: abstraction909, Body: abstraction_3910, Terms: terms911} + result913 := _t1716 + p.recordSpan(int(span_start912), "Reduce") + return result913 } func (p *Parser) parse_terms() []*pb.Term { p.consumeLiteral("(") p.consumeLiteral("terms") - xs906 := []*pb.Term{} - cond907 := (((((((((((((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 cond907 { - _t1703 := p.parse_term() - item908 := _t1703 - xs906 = append(xs906, item908) - cond907 = (((((((((((((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)) - } - terms909 := xs906 + xs914 := []*pb.Term{} + cond915 := (((((((((((((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 cond915 { + _t1717 := p.parse_term() + item916 := _t1717 + xs914 = append(xs914, item916) + cond915 = (((((((((((((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)) + } + terms917 := xs914 p.consumeLiteral(")") - return terms909 + return terms917 } func (p *Parser) parse_term() *pb.Term { - span_start913 := int64(p.spanStart()) - var _t1704 int64 + span_start921 := int64(p.spanStart()) + var _t1718 int64 if p.matchLookaheadLiteral("true", 0) { - _t1704 = 1 + _t1718 = 1 } else { - var _t1705 int64 + var _t1719 int64 if p.matchLookaheadLiteral("missing", 0) { - _t1705 = 1 + _t1719 = 1 } else { - var _t1706 int64 + var _t1720 int64 if p.matchLookaheadLiteral("false", 0) { - _t1706 = 1 + _t1720 = 1 } else { - var _t1707 int64 + var _t1721 int64 if p.matchLookaheadLiteral("(", 0) { - _t1707 = 1 + _t1721 = 1 } else { - var _t1708 int64 + var _t1722 int64 if p.matchLookaheadTerminal("SYMBOL", 0) { - _t1708 = 0 + _t1722 = 0 } else { - var _t1709 int64 + var _t1723 int64 if p.matchLookaheadTerminal("UINT32", 0) { - _t1709 = 1 + _t1723 = 1 } else { - var _t1710 int64 + var _t1724 int64 if p.matchLookaheadTerminal("UINT128", 0) { - _t1710 = 1 + _t1724 = 1 } else { - var _t1711 int64 + var _t1725 int64 if p.matchLookaheadTerminal("STRING", 0) { - _t1711 = 1 + _t1725 = 1 } else { - var _t1712 int64 + var _t1726 int64 if p.matchLookaheadTerminal("INT32", 0) { - _t1712 = 1 + _t1726 = 1 } else { - var _t1713 int64 + var _t1727 int64 if p.matchLookaheadTerminal("INT128", 0) { - _t1713 = 1 + _t1727 = 1 } else { - var _t1714 int64 + var _t1728 int64 if p.matchLookaheadTerminal("INT", 0) { - _t1714 = 1 + _t1728 = 1 } else { - var _t1715 int64 + var _t1729 int64 if p.matchLookaheadTerminal("FLOAT32", 0) { - _t1715 = 1 + _t1729 = 1 } else { - var _t1716 int64 + var _t1730 int64 if p.matchLookaheadTerminal("FLOAT", 0) { - _t1716 = 1 + _t1730 = 1 } else { - var _t1717 int64 + var _t1731 int64 if p.matchLookaheadTerminal("DECIMAL", 0) { - _t1717 = 1 + _t1731 = 1 } else { - _t1717 = -1 + _t1731 = -1 } - _t1716 = _t1717 + _t1730 = _t1731 } - _t1715 = _t1716 + _t1729 = _t1730 } - _t1714 = _t1715 + _t1728 = _t1729 } - _t1713 = _t1714 + _t1727 = _t1728 } - _t1712 = _t1713 + _t1726 = _t1727 } - _t1711 = _t1712 + _t1725 = _t1726 } - _t1710 = _t1711 + _t1724 = _t1725 } - _t1709 = _t1710 + _t1723 = _t1724 } - _t1708 = _t1709 + _t1722 = _t1723 } - _t1707 = _t1708 + _t1721 = _t1722 } - _t1706 = _t1707 + _t1720 = _t1721 } - _t1705 = _t1706 + _t1719 = _t1720 } - _t1704 = _t1705 - } - prediction910 := _t1704 - var _t1718 *pb.Term - if prediction910 == 1 { - _t1719 := p.parse_value() - value912 := _t1719 - _t1720 := &pb.Term{} - _t1720.TermType = &pb.Term_Constant{Constant: value912} - _t1718 = _t1720 + _t1718 = _t1719 + } + prediction918 := _t1718 + var _t1732 *pb.Term + if prediction918 == 1 { + _t1733 := p.parse_value() + value920 := _t1733 + _t1734 := &pb.Term{} + _t1734.TermType = &pb.Term_Constant{Constant: value920} + _t1732 = _t1734 } else { - var _t1721 *pb.Term - if prediction910 == 0 { - _t1722 := p.parse_var() - var911 := _t1722 - _t1723 := &pb.Term{} - _t1723.TermType = &pb.Term_Var{Var: var911} - _t1721 = _t1723 + var _t1735 *pb.Term + if prediction918 == 0 { + _t1736 := p.parse_var() + var919 := _t1736 + _t1737 := &pb.Term{} + _t1737.TermType = &pb.Term_Var{Var: var919} + _t1735 = _t1737 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in term", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1718 = _t1721 + _t1732 = _t1735 } - result914 := _t1718 - p.recordSpan(int(span_start913), "Term") - return result914 + result922 := _t1732 + p.recordSpan(int(span_start921), "Term") + return result922 } func (p *Parser) parse_var() *pb.Var { - span_start916 := int64(p.spanStart()) - symbol915 := p.consumeTerminal("SYMBOL").Value.str - _t1724 := &pb.Var{Name: symbol915} - result917 := _t1724 - p.recordSpan(int(span_start916), "Var") - return result917 + span_start924 := int64(p.spanStart()) + symbol923 := p.consumeTerminal("SYMBOL").Value.str + _t1738 := &pb.Var{Name: symbol923} + result925 := _t1738 + p.recordSpan(int(span_start924), "Var") + return result925 } func (p *Parser) parse_value() *pb.Value { - span_start931 := int64(p.spanStart()) - var _t1725 int64 + span_start939 := int64(p.spanStart()) + var _t1739 int64 if p.matchLookaheadLiteral("true", 0) { - _t1725 = 12 + _t1739 = 12 } else { - var _t1726 int64 + var _t1740 int64 if p.matchLookaheadLiteral("missing", 0) { - _t1726 = 11 + _t1740 = 11 } else { - var _t1727 int64 + var _t1741 int64 if p.matchLookaheadLiteral("false", 0) { - _t1727 = 12 + _t1741 = 12 } else { - var _t1728 int64 + var _t1742 int64 if p.matchLookaheadLiteral("(", 0) { - var _t1729 int64 + var _t1743 int64 if p.matchLookaheadLiteral("datetime", 1) { - _t1729 = 1 + _t1743 = 1 } else { - var _t1730 int64 + var _t1744 int64 if p.matchLookaheadLiteral("date", 1) { - _t1730 = 0 + _t1744 = 0 } else { - _t1730 = -1 + _t1744 = -1 } - _t1729 = _t1730 + _t1743 = _t1744 } - _t1728 = _t1729 + _t1742 = _t1743 } else { - var _t1731 int64 + var _t1745 int64 if p.matchLookaheadTerminal("UINT32", 0) { - _t1731 = 7 + _t1745 = 7 } else { - var _t1732 int64 + var _t1746 int64 if p.matchLookaheadTerminal("UINT128", 0) { - _t1732 = 8 + _t1746 = 8 } else { - var _t1733 int64 + var _t1747 int64 if p.matchLookaheadTerminal("STRING", 0) { - _t1733 = 2 + _t1747 = 2 } else { - var _t1734 int64 + var _t1748 int64 if p.matchLookaheadTerminal("INT32", 0) { - _t1734 = 3 + _t1748 = 3 } else { - var _t1735 int64 + var _t1749 int64 if p.matchLookaheadTerminal("INT128", 0) { - _t1735 = 9 + _t1749 = 9 } else { - var _t1736 int64 + var _t1750 int64 if p.matchLookaheadTerminal("INT", 0) { - _t1736 = 4 + _t1750 = 4 } else { - var _t1737 int64 + var _t1751 int64 if p.matchLookaheadTerminal("FLOAT32", 0) { - _t1737 = 5 + _t1751 = 5 } else { - var _t1738 int64 + var _t1752 int64 if p.matchLookaheadTerminal("FLOAT", 0) { - _t1738 = 6 + _t1752 = 6 } else { - var _t1739 int64 + var _t1753 int64 if p.matchLookaheadTerminal("DECIMAL", 0) { - _t1739 = 10 + _t1753 = 10 } else { - _t1739 = -1 + _t1753 = -1 } - _t1738 = _t1739 + _t1752 = _t1753 } - _t1737 = _t1738 + _t1751 = _t1752 } - _t1736 = _t1737 + _t1750 = _t1751 } - _t1735 = _t1736 + _t1749 = _t1750 } - _t1734 = _t1735 + _t1748 = _t1749 } - _t1733 = _t1734 + _t1747 = _t1748 } - _t1732 = _t1733 + _t1746 = _t1747 } - _t1731 = _t1732 + _t1745 = _t1746 } - _t1728 = _t1731 + _t1742 = _t1745 } - _t1727 = _t1728 + _t1741 = _t1742 } - _t1726 = _t1727 + _t1740 = _t1741 } - _t1725 = _t1726 - } - prediction918 := _t1725 - var _t1740 *pb.Value - if prediction918 == 12 { - _t1741 := p.parse_boolean_value() - boolean_value930 := _t1741 - _t1742 := &pb.Value{} - _t1742.Value = &pb.Value_BooleanValue{BooleanValue: boolean_value930} - _t1740 = _t1742 + _t1739 = _t1740 + } + prediction926 := _t1739 + var _t1754 *pb.Value + if prediction926 == 12 { + _t1755 := p.parse_boolean_value() + boolean_value938 := _t1755 + _t1756 := &pb.Value{} + _t1756.Value = &pb.Value_BooleanValue{BooleanValue: boolean_value938} + _t1754 = _t1756 } else { - var _t1743 *pb.Value - if prediction918 == 11 { + var _t1757 *pb.Value + if prediction926 == 11 { p.consumeLiteral("missing") - _t1744 := &pb.MissingValue{} - _t1745 := &pb.Value{} - _t1745.Value = &pb.Value_MissingValue{MissingValue: _t1744} - _t1743 = _t1745 + _t1758 := &pb.MissingValue{} + _t1759 := &pb.Value{} + _t1759.Value = &pb.Value_MissingValue{MissingValue: _t1758} + _t1757 = _t1759 } else { - var _t1746 *pb.Value - if prediction918 == 10 { - formatted_decimal929 := p.consumeTerminal("DECIMAL").Value.decimal - _t1747 := &pb.Value{} - _t1747.Value = &pb.Value_DecimalValue{DecimalValue: formatted_decimal929} - _t1746 = _t1747 + var _t1760 *pb.Value + if prediction926 == 10 { + formatted_decimal937 := p.consumeTerminal("DECIMAL").Value.decimal + _t1761 := &pb.Value{} + _t1761.Value = &pb.Value_DecimalValue{DecimalValue: formatted_decimal937} + _t1760 = _t1761 } else { - var _t1748 *pb.Value - if prediction918 == 9 { - formatted_int128928 := p.consumeTerminal("INT128").Value.int128 - _t1749 := &pb.Value{} - _t1749.Value = &pb.Value_Int128Value{Int128Value: formatted_int128928} - _t1748 = _t1749 + var _t1762 *pb.Value + if prediction926 == 9 { + formatted_int128936 := p.consumeTerminal("INT128").Value.int128 + _t1763 := &pb.Value{} + _t1763.Value = &pb.Value_Int128Value{Int128Value: formatted_int128936} + _t1762 = _t1763 } else { - var _t1750 *pb.Value - if prediction918 == 8 { - formatted_uint128927 := p.consumeTerminal("UINT128").Value.uint128 - _t1751 := &pb.Value{} - _t1751.Value = &pb.Value_Uint128Value{Uint128Value: formatted_uint128927} - _t1750 = _t1751 + var _t1764 *pb.Value + if prediction926 == 8 { + formatted_uint128935 := p.consumeTerminal("UINT128").Value.uint128 + _t1765 := &pb.Value{} + _t1765.Value = &pb.Value_Uint128Value{Uint128Value: formatted_uint128935} + _t1764 = _t1765 } else { - var _t1752 *pb.Value - if prediction918 == 7 { - formatted_uint32926 := p.consumeTerminal("UINT32").Value.u32 - _t1753 := &pb.Value{} - _t1753.Value = &pb.Value_Uint32Value{Uint32Value: formatted_uint32926} - _t1752 = _t1753 + var _t1766 *pb.Value + if prediction926 == 7 { + formatted_uint32934 := p.consumeTerminal("UINT32").Value.u32 + _t1767 := &pb.Value{} + _t1767.Value = &pb.Value_Uint32Value{Uint32Value: formatted_uint32934} + _t1766 = _t1767 } else { - var _t1754 *pb.Value - if prediction918 == 6 { - formatted_float925 := p.consumeTerminal("FLOAT").Value.f64 - _t1755 := &pb.Value{} - _t1755.Value = &pb.Value_FloatValue{FloatValue: formatted_float925} - _t1754 = _t1755 + var _t1768 *pb.Value + if prediction926 == 6 { + formatted_float933 := p.consumeTerminal("FLOAT").Value.f64 + _t1769 := &pb.Value{} + _t1769.Value = &pb.Value_FloatValue{FloatValue: formatted_float933} + _t1768 = _t1769 } else { - var _t1756 *pb.Value - if prediction918 == 5 { - formatted_float32924 := p.consumeTerminal("FLOAT32").Value.f32 - _t1757 := &pb.Value{} - _t1757.Value = &pb.Value_Float32Value{Float32Value: formatted_float32924} - _t1756 = _t1757 + var _t1770 *pb.Value + if prediction926 == 5 { + formatted_float32932 := p.consumeTerminal("FLOAT32").Value.f32 + _t1771 := &pb.Value{} + _t1771.Value = &pb.Value_Float32Value{Float32Value: formatted_float32932} + _t1770 = _t1771 } else { - var _t1758 *pb.Value - if prediction918 == 4 { - formatted_int923 := p.consumeTerminal("INT").Value.i64 - _t1759 := &pb.Value{} - _t1759.Value = &pb.Value_IntValue{IntValue: formatted_int923} - _t1758 = _t1759 + var _t1772 *pb.Value + if prediction926 == 4 { + formatted_int931 := p.consumeTerminal("INT").Value.i64 + _t1773 := &pb.Value{} + _t1773.Value = &pb.Value_IntValue{IntValue: formatted_int931} + _t1772 = _t1773 } else { - var _t1760 *pb.Value - if prediction918 == 3 { - formatted_int32922 := p.consumeTerminal("INT32").Value.i32 - _t1761 := &pb.Value{} - _t1761.Value = &pb.Value_Int32Value{Int32Value: formatted_int32922} - _t1760 = _t1761 + var _t1774 *pb.Value + if prediction926 == 3 { + formatted_int32930 := p.consumeTerminal("INT32").Value.i32 + _t1775 := &pb.Value{} + _t1775.Value = &pb.Value_Int32Value{Int32Value: formatted_int32930} + _t1774 = _t1775 } else { - var _t1762 *pb.Value - if prediction918 == 2 { - formatted_string921 := p.consumeTerminal("STRING").Value.str - _t1763 := &pb.Value{} - _t1763.Value = &pb.Value_StringValue{StringValue: formatted_string921} - _t1762 = _t1763 + var _t1776 *pb.Value + if prediction926 == 2 { + formatted_string929 := p.consumeTerminal("STRING").Value.str + _t1777 := &pb.Value{} + _t1777.Value = &pb.Value_StringValue{StringValue: formatted_string929} + _t1776 = _t1777 } else { - var _t1764 *pb.Value - if prediction918 == 1 { - _t1765 := p.parse_datetime() - datetime920 := _t1765 - _t1766 := &pb.Value{} - _t1766.Value = &pb.Value_DatetimeValue{DatetimeValue: datetime920} - _t1764 = _t1766 + var _t1778 *pb.Value + if prediction926 == 1 { + _t1779 := p.parse_datetime() + datetime928 := _t1779 + _t1780 := &pb.Value{} + _t1780.Value = &pb.Value_DatetimeValue{DatetimeValue: datetime928} + _t1778 = _t1780 } else { - var _t1767 *pb.Value - if prediction918 == 0 { - _t1768 := p.parse_date() - date919 := _t1768 - _t1769 := &pb.Value{} - _t1769.Value = &pb.Value_DateValue{DateValue: date919} - _t1767 = _t1769 + var _t1781 *pb.Value + if prediction926 == 0 { + _t1782 := p.parse_date() + date927 := _t1782 + _t1783 := &pb.Value{} + _t1783.Value = &pb.Value_DateValue{DateValue: date927} + _t1781 = _t1783 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in value", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1764 = _t1767 + _t1778 = _t1781 } - _t1762 = _t1764 + _t1776 = _t1778 } - _t1760 = _t1762 + _t1774 = _t1776 } - _t1758 = _t1760 + _t1772 = _t1774 } - _t1756 = _t1758 + _t1770 = _t1772 } - _t1754 = _t1756 + _t1768 = _t1770 } - _t1752 = _t1754 + _t1766 = _t1768 } - _t1750 = _t1752 + _t1764 = _t1766 } - _t1748 = _t1750 + _t1762 = _t1764 } - _t1746 = _t1748 + _t1760 = _t1762 } - _t1743 = _t1746 + _t1757 = _t1760 } - _t1740 = _t1743 + _t1754 = _t1757 } - result932 := _t1740 - p.recordSpan(int(span_start931), "Value") - return result932 + result940 := _t1754 + p.recordSpan(int(span_start939), "Value") + return result940 } func (p *Parser) parse_date() *pb.DateValue { - span_start936 := int64(p.spanStart()) + span_start944 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("date") - formatted_int933 := p.consumeTerminal("INT").Value.i64 - formatted_int_3934 := p.consumeTerminal("INT").Value.i64 - formatted_int_4935 := p.consumeTerminal("INT").Value.i64 + formatted_int941 := p.consumeTerminal("INT").Value.i64 + formatted_int_3942 := p.consumeTerminal("INT").Value.i64 + formatted_int_4943 := p.consumeTerminal("INT").Value.i64 p.consumeLiteral(")") - _t1770 := &pb.DateValue{Year: int32(formatted_int933), Month: int32(formatted_int_3934), Day: int32(formatted_int_4935)} - result937 := _t1770 - p.recordSpan(int(span_start936), "DateValue") - return result937 + _t1784 := &pb.DateValue{Year: int32(formatted_int941), Month: int32(formatted_int_3942), Day: int32(formatted_int_4943)} + result945 := _t1784 + p.recordSpan(int(span_start944), "DateValue") + return result945 } func (p *Parser) parse_datetime() *pb.DateTimeValue { - span_start945 := int64(p.spanStart()) + span_start953 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("datetime") - formatted_int938 := p.consumeTerminal("INT").Value.i64 - formatted_int_3939 := p.consumeTerminal("INT").Value.i64 - formatted_int_4940 := p.consumeTerminal("INT").Value.i64 - formatted_int_5941 := p.consumeTerminal("INT").Value.i64 - formatted_int_6942 := p.consumeTerminal("INT").Value.i64 - formatted_int_7943 := p.consumeTerminal("INT").Value.i64 - var _t1771 *int64 + formatted_int946 := p.consumeTerminal("INT").Value.i64 + formatted_int_3947 := p.consumeTerminal("INT").Value.i64 + formatted_int_4948 := p.consumeTerminal("INT").Value.i64 + formatted_int_5949 := p.consumeTerminal("INT").Value.i64 + formatted_int_6950 := p.consumeTerminal("INT").Value.i64 + formatted_int_7951 := p.consumeTerminal("INT").Value.i64 + var _t1785 *int64 if p.matchLookaheadTerminal("INT", 0) { - _t1771 = ptr(p.consumeTerminal("INT").Value.i64) + _t1785 = ptr(p.consumeTerminal("INT").Value.i64) } - formatted_int_8944 := _t1771 + formatted_int_8952 := _t1785 p.consumeLiteral(")") - _t1772 := &pb.DateTimeValue{Year: int32(formatted_int938), Month: int32(formatted_int_3939), Day: int32(formatted_int_4940), Hour: int32(formatted_int_5941), Minute: int32(formatted_int_6942), Second: int32(formatted_int_7943), Microsecond: int32(deref(formatted_int_8944, 0))} - result946 := _t1772 - p.recordSpan(int(span_start945), "DateTimeValue") - return result946 + _t1786 := &pb.DateTimeValue{Year: int32(formatted_int946), Month: int32(formatted_int_3947), Day: int32(formatted_int_4948), Hour: int32(formatted_int_5949), Minute: int32(formatted_int_6950), Second: int32(formatted_int_7951), Microsecond: int32(deref(formatted_int_8952, 0))} + result954 := _t1786 + p.recordSpan(int(span_start953), "DateTimeValue") + return result954 } func (p *Parser) parse_conjunction() *pb.Conjunction { - span_start951 := int64(p.spanStart()) + span_start959 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("and") - xs947 := []*pb.Formula{} - cond948 := p.matchLookaheadLiteral("(", 0) - for cond948 { - _t1773 := p.parse_formula() - item949 := _t1773 - xs947 = append(xs947, item949) - cond948 = p.matchLookaheadLiteral("(", 0) - } - formulas950 := xs947 + xs955 := []*pb.Formula{} + cond956 := p.matchLookaheadLiteral("(", 0) + for cond956 { + _t1787 := p.parse_formula() + item957 := _t1787 + xs955 = append(xs955, item957) + cond956 = p.matchLookaheadLiteral("(", 0) + } + formulas958 := xs955 p.consumeLiteral(")") - _t1774 := &pb.Conjunction{Args: formulas950} - result952 := _t1774 - p.recordSpan(int(span_start951), "Conjunction") - return result952 + _t1788 := &pb.Conjunction{Args: formulas958} + result960 := _t1788 + p.recordSpan(int(span_start959), "Conjunction") + return result960 } func (p *Parser) parse_disjunction() *pb.Disjunction { - span_start957 := int64(p.spanStart()) + span_start965 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("or") - xs953 := []*pb.Formula{} - cond954 := p.matchLookaheadLiteral("(", 0) - for cond954 { - _t1775 := p.parse_formula() - item955 := _t1775 - xs953 = append(xs953, item955) - cond954 = p.matchLookaheadLiteral("(", 0) - } - formulas956 := xs953 + xs961 := []*pb.Formula{} + cond962 := p.matchLookaheadLiteral("(", 0) + for cond962 { + _t1789 := p.parse_formula() + item963 := _t1789 + xs961 = append(xs961, item963) + cond962 = p.matchLookaheadLiteral("(", 0) + } + formulas964 := xs961 p.consumeLiteral(")") - _t1776 := &pb.Disjunction{Args: formulas956} - result958 := _t1776 - p.recordSpan(int(span_start957), "Disjunction") - return result958 + _t1790 := &pb.Disjunction{Args: formulas964} + result966 := _t1790 + p.recordSpan(int(span_start965), "Disjunction") + return result966 } func (p *Parser) parse_not() *pb.Not { - span_start960 := int64(p.spanStart()) + span_start968 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("not") - _t1777 := p.parse_formula() - formula959 := _t1777 + _t1791 := p.parse_formula() + formula967 := _t1791 p.consumeLiteral(")") - _t1778 := &pb.Not{Arg: formula959} - result961 := _t1778 - p.recordSpan(int(span_start960), "Not") - return result961 + _t1792 := &pb.Not{Arg: formula967} + result969 := _t1792 + p.recordSpan(int(span_start968), "Not") + return result969 } func (p *Parser) parse_ffi() *pb.FFI { - span_start965 := int64(p.spanStart()) + span_start973 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("ffi") - _t1779 := p.parse_name() - name962 := _t1779 - _t1780 := p.parse_ffi_args() - ffi_args963 := _t1780 - _t1781 := p.parse_terms() - terms964 := _t1781 + _t1793 := p.parse_name() + name970 := _t1793 + _t1794 := p.parse_ffi_args() + ffi_args971 := _t1794 + _t1795 := p.parse_terms() + terms972 := _t1795 p.consumeLiteral(")") - _t1782 := &pb.FFI{Name: name962, Args: ffi_args963, Terms: terms964} - result966 := _t1782 - p.recordSpan(int(span_start965), "FFI") - return result966 + _t1796 := &pb.FFI{Name: name970, Args: ffi_args971, Terms: terms972} + result974 := _t1796 + p.recordSpan(int(span_start973), "FFI") + return result974 } func (p *Parser) parse_name() string { p.consumeLiteral(":") - symbol967 := p.consumeTerminal("SYMBOL").Value.str - return symbol967 + symbol975 := p.consumeTerminal("SYMBOL").Value.str + return symbol975 } func (p *Parser) parse_ffi_args() []*pb.Abstraction { p.consumeLiteral("(") p.consumeLiteral("args") - xs968 := []*pb.Abstraction{} - cond969 := p.matchLookaheadLiteral("(", 0) - for cond969 { - _t1783 := p.parse_abstraction() - item970 := _t1783 - xs968 = append(xs968, item970) - cond969 = p.matchLookaheadLiteral("(", 0) - } - abstractions971 := xs968 + xs976 := []*pb.Abstraction{} + cond977 := p.matchLookaheadLiteral("(", 0) + for cond977 { + _t1797 := p.parse_abstraction() + item978 := _t1797 + xs976 = append(xs976, item978) + cond977 = p.matchLookaheadLiteral("(", 0) + } + abstractions979 := xs976 p.consumeLiteral(")") - return abstractions971 + return abstractions979 } func (p *Parser) parse_atom() *pb.Atom { - span_start977 := int64(p.spanStart()) + span_start985 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("atom") - _t1784 := p.parse_relation_id() - relation_id972 := _t1784 - xs973 := []*pb.Term{} - cond974 := (((((((((((((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 cond974 { - _t1785 := p.parse_term() - item975 := _t1785 - xs973 = append(xs973, item975) - cond974 = (((((((((((((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)) - } - terms976 := xs973 + _t1798 := p.parse_relation_id() + relation_id980 := _t1798 + xs981 := []*pb.Term{} + cond982 := (((((((((((((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 cond982 { + _t1799 := p.parse_term() + item983 := _t1799 + xs981 = append(xs981, item983) + cond982 = (((((((((((((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)) + } + terms984 := xs981 p.consumeLiteral(")") - _t1786 := &pb.Atom{Name: relation_id972, Terms: terms976} - result978 := _t1786 - p.recordSpan(int(span_start977), "Atom") - return result978 + _t1800 := &pb.Atom{Name: relation_id980, Terms: terms984} + result986 := _t1800 + p.recordSpan(int(span_start985), "Atom") + return result986 } func (p *Parser) parse_pragma() *pb.Pragma { - span_start984 := int64(p.spanStart()) + span_start992 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("pragma") - _t1787 := p.parse_name() - name979 := _t1787 - xs980 := []*pb.Term{} - cond981 := (((((((((((((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 cond981 { - _t1788 := p.parse_term() - item982 := _t1788 - xs980 = append(xs980, item982) - cond981 = (((((((((((((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)) - } - terms983 := xs980 + _t1801 := p.parse_name() + name987 := _t1801 + xs988 := []*pb.Term{} + cond989 := (((((((((((((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 cond989 { + _t1802 := p.parse_term() + item990 := _t1802 + xs988 = append(xs988, item990) + cond989 = (((((((((((((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)) + } + terms991 := xs988 p.consumeLiteral(")") - _t1789 := &pb.Pragma{Name: name979, Terms: terms983} - result985 := _t1789 - p.recordSpan(int(span_start984), "Pragma") - return result985 + _t1803 := &pb.Pragma{Name: name987, Terms: terms991} + result993 := _t1803 + p.recordSpan(int(span_start992), "Pragma") + return result993 } func (p *Parser) parse_primitive() *pb.Primitive { - span_start1001 := int64(p.spanStart()) - var _t1790 int64 + span_start1009 := int64(p.spanStart()) + var _t1804 int64 if p.matchLookaheadLiteral("(", 0) { - var _t1791 int64 + var _t1805 int64 if p.matchLookaheadLiteral("primitive", 1) { - _t1791 = 9 + _t1805 = 9 } else { - var _t1792 int64 + var _t1806 int64 if p.matchLookaheadLiteral(">=", 1) { - _t1792 = 4 + _t1806 = 4 } else { - var _t1793 int64 + var _t1807 int64 if p.matchLookaheadLiteral(">", 1) { - _t1793 = 3 + _t1807 = 3 } else { - var _t1794 int64 + var _t1808 int64 if p.matchLookaheadLiteral("=", 1) { - _t1794 = 0 + _t1808 = 0 } else { - var _t1795 int64 + var _t1809 int64 if p.matchLookaheadLiteral("<=", 1) { - _t1795 = 2 + _t1809 = 2 } else { - var _t1796 int64 + var _t1810 int64 if p.matchLookaheadLiteral("<", 1) { - _t1796 = 1 + _t1810 = 1 } else { - var _t1797 int64 + var _t1811 int64 if p.matchLookaheadLiteral("/", 1) { - _t1797 = 8 + _t1811 = 8 } else { - var _t1798 int64 + var _t1812 int64 if p.matchLookaheadLiteral("-", 1) { - _t1798 = 6 + _t1812 = 6 } else { - var _t1799 int64 + var _t1813 int64 if p.matchLookaheadLiteral("+", 1) { - _t1799 = 5 + _t1813 = 5 } else { - var _t1800 int64 + var _t1814 int64 if p.matchLookaheadLiteral("*", 1) { - _t1800 = 7 + _t1814 = 7 } else { - _t1800 = -1 + _t1814 = -1 } - _t1799 = _t1800 + _t1813 = _t1814 } - _t1798 = _t1799 + _t1812 = _t1813 } - _t1797 = _t1798 + _t1811 = _t1812 } - _t1796 = _t1797 + _t1810 = _t1811 } - _t1795 = _t1796 + _t1809 = _t1810 } - _t1794 = _t1795 + _t1808 = _t1809 } - _t1793 = _t1794 + _t1807 = _t1808 } - _t1792 = _t1793 + _t1806 = _t1807 } - _t1791 = _t1792 + _t1805 = _t1806 } - _t1790 = _t1791 + _t1804 = _t1805 } else { - _t1790 = -1 + _t1804 = -1 } - prediction986 := _t1790 - var _t1801 *pb.Primitive - if prediction986 == 9 { + prediction994 := _t1804 + var _t1815 *pb.Primitive + if prediction994 == 9 { p.consumeLiteral("(") p.consumeLiteral("primitive") - _t1802 := p.parse_name() - name996 := _t1802 - xs997 := []*pb.RelTerm{} - cond998 := ((((((((((((((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 cond998 { - _t1803 := p.parse_rel_term() - item999 := _t1803 - xs997 = append(xs997, item999) - cond998 = ((((((((((((((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)) + _t1816 := p.parse_name() + name1004 := _t1816 + xs1005 := []*pb.RelTerm{} + cond1006 := ((((((((((((((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 cond1006 { + _t1817 := p.parse_rel_term() + item1007 := _t1817 + xs1005 = append(xs1005, item1007) + cond1006 = ((((((((((((((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_terms1000 := xs997 + rel_terms1008 := xs1005 p.consumeLiteral(")") - _t1804 := &pb.Primitive{Name: name996, Terms: rel_terms1000} - _t1801 = _t1804 + _t1818 := &pb.Primitive{Name: name1004, Terms: rel_terms1008} + _t1815 = _t1818 } else { - var _t1805 *pb.Primitive - if prediction986 == 8 { - _t1806 := p.parse_divide() - divide995 := _t1806 - _t1805 = divide995 + var _t1819 *pb.Primitive + if prediction994 == 8 { + _t1820 := p.parse_divide() + divide1003 := _t1820 + _t1819 = divide1003 } else { - var _t1807 *pb.Primitive - if prediction986 == 7 { - _t1808 := p.parse_multiply() - multiply994 := _t1808 - _t1807 = multiply994 + var _t1821 *pb.Primitive + if prediction994 == 7 { + _t1822 := p.parse_multiply() + multiply1002 := _t1822 + _t1821 = multiply1002 } else { - var _t1809 *pb.Primitive - if prediction986 == 6 { - _t1810 := p.parse_minus() - minus993 := _t1810 - _t1809 = minus993 + var _t1823 *pb.Primitive + if prediction994 == 6 { + _t1824 := p.parse_minus() + minus1001 := _t1824 + _t1823 = minus1001 } else { - var _t1811 *pb.Primitive - if prediction986 == 5 { - _t1812 := p.parse_add() - add992 := _t1812 - _t1811 = add992 + var _t1825 *pb.Primitive + if prediction994 == 5 { + _t1826 := p.parse_add() + add1000 := _t1826 + _t1825 = add1000 } else { - var _t1813 *pb.Primitive - if prediction986 == 4 { - _t1814 := p.parse_gt_eq() - gt_eq991 := _t1814 - _t1813 = gt_eq991 + var _t1827 *pb.Primitive + if prediction994 == 4 { + _t1828 := p.parse_gt_eq() + gt_eq999 := _t1828 + _t1827 = gt_eq999 } else { - var _t1815 *pb.Primitive - if prediction986 == 3 { - _t1816 := p.parse_gt() - gt990 := _t1816 - _t1815 = gt990 + var _t1829 *pb.Primitive + if prediction994 == 3 { + _t1830 := p.parse_gt() + gt998 := _t1830 + _t1829 = gt998 } else { - var _t1817 *pb.Primitive - if prediction986 == 2 { - _t1818 := p.parse_lt_eq() - lt_eq989 := _t1818 - _t1817 = lt_eq989 + var _t1831 *pb.Primitive + if prediction994 == 2 { + _t1832 := p.parse_lt_eq() + lt_eq997 := _t1832 + _t1831 = lt_eq997 } else { - var _t1819 *pb.Primitive - if prediction986 == 1 { - _t1820 := p.parse_lt() - lt988 := _t1820 - _t1819 = lt988 + var _t1833 *pb.Primitive + if prediction994 == 1 { + _t1834 := p.parse_lt() + lt996 := _t1834 + _t1833 = lt996 } else { - var _t1821 *pb.Primitive - if prediction986 == 0 { - _t1822 := p.parse_eq() - eq987 := _t1822 - _t1821 = eq987 + var _t1835 *pb.Primitive + if prediction994 == 0 { + _t1836 := p.parse_eq() + eq995 := _t1836 + _t1835 = eq995 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in primitive", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1819 = _t1821 + _t1833 = _t1835 } - _t1817 = _t1819 + _t1831 = _t1833 } - _t1815 = _t1817 + _t1829 = _t1831 } - _t1813 = _t1815 + _t1827 = _t1829 } - _t1811 = _t1813 + _t1825 = _t1827 } - _t1809 = _t1811 + _t1823 = _t1825 } - _t1807 = _t1809 + _t1821 = _t1823 } - _t1805 = _t1807 + _t1819 = _t1821 } - _t1801 = _t1805 + _t1815 = _t1819 } - result1002 := _t1801 - p.recordSpan(int(span_start1001), "Primitive") - return result1002 -} - -func (p *Parser) parse_eq() *pb.Primitive { - span_start1005 := int64(p.spanStart()) - p.consumeLiteral("(") - p.consumeLiteral("=") - _t1823 := p.parse_term() - term1003 := _t1823 - _t1824 := p.parse_term() - term_31004 := _t1824 - p.consumeLiteral(")") - _t1825 := &pb.RelTerm{} - _t1825.RelTermType = &pb.RelTerm_Term{Term: term1003} - _t1826 := &pb.RelTerm{} - _t1826.RelTermType = &pb.RelTerm_Term{Term: term_31004} - _t1827 := &pb.Primitive{Name: "rel_primitive_eq", Terms: []*pb.RelTerm{_t1825, _t1826}} - result1006 := _t1827 - p.recordSpan(int(span_start1005), "Primitive") - return result1006 -} - -func (p *Parser) parse_lt() *pb.Primitive { - span_start1009 := int64(p.spanStart()) - p.consumeLiteral("(") - p.consumeLiteral("<") - _t1828 := p.parse_term() - term1007 := _t1828 - _t1829 := p.parse_term() - term_31008 := _t1829 - p.consumeLiteral(")") - _t1830 := &pb.RelTerm{} - _t1830.RelTermType = &pb.RelTerm_Term{Term: term1007} - _t1831 := &pb.RelTerm{} - _t1831.RelTermType = &pb.RelTerm_Term{Term: term_31008} - _t1832 := &pb.Primitive{Name: "rel_primitive_lt_monotype", Terms: []*pb.RelTerm{_t1830, _t1831}} - result1010 := _t1832 + result1010 := _t1815 p.recordSpan(int(span_start1009), "Primitive") return result1010 } -func (p *Parser) parse_lt_eq() *pb.Primitive { +func (p *Parser) parse_eq() *pb.Primitive { span_start1013 := int64(p.spanStart()) p.consumeLiteral("(") - p.consumeLiteral("<=") - _t1833 := p.parse_term() - term1011 := _t1833 - _t1834 := p.parse_term() - term_31012 := _t1834 + p.consumeLiteral("=") + _t1837 := p.parse_term() + term1011 := _t1837 + _t1838 := p.parse_term() + term_31012 := _t1838 p.consumeLiteral(")") - _t1835 := &pb.RelTerm{} - _t1835.RelTermType = &pb.RelTerm_Term{Term: term1011} - _t1836 := &pb.RelTerm{} - _t1836.RelTermType = &pb.RelTerm_Term{Term: term_31012} - _t1837 := &pb.Primitive{Name: "rel_primitive_lt_eq_monotype", Terms: []*pb.RelTerm{_t1835, _t1836}} - result1014 := _t1837 + _t1839 := &pb.RelTerm{} + _t1839.RelTermType = &pb.RelTerm_Term{Term: term1011} + _t1840 := &pb.RelTerm{} + _t1840.RelTermType = &pb.RelTerm_Term{Term: term_31012} + _t1841 := &pb.Primitive{Name: "rel_primitive_eq", Terms: []*pb.RelTerm{_t1839, _t1840}} + result1014 := _t1841 p.recordSpan(int(span_start1013), "Primitive") return result1014 } -func (p *Parser) parse_gt() *pb.Primitive { +func (p *Parser) parse_lt() *pb.Primitive { span_start1017 := int64(p.spanStart()) p.consumeLiteral("(") - p.consumeLiteral(">") - _t1838 := p.parse_term() - term1015 := _t1838 - _t1839 := p.parse_term() - term_31016 := _t1839 + p.consumeLiteral("<") + _t1842 := p.parse_term() + term1015 := _t1842 + _t1843 := p.parse_term() + term_31016 := _t1843 p.consumeLiteral(")") - _t1840 := &pb.RelTerm{} - _t1840.RelTermType = &pb.RelTerm_Term{Term: term1015} - _t1841 := &pb.RelTerm{} - _t1841.RelTermType = &pb.RelTerm_Term{Term: term_31016} - _t1842 := &pb.Primitive{Name: "rel_primitive_gt_monotype", Terms: []*pb.RelTerm{_t1840, _t1841}} - result1018 := _t1842 + _t1844 := &pb.RelTerm{} + _t1844.RelTermType = &pb.RelTerm_Term{Term: term1015} + _t1845 := &pb.RelTerm{} + _t1845.RelTermType = &pb.RelTerm_Term{Term: term_31016} + _t1846 := &pb.Primitive{Name: "rel_primitive_lt_monotype", Terms: []*pb.RelTerm{_t1844, _t1845}} + result1018 := _t1846 p.recordSpan(int(span_start1017), "Primitive") return result1018 } -func (p *Parser) parse_gt_eq() *pb.Primitive { +func (p *Parser) parse_lt_eq() *pb.Primitive { span_start1021 := int64(p.spanStart()) p.consumeLiteral("(") - p.consumeLiteral(">=") - _t1843 := p.parse_term() - term1019 := _t1843 - _t1844 := p.parse_term() - term_31020 := _t1844 + p.consumeLiteral("<=") + _t1847 := p.parse_term() + term1019 := _t1847 + _t1848 := p.parse_term() + term_31020 := _t1848 p.consumeLiteral(")") - _t1845 := &pb.RelTerm{} - _t1845.RelTermType = &pb.RelTerm_Term{Term: term1019} - _t1846 := &pb.RelTerm{} - _t1846.RelTermType = &pb.RelTerm_Term{Term: term_31020} - _t1847 := &pb.Primitive{Name: "rel_primitive_gt_eq_monotype", Terms: []*pb.RelTerm{_t1845, _t1846}} - result1022 := _t1847 + _t1849 := &pb.RelTerm{} + _t1849.RelTermType = &pb.RelTerm_Term{Term: term1019} + _t1850 := &pb.RelTerm{} + _t1850.RelTermType = &pb.RelTerm_Term{Term: term_31020} + _t1851 := &pb.Primitive{Name: "rel_primitive_lt_eq_monotype", Terms: []*pb.RelTerm{_t1849, _t1850}} + result1022 := _t1851 p.recordSpan(int(span_start1021), "Primitive") return result1022 } -func (p *Parser) parse_add() *pb.Primitive { - span_start1026 := int64(p.spanStart()) +func (p *Parser) parse_gt() *pb.Primitive { + span_start1025 := int64(p.spanStart()) p.consumeLiteral("(") - p.consumeLiteral("+") - _t1848 := p.parse_term() - term1023 := _t1848 - _t1849 := p.parse_term() - term_31024 := _t1849 - _t1850 := p.parse_term() - term_41025 := _t1850 + p.consumeLiteral(">") + _t1852 := p.parse_term() + term1023 := _t1852 + _t1853 := p.parse_term() + term_31024 := _t1853 p.consumeLiteral(")") - _t1851 := &pb.RelTerm{} - _t1851.RelTermType = &pb.RelTerm_Term{Term: term1023} - _t1852 := &pb.RelTerm{} - _t1852.RelTermType = &pb.RelTerm_Term{Term: term_31024} - _t1853 := &pb.RelTerm{} - _t1853.RelTermType = &pb.RelTerm_Term{Term: term_41025} - _t1854 := &pb.Primitive{Name: "rel_primitive_add_monotype", Terms: []*pb.RelTerm{_t1851, _t1852, _t1853}} - result1027 := _t1854 - p.recordSpan(int(span_start1026), "Primitive") - return result1027 + _t1854 := &pb.RelTerm{} + _t1854.RelTermType = &pb.RelTerm_Term{Term: term1023} + _t1855 := &pb.RelTerm{} + _t1855.RelTermType = &pb.RelTerm_Term{Term: term_31024} + _t1856 := &pb.Primitive{Name: "rel_primitive_gt_monotype", Terms: []*pb.RelTerm{_t1854, _t1855}} + result1026 := _t1856 + p.recordSpan(int(span_start1025), "Primitive") + return result1026 } -func (p *Parser) parse_minus() *pb.Primitive { - span_start1031 := int64(p.spanStart()) +func (p *Parser) parse_gt_eq() *pb.Primitive { + span_start1029 := int64(p.spanStart()) p.consumeLiteral("(") - p.consumeLiteral("-") - _t1855 := p.parse_term() - term1028 := _t1855 - _t1856 := p.parse_term() - term_31029 := _t1856 + p.consumeLiteral(">=") _t1857 := p.parse_term() - term_41030 := _t1857 + term1027 := _t1857 + _t1858 := p.parse_term() + term_31028 := _t1858 p.consumeLiteral(")") - _t1858 := &pb.RelTerm{} - _t1858.RelTermType = &pb.RelTerm_Term{Term: term1028} _t1859 := &pb.RelTerm{} - _t1859.RelTermType = &pb.RelTerm_Term{Term: term_31029} + _t1859.RelTermType = &pb.RelTerm_Term{Term: term1027} _t1860 := &pb.RelTerm{} - _t1860.RelTermType = &pb.RelTerm_Term{Term: term_41030} - _t1861 := &pb.Primitive{Name: "rel_primitive_subtract_monotype", Terms: []*pb.RelTerm{_t1858, _t1859, _t1860}} - result1032 := _t1861 - p.recordSpan(int(span_start1031), "Primitive") - return result1032 + _t1860.RelTermType = &pb.RelTerm_Term{Term: term_31028} + _t1861 := &pb.Primitive{Name: "rel_primitive_gt_eq_monotype", Terms: []*pb.RelTerm{_t1859, _t1860}} + result1030 := _t1861 + p.recordSpan(int(span_start1029), "Primitive") + return result1030 } -func (p *Parser) parse_multiply() *pb.Primitive { - span_start1036 := int64(p.spanStart()) +func (p *Parser) parse_add() *pb.Primitive { + span_start1034 := int64(p.spanStart()) p.consumeLiteral("(") - p.consumeLiteral("*") + p.consumeLiteral("+") _t1862 := p.parse_term() - term1033 := _t1862 + term1031 := _t1862 _t1863 := p.parse_term() - term_31034 := _t1863 + term_31032 := _t1863 _t1864 := p.parse_term() - term_41035 := _t1864 + term_41033 := _t1864 p.consumeLiteral(")") _t1865 := &pb.RelTerm{} - _t1865.RelTermType = &pb.RelTerm_Term{Term: term1033} + _t1865.RelTermType = &pb.RelTerm_Term{Term: term1031} _t1866 := &pb.RelTerm{} - _t1866.RelTermType = &pb.RelTerm_Term{Term: term_31034} + _t1866.RelTermType = &pb.RelTerm_Term{Term: term_31032} _t1867 := &pb.RelTerm{} - _t1867.RelTermType = &pb.RelTerm_Term{Term: term_41035} - _t1868 := &pb.Primitive{Name: "rel_primitive_multiply_monotype", Terms: []*pb.RelTerm{_t1865, _t1866, _t1867}} - result1037 := _t1868 - p.recordSpan(int(span_start1036), "Primitive") - return result1037 + _t1867.RelTermType = &pb.RelTerm_Term{Term: term_41033} + _t1868 := &pb.Primitive{Name: "rel_primitive_add_monotype", Terms: []*pb.RelTerm{_t1865, _t1866, _t1867}} + result1035 := _t1868 + p.recordSpan(int(span_start1034), "Primitive") + return result1035 } -func (p *Parser) parse_divide() *pb.Primitive { - span_start1041 := int64(p.spanStart()) +func (p *Parser) parse_minus() *pb.Primitive { + span_start1039 := int64(p.spanStart()) p.consumeLiteral("(") - p.consumeLiteral("/") + p.consumeLiteral("-") _t1869 := p.parse_term() - term1038 := _t1869 + term1036 := _t1869 _t1870 := p.parse_term() - term_31039 := _t1870 + term_31037 := _t1870 _t1871 := p.parse_term() - term_41040 := _t1871 + term_41038 := _t1871 p.consumeLiteral(")") _t1872 := &pb.RelTerm{} - _t1872.RelTermType = &pb.RelTerm_Term{Term: term1038} + _t1872.RelTermType = &pb.RelTerm_Term{Term: term1036} _t1873 := &pb.RelTerm{} - _t1873.RelTermType = &pb.RelTerm_Term{Term: term_31039} + _t1873.RelTermType = &pb.RelTerm_Term{Term: term_31037} _t1874 := &pb.RelTerm{} - _t1874.RelTermType = &pb.RelTerm_Term{Term: term_41040} - _t1875 := &pb.Primitive{Name: "rel_primitive_divide_monotype", Terms: []*pb.RelTerm{_t1872, _t1873, _t1874}} - result1042 := _t1875 - p.recordSpan(int(span_start1041), "Primitive") - return result1042 + _t1874.RelTermType = &pb.RelTerm_Term{Term: term_41038} + _t1875 := &pb.Primitive{Name: "rel_primitive_subtract_monotype", Terms: []*pb.RelTerm{_t1872, _t1873, _t1874}} + result1040 := _t1875 + p.recordSpan(int(span_start1039), "Primitive") + return result1040 +} + +func (p *Parser) parse_multiply() *pb.Primitive { + span_start1044 := int64(p.spanStart()) + p.consumeLiteral("(") + p.consumeLiteral("*") + _t1876 := p.parse_term() + term1041 := _t1876 + _t1877 := p.parse_term() + term_31042 := _t1877 + _t1878 := p.parse_term() + term_41043 := _t1878 + p.consumeLiteral(")") + _t1879 := &pb.RelTerm{} + _t1879.RelTermType = &pb.RelTerm_Term{Term: term1041} + _t1880 := &pb.RelTerm{} + _t1880.RelTermType = &pb.RelTerm_Term{Term: term_31042} + _t1881 := &pb.RelTerm{} + _t1881.RelTermType = &pb.RelTerm_Term{Term: term_41043} + _t1882 := &pb.Primitive{Name: "rel_primitive_multiply_monotype", Terms: []*pb.RelTerm{_t1879, _t1880, _t1881}} + result1045 := _t1882 + p.recordSpan(int(span_start1044), "Primitive") + return result1045 +} + +func (p *Parser) parse_divide() *pb.Primitive { + span_start1049 := int64(p.spanStart()) + p.consumeLiteral("(") + p.consumeLiteral("/") + _t1883 := p.parse_term() + term1046 := _t1883 + _t1884 := p.parse_term() + term_31047 := _t1884 + _t1885 := p.parse_term() + term_41048 := _t1885 + p.consumeLiteral(")") + _t1886 := &pb.RelTerm{} + _t1886.RelTermType = &pb.RelTerm_Term{Term: term1046} + _t1887 := &pb.RelTerm{} + _t1887.RelTermType = &pb.RelTerm_Term{Term: term_31047} + _t1888 := &pb.RelTerm{} + _t1888.RelTermType = &pb.RelTerm_Term{Term: term_41048} + _t1889 := &pb.Primitive{Name: "rel_primitive_divide_monotype", Terms: []*pb.RelTerm{_t1886, _t1887, _t1888}} + result1050 := _t1889 + p.recordSpan(int(span_start1049), "Primitive") + return result1050 } func (p *Parser) parse_rel_term() *pb.RelTerm { - span_start1046 := int64(p.spanStart()) - var _t1876 int64 + span_start1054 := int64(p.spanStart()) + var _t1890 int64 if p.matchLookaheadLiteral("true", 0) { - _t1876 = 1 + _t1890 = 1 } else { - var _t1877 int64 + var _t1891 int64 if p.matchLookaheadLiteral("missing", 0) { - _t1877 = 1 + _t1891 = 1 } else { - var _t1878 int64 + var _t1892 int64 if p.matchLookaheadLiteral("false", 0) { - _t1878 = 1 + _t1892 = 1 } else { - var _t1879 int64 + var _t1893 int64 if p.matchLookaheadLiteral("(", 0) { - _t1879 = 1 + _t1893 = 1 } else { - var _t1880 int64 + var _t1894 int64 if p.matchLookaheadLiteral("#", 0) { - _t1880 = 0 + _t1894 = 0 } else { - var _t1881 int64 + var _t1895 int64 if p.matchLookaheadTerminal("SYMBOL", 0) { - _t1881 = 1 + _t1895 = 1 } else { - var _t1882 int64 + var _t1896 int64 if p.matchLookaheadTerminal("UINT32", 0) { - _t1882 = 1 + _t1896 = 1 } else { - var _t1883 int64 + var _t1897 int64 if p.matchLookaheadTerminal("UINT128", 0) { - _t1883 = 1 + _t1897 = 1 } else { - var _t1884 int64 + var _t1898 int64 if p.matchLookaheadTerminal("STRING", 0) { - _t1884 = 1 + _t1898 = 1 } else { - var _t1885 int64 + var _t1899 int64 if p.matchLookaheadTerminal("INT32", 0) { - _t1885 = 1 + _t1899 = 1 } else { - var _t1886 int64 + var _t1900 int64 if p.matchLookaheadTerminal("INT128", 0) { - _t1886 = 1 + _t1900 = 1 } else { - var _t1887 int64 + var _t1901 int64 if p.matchLookaheadTerminal("INT", 0) { - _t1887 = 1 + _t1901 = 1 } else { - var _t1888 int64 + var _t1902 int64 if p.matchLookaheadTerminal("FLOAT32", 0) { - _t1888 = 1 + _t1902 = 1 } else { - var _t1889 int64 + var _t1903 int64 if p.matchLookaheadTerminal("FLOAT", 0) { - _t1889 = 1 + _t1903 = 1 } else { - var _t1890 int64 + var _t1904 int64 if p.matchLookaheadTerminal("DECIMAL", 0) { - _t1890 = 1 + _t1904 = 1 } else { - _t1890 = -1 + _t1904 = -1 } - _t1889 = _t1890 + _t1903 = _t1904 } - _t1888 = _t1889 + _t1902 = _t1903 } - _t1887 = _t1888 + _t1901 = _t1902 } - _t1886 = _t1887 + _t1900 = _t1901 } - _t1885 = _t1886 + _t1899 = _t1900 } - _t1884 = _t1885 + _t1898 = _t1899 } - _t1883 = _t1884 + _t1897 = _t1898 } - _t1882 = _t1883 + _t1896 = _t1897 } - _t1881 = _t1882 + _t1895 = _t1896 } - _t1880 = _t1881 + _t1894 = _t1895 } - _t1879 = _t1880 + _t1893 = _t1894 } - _t1878 = _t1879 + _t1892 = _t1893 } - _t1877 = _t1878 + _t1891 = _t1892 } - _t1876 = _t1877 - } - prediction1043 := _t1876 - var _t1891 *pb.RelTerm - if prediction1043 == 1 { - _t1892 := p.parse_term() - term1045 := _t1892 - _t1893 := &pb.RelTerm{} - _t1893.RelTermType = &pb.RelTerm_Term{Term: term1045} - _t1891 = _t1893 + _t1890 = _t1891 + } + prediction1051 := _t1890 + var _t1905 *pb.RelTerm + if prediction1051 == 1 { + _t1906 := p.parse_term() + term1053 := _t1906 + _t1907 := &pb.RelTerm{} + _t1907.RelTermType = &pb.RelTerm_Term{Term: term1053} + _t1905 = _t1907 } else { - var _t1894 *pb.RelTerm - if prediction1043 == 0 { - _t1895 := p.parse_specialized_value() - specialized_value1044 := _t1895 - _t1896 := &pb.RelTerm{} - _t1896.RelTermType = &pb.RelTerm_SpecializedValue{SpecializedValue: specialized_value1044} - _t1894 = _t1896 + var _t1908 *pb.RelTerm + if prediction1051 == 0 { + _t1909 := p.parse_specialized_value() + specialized_value1052 := _t1909 + _t1910 := &pb.RelTerm{} + _t1910.RelTermType = &pb.RelTerm_SpecializedValue{SpecializedValue: specialized_value1052} + _t1908 = _t1910 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in rel_term", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1891 = _t1894 + _t1905 = _t1908 } - result1047 := _t1891 - p.recordSpan(int(span_start1046), "RelTerm") - return result1047 + result1055 := _t1905 + p.recordSpan(int(span_start1054), "RelTerm") + return result1055 } func (p *Parser) parse_specialized_value() *pb.Value { - span_start1049 := int64(p.spanStart()) + span_start1057 := int64(p.spanStart()) p.consumeLiteral("#") - _t1897 := p.parse_raw_value() - raw_value1048 := _t1897 - result1050 := raw_value1048 - p.recordSpan(int(span_start1049), "Value") - return result1050 + _t1911 := p.parse_raw_value() + raw_value1056 := _t1911 + result1058 := raw_value1056 + p.recordSpan(int(span_start1057), "Value") + return result1058 } func (p *Parser) parse_rel_atom() *pb.RelAtom { - span_start1056 := int64(p.spanStart()) + span_start1064 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("relatom") - _t1898 := p.parse_name() - name1051 := _t1898 - xs1052 := []*pb.RelTerm{} - cond1053 := ((((((((((((((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 cond1053 { - _t1899 := p.parse_rel_term() - item1054 := _t1899 - xs1052 = append(xs1052, item1054) - cond1053 = ((((((((((((((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_terms1055 := xs1052 + _t1912 := p.parse_name() + name1059 := _t1912 + xs1060 := []*pb.RelTerm{} + cond1061 := ((((((((((((((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 cond1061 { + _t1913 := p.parse_rel_term() + item1062 := _t1913 + xs1060 = append(xs1060, item1062) + cond1061 = ((((((((((((((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_terms1063 := xs1060 p.consumeLiteral(")") - _t1900 := &pb.RelAtom{Name: name1051, Terms: rel_terms1055} - result1057 := _t1900 - p.recordSpan(int(span_start1056), "RelAtom") - return result1057 + _t1914 := &pb.RelAtom{Name: name1059, Terms: rel_terms1063} + result1065 := _t1914 + p.recordSpan(int(span_start1064), "RelAtom") + return result1065 } func (p *Parser) parse_cast() *pb.Cast { - span_start1060 := int64(p.spanStart()) + span_start1068 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("cast") - _t1901 := p.parse_term() - term1058 := _t1901 - _t1902 := p.parse_term() - term_31059 := _t1902 + _t1915 := p.parse_term() + term1066 := _t1915 + _t1916 := p.parse_term() + term_31067 := _t1916 p.consumeLiteral(")") - _t1903 := &pb.Cast{Input: term1058, Result: term_31059} - result1061 := _t1903 - p.recordSpan(int(span_start1060), "Cast") - return result1061 + _t1917 := &pb.Cast{Input: term1066, Result: term_31067} + result1069 := _t1917 + p.recordSpan(int(span_start1068), "Cast") + return result1069 } func (p *Parser) parse_attrs() []*pb.Attribute { p.consumeLiteral("(") p.consumeLiteral("attrs") - xs1062 := []*pb.Attribute{} - cond1063 := p.matchLookaheadLiteral("(", 0) - for cond1063 { - _t1904 := p.parse_attribute() - item1064 := _t1904 - xs1062 = append(xs1062, item1064) - cond1063 = p.matchLookaheadLiteral("(", 0) - } - attributes1065 := xs1062 + xs1070 := []*pb.Attribute{} + cond1071 := p.matchLookaheadLiteral("(", 0) + for cond1071 { + _t1918 := p.parse_attribute() + item1072 := _t1918 + xs1070 = append(xs1070, item1072) + cond1071 = p.matchLookaheadLiteral("(", 0) + } + attributes1073 := xs1070 p.consumeLiteral(")") - return attributes1065 + return attributes1073 } func (p *Parser) parse_attribute() *pb.Attribute { - span_start1071 := int64(p.spanStart()) + span_start1079 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("attribute") - _t1905 := p.parse_name() - name1066 := _t1905 - xs1067 := []*pb.Value{} - cond1068 := ((((((((((((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 cond1068 { - _t1906 := p.parse_raw_value() - item1069 := _t1906 - xs1067 = append(xs1067, item1069) - cond1068 = ((((((((((((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_values1070 := xs1067 + _t1919 := p.parse_name() + name1074 := _t1919 + xs1075 := []*pb.Value{} + cond1076 := ((((((((((((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 cond1076 { + _t1920 := p.parse_raw_value() + item1077 := _t1920 + xs1075 = append(xs1075, item1077) + cond1076 = ((((((((((((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_values1078 := xs1075 p.consumeLiteral(")") - _t1907 := &pb.Attribute{Name: name1066, Args: raw_values1070} - result1072 := _t1907 - p.recordSpan(int(span_start1071), "Attribute") - return result1072 + _t1921 := &pb.Attribute{Name: name1074, Args: raw_values1078} + result1080 := _t1921 + p.recordSpan(int(span_start1079), "Attribute") + return result1080 } func (p *Parser) parse_algorithm() *pb.Algorithm { - span_start1079 := int64(p.spanStart()) + span_start1087 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("algorithm") - xs1073 := []*pb.RelationId{} - cond1074 := (p.matchLookaheadLiteral(":", 0) || p.matchLookaheadTerminal("UINT128", 0)) - for cond1074 { - _t1908 := p.parse_relation_id() - item1075 := _t1908 - xs1073 = append(xs1073, item1075) - cond1074 = (p.matchLookaheadLiteral(":", 0) || p.matchLookaheadTerminal("UINT128", 0)) - } - relation_ids1076 := xs1073 - _t1909 := p.parse_script() - script1077 := _t1909 - var _t1910 []*pb.Attribute + xs1081 := []*pb.RelationId{} + cond1082 := (p.matchLookaheadLiteral(":", 0) || p.matchLookaheadTerminal("UINT128", 0)) + for cond1082 { + _t1922 := p.parse_relation_id() + item1083 := _t1922 + xs1081 = append(xs1081, item1083) + cond1082 = (p.matchLookaheadLiteral(":", 0) || p.matchLookaheadTerminal("UINT128", 0)) + } + relation_ids1084 := xs1081 + _t1923 := p.parse_script() + script1085 := _t1923 + var _t1924 []*pb.Attribute if p.matchLookaheadLiteral("(", 0) { - _t1911 := p.parse_attrs() - _t1910 = _t1911 + _t1925 := p.parse_attrs() + _t1924 = _t1925 } - attrs1078 := _t1910 + attrs1086 := _t1924 p.consumeLiteral(")") - _t1912 := attrs1078 - if attrs1078 == nil { - _t1912 = []*pb.Attribute{} + _t1926 := attrs1086 + if attrs1086 == nil { + _t1926 = []*pb.Attribute{} } - _t1913 := &pb.Algorithm{Global: relation_ids1076, Body: script1077, Attrs: _t1912} - result1080 := _t1913 - p.recordSpan(int(span_start1079), "Algorithm") - return result1080 + _t1927 := &pb.Algorithm{Global: relation_ids1084, Body: script1085, Attrs: _t1926} + result1088 := _t1927 + p.recordSpan(int(span_start1087), "Algorithm") + return result1088 } func (p *Parser) parse_script() *pb.Script { - span_start1085 := int64(p.spanStart()) + span_start1093 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("script") - xs1081 := []*pb.Construct{} - cond1082 := p.matchLookaheadLiteral("(", 0) - for cond1082 { - _t1914 := p.parse_construct() - item1083 := _t1914 - xs1081 = append(xs1081, item1083) - cond1082 = p.matchLookaheadLiteral("(", 0) - } - constructs1084 := xs1081 + xs1089 := []*pb.Construct{} + cond1090 := p.matchLookaheadLiteral("(", 0) + for cond1090 { + _t1928 := p.parse_construct() + item1091 := _t1928 + xs1089 = append(xs1089, item1091) + cond1090 = p.matchLookaheadLiteral("(", 0) + } + constructs1092 := xs1089 p.consumeLiteral(")") - _t1915 := &pb.Script{Constructs: constructs1084} - result1086 := _t1915 - p.recordSpan(int(span_start1085), "Script") - return result1086 + _t1929 := &pb.Script{Constructs: constructs1092} + result1094 := _t1929 + p.recordSpan(int(span_start1093), "Script") + return result1094 } func (p *Parser) parse_construct() *pb.Construct { - span_start1090 := int64(p.spanStart()) - var _t1916 int64 + span_start1098 := int64(p.spanStart()) + var _t1930 int64 if p.matchLookaheadLiteral("(", 0) { - var _t1917 int64 + var _t1931 int64 if p.matchLookaheadLiteral("upsert", 1) { - _t1917 = 1 + _t1931 = 1 } else { - var _t1918 int64 + var _t1932 int64 if p.matchLookaheadLiteral("monus", 1) { - _t1918 = 1 + _t1932 = 1 } else { - var _t1919 int64 + var _t1933 int64 if p.matchLookaheadLiteral("monoid", 1) { - _t1919 = 1 + _t1933 = 1 } else { - var _t1920 int64 + var _t1934 int64 if p.matchLookaheadLiteral("loop", 1) { - _t1920 = 0 + _t1934 = 0 } else { - var _t1921 int64 + var _t1935 int64 if p.matchLookaheadLiteral("break", 1) { - _t1921 = 1 + _t1935 = 1 } else { - var _t1922 int64 + var _t1936 int64 if p.matchLookaheadLiteral("assign", 1) { - _t1922 = 1 + _t1936 = 1 } else { - _t1922 = -1 + _t1936 = -1 } - _t1921 = _t1922 + _t1935 = _t1936 } - _t1920 = _t1921 + _t1934 = _t1935 } - _t1919 = _t1920 + _t1933 = _t1934 } - _t1918 = _t1919 + _t1932 = _t1933 } - _t1917 = _t1918 + _t1931 = _t1932 } - _t1916 = _t1917 + _t1930 = _t1931 } else { - _t1916 = -1 - } - prediction1087 := _t1916 - var _t1923 *pb.Construct - if prediction1087 == 1 { - _t1924 := p.parse_instruction() - instruction1089 := _t1924 - _t1925 := &pb.Construct{} - _t1925.ConstructType = &pb.Construct_Instruction{Instruction: instruction1089} - _t1923 = _t1925 + _t1930 = -1 + } + prediction1095 := _t1930 + var _t1937 *pb.Construct + if prediction1095 == 1 { + _t1938 := p.parse_instruction() + instruction1097 := _t1938 + _t1939 := &pb.Construct{} + _t1939.ConstructType = &pb.Construct_Instruction{Instruction: instruction1097} + _t1937 = _t1939 } else { - var _t1926 *pb.Construct - if prediction1087 == 0 { - _t1927 := p.parse_loop() - loop1088 := _t1927 - _t1928 := &pb.Construct{} - _t1928.ConstructType = &pb.Construct_Loop{Loop: loop1088} - _t1926 = _t1928 + var _t1940 *pb.Construct + if prediction1095 == 0 { + _t1941 := p.parse_loop() + loop1096 := _t1941 + _t1942 := &pb.Construct{} + _t1942.ConstructType = &pb.Construct_Loop{Loop: loop1096} + _t1940 = _t1942 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in construct", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1923 = _t1926 + _t1937 = _t1940 } - result1091 := _t1923 - p.recordSpan(int(span_start1090), "Construct") - return result1091 + result1099 := _t1937 + p.recordSpan(int(span_start1098), "Construct") + return result1099 } func (p *Parser) parse_loop() *pb.Loop { - span_start1095 := int64(p.spanStart()) + span_start1103 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("loop") - _t1929 := p.parse_init() - init1092 := _t1929 - _t1930 := p.parse_script() - script1093 := _t1930 - var _t1931 []*pb.Attribute + _t1943 := p.parse_init() + init1100 := _t1943 + _t1944 := p.parse_script() + script1101 := _t1944 + var _t1945 []*pb.Attribute if p.matchLookaheadLiteral("(", 0) { - _t1932 := p.parse_attrs() - _t1931 = _t1932 + _t1946 := p.parse_attrs() + _t1945 = _t1946 } - attrs1094 := _t1931 + attrs1102 := _t1945 p.consumeLiteral(")") - _t1933 := attrs1094 - if attrs1094 == nil { - _t1933 = []*pb.Attribute{} + _t1947 := attrs1102 + if attrs1102 == nil { + _t1947 = []*pb.Attribute{} } - _t1934 := &pb.Loop{Init: init1092, Body: script1093, Attrs: _t1933} - result1096 := _t1934 - p.recordSpan(int(span_start1095), "Loop") - return result1096 + _t1948 := &pb.Loop{Init: init1100, Body: script1101, Attrs: _t1947} + result1104 := _t1948 + p.recordSpan(int(span_start1103), "Loop") + return result1104 } func (p *Parser) parse_init() []*pb.Instruction { p.consumeLiteral("(") p.consumeLiteral("init") - xs1097 := []*pb.Instruction{} - cond1098 := p.matchLookaheadLiteral("(", 0) - for cond1098 { - _t1935 := p.parse_instruction() - item1099 := _t1935 - xs1097 = append(xs1097, item1099) - cond1098 = p.matchLookaheadLiteral("(", 0) - } - instructions1100 := xs1097 + xs1105 := []*pb.Instruction{} + cond1106 := p.matchLookaheadLiteral("(", 0) + for cond1106 { + _t1949 := p.parse_instruction() + item1107 := _t1949 + xs1105 = append(xs1105, item1107) + cond1106 = p.matchLookaheadLiteral("(", 0) + } + instructions1108 := xs1105 p.consumeLiteral(")") - return instructions1100 + return instructions1108 } func (p *Parser) parse_instruction() *pb.Instruction { - span_start1107 := int64(p.spanStart()) - var _t1936 int64 + span_start1115 := int64(p.spanStart()) + var _t1950 int64 if p.matchLookaheadLiteral("(", 0) { - var _t1937 int64 + var _t1951 int64 if p.matchLookaheadLiteral("upsert", 1) { - _t1937 = 1 + _t1951 = 1 } else { - var _t1938 int64 + var _t1952 int64 if p.matchLookaheadLiteral("monus", 1) { - _t1938 = 4 + _t1952 = 4 } else { - var _t1939 int64 + var _t1953 int64 if p.matchLookaheadLiteral("monoid", 1) { - _t1939 = 3 + _t1953 = 3 } else { - var _t1940 int64 + var _t1954 int64 if p.matchLookaheadLiteral("break", 1) { - _t1940 = 2 + _t1954 = 2 } else { - var _t1941 int64 + var _t1955 int64 if p.matchLookaheadLiteral("assign", 1) { - _t1941 = 0 + _t1955 = 0 } else { - _t1941 = -1 + _t1955 = -1 } - _t1940 = _t1941 + _t1954 = _t1955 } - _t1939 = _t1940 + _t1953 = _t1954 } - _t1938 = _t1939 + _t1952 = _t1953 } - _t1937 = _t1938 + _t1951 = _t1952 } - _t1936 = _t1937 + _t1950 = _t1951 } else { - _t1936 = -1 - } - prediction1101 := _t1936 - var _t1942 *pb.Instruction - if prediction1101 == 4 { - _t1943 := p.parse_monus_def() - monus_def1106 := _t1943 - _t1944 := &pb.Instruction{} - _t1944.InstrType = &pb.Instruction_MonusDef{MonusDef: monus_def1106} - _t1942 = _t1944 + _t1950 = -1 + } + prediction1109 := _t1950 + var _t1956 *pb.Instruction + if prediction1109 == 4 { + _t1957 := p.parse_monus_def() + monus_def1114 := _t1957 + _t1958 := &pb.Instruction{} + _t1958.InstrType = &pb.Instruction_MonusDef{MonusDef: monus_def1114} + _t1956 = _t1958 } else { - var _t1945 *pb.Instruction - if prediction1101 == 3 { - _t1946 := p.parse_monoid_def() - monoid_def1105 := _t1946 - _t1947 := &pb.Instruction{} - _t1947.InstrType = &pb.Instruction_MonoidDef{MonoidDef: monoid_def1105} - _t1945 = _t1947 + var _t1959 *pb.Instruction + if prediction1109 == 3 { + _t1960 := p.parse_monoid_def() + monoid_def1113 := _t1960 + _t1961 := &pb.Instruction{} + _t1961.InstrType = &pb.Instruction_MonoidDef{MonoidDef: monoid_def1113} + _t1959 = _t1961 } else { - var _t1948 *pb.Instruction - if prediction1101 == 2 { - _t1949 := p.parse_break() - break1104 := _t1949 - _t1950 := &pb.Instruction{} - _t1950.InstrType = &pb.Instruction_Break{Break: break1104} - _t1948 = _t1950 + var _t1962 *pb.Instruction + if prediction1109 == 2 { + _t1963 := p.parse_break() + break1112 := _t1963 + _t1964 := &pb.Instruction{} + _t1964.InstrType = &pb.Instruction_Break{Break: break1112} + _t1962 = _t1964 } else { - var _t1951 *pb.Instruction - if prediction1101 == 1 { - _t1952 := p.parse_upsert() - upsert1103 := _t1952 - _t1953 := &pb.Instruction{} - _t1953.InstrType = &pb.Instruction_Upsert{Upsert: upsert1103} - _t1951 = _t1953 + var _t1965 *pb.Instruction + if prediction1109 == 1 { + _t1966 := p.parse_upsert() + upsert1111 := _t1966 + _t1967 := &pb.Instruction{} + _t1967.InstrType = &pb.Instruction_Upsert{Upsert: upsert1111} + _t1965 = _t1967 } else { - var _t1954 *pb.Instruction - if prediction1101 == 0 { - _t1955 := p.parse_assign() - assign1102 := _t1955 - _t1956 := &pb.Instruction{} - _t1956.InstrType = &pb.Instruction_Assign{Assign: assign1102} - _t1954 = _t1956 + var _t1968 *pb.Instruction + if prediction1109 == 0 { + _t1969 := p.parse_assign() + assign1110 := _t1969 + _t1970 := &pb.Instruction{} + _t1970.InstrType = &pb.Instruction_Assign{Assign: assign1110} + _t1968 = _t1970 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in instruction", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1951 = _t1954 + _t1965 = _t1968 } - _t1948 = _t1951 + _t1962 = _t1965 } - _t1945 = _t1948 + _t1959 = _t1962 } - _t1942 = _t1945 + _t1956 = _t1959 } - result1108 := _t1942 - p.recordSpan(int(span_start1107), "Instruction") - return result1108 + result1116 := _t1956 + p.recordSpan(int(span_start1115), "Instruction") + return result1116 } func (p *Parser) parse_assign() *pb.Assign { - span_start1112 := int64(p.spanStart()) + span_start1120 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("assign") - _t1957 := p.parse_relation_id() - relation_id1109 := _t1957 - _t1958 := p.parse_abstraction() - abstraction1110 := _t1958 - var _t1959 []*pb.Attribute + _t1971 := p.parse_relation_id() + relation_id1117 := _t1971 + _t1972 := p.parse_abstraction() + abstraction1118 := _t1972 + var _t1973 []*pb.Attribute if p.matchLookaheadLiteral("(", 0) { - _t1960 := p.parse_attrs() - _t1959 = _t1960 + _t1974 := p.parse_attrs() + _t1973 = _t1974 } - attrs1111 := _t1959 + attrs1119 := _t1973 p.consumeLiteral(")") - _t1961 := attrs1111 - if attrs1111 == nil { - _t1961 = []*pb.Attribute{} + _t1975 := attrs1119 + if attrs1119 == nil { + _t1975 = []*pb.Attribute{} } - _t1962 := &pb.Assign{Name: relation_id1109, Body: abstraction1110, Attrs: _t1961} - result1113 := _t1962 - p.recordSpan(int(span_start1112), "Assign") - return result1113 + _t1976 := &pb.Assign{Name: relation_id1117, Body: abstraction1118, Attrs: _t1975} + result1121 := _t1976 + p.recordSpan(int(span_start1120), "Assign") + return result1121 } func (p *Parser) parse_upsert() *pb.Upsert { - span_start1117 := int64(p.spanStart()) + span_start1125 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("upsert") - _t1963 := p.parse_relation_id() - relation_id1114 := _t1963 - _t1964 := p.parse_abstraction_with_arity() - abstraction_with_arity1115 := _t1964 - var _t1965 []*pb.Attribute + _t1977 := p.parse_relation_id() + relation_id1122 := _t1977 + _t1978 := p.parse_abstraction_with_arity() + abstraction_with_arity1123 := _t1978 + var _t1979 []*pb.Attribute if p.matchLookaheadLiteral("(", 0) { - _t1966 := p.parse_attrs() - _t1965 = _t1966 + _t1980 := p.parse_attrs() + _t1979 = _t1980 } - attrs1116 := _t1965 + attrs1124 := _t1979 p.consumeLiteral(")") - _t1967 := attrs1116 - if attrs1116 == nil { - _t1967 = []*pb.Attribute{} + _t1981 := attrs1124 + if attrs1124 == nil { + _t1981 = []*pb.Attribute{} } - _t1968 := &pb.Upsert{Name: relation_id1114, Body: abstraction_with_arity1115[0].(*pb.Abstraction), Attrs: _t1967, ValueArity: abstraction_with_arity1115[1].(int64)} - result1118 := _t1968 - p.recordSpan(int(span_start1117), "Upsert") - return result1118 + _t1982 := &pb.Upsert{Name: relation_id1122, Body: abstraction_with_arity1123[0].(*pb.Abstraction), Attrs: _t1981, ValueArity: abstraction_with_arity1123[1].(int64)} + result1126 := _t1982 + p.recordSpan(int(span_start1125), "Upsert") + return result1126 } func (p *Parser) parse_abstraction_with_arity() []interface{} { p.consumeLiteral("(") - _t1969 := p.parse_bindings() - bindings1119 := _t1969 - _t1970 := p.parse_formula() - formula1120 := _t1970 + _t1983 := p.parse_bindings() + bindings1127 := _t1983 + _t1984 := p.parse_formula() + formula1128 := _t1984 p.consumeLiteral(")") - _t1971 := &pb.Abstraction{Vars: listConcat(bindings1119[0].([]*pb.Binding), bindings1119[1].([]*pb.Binding)), Value: formula1120} - return []interface{}{_t1971, int64(len(bindings1119[1].([]*pb.Binding)))} + _t1985 := &pb.Abstraction{Vars: listConcat(bindings1127[0].([]*pb.Binding), bindings1127[1].([]*pb.Binding)), Value: formula1128} + return []interface{}{_t1985, int64(len(bindings1127[1].([]*pb.Binding)))} } func (p *Parser) parse_break() *pb.Break { - span_start1124 := int64(p.spanStart()) + span_start1132 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("break") - _t1972 := p.parse_relation_id() - relation_id1121 := _t1972 - _t1973 := p.parse_abstraction() - abstraction1122 := _t1973 - var _t1974 []*pb.Attribute + _t1986 := p.parse_relation_id() + relation_id1129 := _t1986 + _t1987 := p.parse_abstraction() + abstraction1130 := _t1987 + var _t1988 []*pb.Attribute if p.matchLookaheadLiteral("(", 0) { - _t1975 := p.parse_attrs() - _t1974 = _t1975 + _t1989 := p.parse_attrs() + _t1988 = _t1989 } - attrs1123 := _t1974 + attrs1131 := _t1988 p.consumeLiteral(")") - _t1976 := attrs1123 - if attrs1123 == nil { - _t1976 = []*pb.Attribute{} + _t1990 := attrs1131 + if attrs1131 == nil { + _t1990 = []*pb.Attribute{} } - _t1977 := &pb.Break{Name: relation_id1121, Body: abstraction1122, Attrs: _t1976} - result1125 := _t1977 - p.recordSpan(int(span_start1124), "Break") - return result1125 + _t1991 := &pb.Break{Name: relation_id1129, Body: abstraction1130, Attrs: _t1990} + result1133 := _t1991 + p.recordSpan(int(span_start1132), "Break") + return result1133 } func (p *Parser) parse_monoid_def() *pb.MonoidDef { - span_start1130 := int64(p.spanStart()) + span_start1138 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("monoid") - _t1978 := p.parse_monoid() - monoid1126 := _t1978 - _t1979 := p.parse_relation_id() - relation_id1127 := _t1979 - _t1980 := p.parse_abstraction_with_arity() - abstraction_with_arity1128 := _t1980 - var _t1981 []*pb.Attribute + _t1992 := p.parse_monoid() + monoid1134 := _t1992 + _t1993 := p.parse_relation_id() + relation_id1135 := _t1993 + _t1994 := p.parse_abstraction_with_arity() + abstraction_with_arity1136 := _t1994 + var _t1995 []*pb.Attribute if p.matchLookaheadLiteral("(", 0) { - _t1982 := p.parse_attrs() - _t1981 = _t1982 + _t1996 := p.parse_attrs() + _t1995 = _t1996 } - attrs1129 := _t1981 + attrs1137 := _t1995 p.consumeLiteral(")") - _t1983 := attrs1129 - if attrs1129 == nil { - _t1983 = []*pb.Attribute{} + _t1997 := attrs1137 + if attrs1137 == nil { + _t1997 = []*pb.Attribute{} } - _t1984 := &pb.MonoidDef{Monoid: monoid1126, Name: relation_id1127, Body: abstraction_with_arity1128[0].(*pb.Abstraction), Attrs: _t1983, ValueArity: abstraction_with_arity1128[1].(int64)} - result1131 := _t1984 - p.recordSpan(int(span_start1130), "MonoidDef") - return result1131 + _t1998 := &pb.MonoidDef{Monoid: monoid1134, Name: relation_id1135, Body: abstraction_with_arity1136[0].(*pb.Abstraction), Attrs: _t1997, ValueArity: abstraction_with_arity1136[1].(int64)} + result1139 := _t1998 + p.recordSpan(int(span_start1138), "MonoidDef") + return result1139 } func (p *Parser) parse_monoid() *pb.Monoid { - span_start1137 := int64(p.spanStart()) - var _t1985 int64 + span_start1145 := int64(p.spanStart()) + var _t1999 int64 if p.matchLookaheadLiteral("(", 0) { - var _t1986 int64 + var _t2000 int64 if p.matchLookaheadLiteral("sum", 1) { - _t1986 = 3 + _t2000 = 3 } else { - var _t1987 int64 + var _t2001 int64 if p.matchLookaheadLiteral("or", 1) { - _t1987 = 0 + _t2001 = 0 } else { - var _t1988 int64 + var _t2002 int64 if p.matchLookaheadLiteral("min", 1) { - _t1988 = 1 + _t2002 = 1 } else { - var _t1989 int64 + var _t2003 int64 if p.matchLookaheadLiteral("max", 1) { - _t1989 = 2 + _t2003 = 2 } else { - _t1989 = -1 + _t2003 = -1 } - _t1988 = _t1989 + _t2002 = _t2003 } - _t1987 = _t1988 + _t2001 = _t2002 } - _t1986 = _t1987 + _t2000 = _t2001 } - _t1985 = _t1986 + _t1999 = _t2000 } else { - _t1985 = -1 - } - prediction1132 := _t1985 - var _t1990 *pb.Monoid - if prediction1132 == 3 { - _t1991 := p.parse_sum_monoid() - sum_monoid1136 := _t1991 - _t1992 := &pb.Monoid{} - _t1992.Value = &pb.Monoid_SumMonoid{SumMonoid: sum_monoid1136} - _t1990 = _t1992 + _t1999 = -1 + } + prediction1140 := _t1999 + var _t2004 *pb.Monoid + if prediction1140 == 3 { + _t2005 := p.parse_sum_monoid() + sum_monoid1144 := _t2005 + _t2006 := &pb.Monoid{} + _t2006.Value = &pb.Monoid_SumMonoid{SumMonoid: sum_monoid1144} + _t2004 = _t2006 } else { - var _t1993 *pb.Monoid - if prediction1132 == 2 { - _t1994 := p.parse_max_monoid() - max_monoid1135 := _t1994 - _t1995 := &pb.Monoid{} - _t1995.Value = &pb.Monoid_MaxMonoid{MaxMonoid: max_monoid1135} - _t1993 = _t1995 + var _t2007 *pb.Monoid + if prediction1140 == 2 { + _t2008 := p.parse_max_monoid() + max_monoid1143 := _t2008 + _t2009 := &pb.Monoid{} + _t2009.Value = &pb.Monoid_MaxMonoid{MaxMonoid: max_monoid1143} + _t2007 = _t2009 } else { - var _t1996 *pb.Monoid - if prediction1132 == 1 { - _t1997 := p.parse_min_monoid() - min_monoid1134 := _t1997 - _t1998 := &pb.Monoid{} - _t1998.Value = &pb.Monoid_MinMonoid{MinMonoid: min_monoid1134} - _t1996 = _t1998 + var _t2010 *pb.Monoid + if prediction1140 == 1 { + _t2011 := p.parse_min_monoid() + min_monoid1142 := _t2011 + _t2012 := &pb.Monoid{} + _t2012.Value = &pb.Monoid_MinMonoid{MinMonoid: min_monoid1142} + _t2010 = _t2012 } else { - var _t1999 *pb.Monoid - if prediction1132 == 0 { - _t2000 := p.parse_or_monoid() - or_monoid1133 := _t2000 - _t2001 := &pb.Monoid{} - _t2001.Value = &pb.Monoid_OrMonoid{OrMonoid: or_monoid1133} - _t1999 = _t2001 + var _t2013 *pb.Monoid + if prediction1140 == 0 { + _t2014 := p.parse_or_monoid() + or_monoid1141 := _t2014 + _t2015 := &pb.Monoid{} + _t2015.Value = &pb.Monoid_OrMonoid{OrMonoid: or_monoid1141} + _t2013 = _t2015 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in monoid", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1996 = _t1999 + _t2010 = _t2013 } - _t1993 = _t1996 + _t2007 = _t2010 } - _t1990 = _t1993 + _t2004 = _t2007 } - result1138 := _t1990 - p.recordSpan(int(span_start1137), "Monoid") - return result1138 + result1146 := _t2004 + p.recordSpan(int(span_start1145), "Monoid") + return result1146 } func (p *Parser) parse_or_monoid() *pb.OrMonoid { - span_start1139 := int64(p.spanStart()) + span_start1147 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("or") p.consumeLiteral(")") - _t2002 := &pb.OrMonoid{} - result1140 := _t2002 - p.recordSpan(int(span_start1139), "OrMonoid") - return result1140 + _t2016 := &pb.OrMonoid{} + result1148 := _t2016 + p.recordSpan(int(span_start1147), "OrMonoid") + return result1148 } func (p *Parser) parse_min_monoid() *pb.MinMonoid { - span_start1142 := int64(p.spanStart()) + span_start1150 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("min") - _t2003 := p.parse_type() - type1141 := _t2003 + _t2017 := p.parse_type() + type1149 := _t2017 p.consumeLiteral(")") - _t2004 := &pb.MinMonoid{Type: type1141} - result1143 := _t2004 - p.recordSpan(int(span_start1142), "MinMonoid") - return result1143 + _t2018 := &pb.MinMonoid{Type: type1149} + result1151 := _t2018 + p.recordSpan(int(span_start1150), "MinMonoid") + return result1151 } func (p *Parser) parse_max_monoid() *pb.MaxMonoid { - span_start1145 := int64(p.spanStart()) + span_start1153 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("max") - _t2005 := p.parse_type() - type1144 := _t2005 + _t2019 := p.parse_type() + type1152 := _t2019 p.consumeLiteral(")") - _t2006 := &pb.MaxMonoid{Type: type1144} - result1146 := _t2006 - p.recordSpan(int(span_start1145), "MaxMonoid") - return result1146 + _t2020 := &pb.MaxMonoid{Type: type1152} + result1154 := _t2020 + p.recordSpan(int(span_start1153), "MaxMonoid") + return result1154 } func (p *Parser) parse_sum_monoid() *pb.SumMonoid { - span_start1148 := int64(p.spanStart()) + span_start1156 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("sum") - _t2007 := p.parse_type() - type1147 := _t2007 + _t2021 := p.parse_type() + type1155 := _t2021 p.consumeLiteral(")") - _t2008 := &pb.SumMonoid{Type: type1147} - result1149 := _t2008 - p.recordSpan(int(span_start1148), "SumMonoid") - return result1149 + _t2022 := &pb.SumMonoid{Type: type1155} + result1157 := _t2022 + p.recordSpan(int(span_start1156), "SumMonoid") + return result1157 } func (p *Parser) parse_monus_def() *pb.MonusDef { - span_start1154 := int64(p.spanStart()) + span_start1162 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("monus") - _t2009 := p.parse_monoid() - monoid1150 := _t2009 - _t2010 := p.parse_relation_id() - relation_id1151 := _t2010 - _t2011 := p.parse_abstraction_with_arity() - abstraction_with_arity1152 := _t2011 - var _t2012 []*pb.Attribute + _t2023 := p.parse_monoid() + monoid1158 := _t2023 + _t2024 := p.parse_relation_id() + relation_id1159 := _t2024 + _t2025 := p.parse_abstraction_with_arity() + abstraction_with_arity1160 := _t2025 + var _t2026 []*pb.Attribute if p.matchLookaheadLiteral("(", 0) { - _t2013 := p.parse_attrs() - _t2012 = _t2013 + _t2027 := p.parse_attrs() + _t2026 = _t2027 } - attrs1153 := _t2012 + attrs1161 := _t2026 p.consumeLiteral(")") - _t2014 := attrs1153 - if attrs1153 == nil { - _t2014 = []*pb.Attribute{} + _t2028 := attrs1161 + if attrs1161 == nil { + _t2028 = []*pb.Attribute{} } - _t2015 := &pb.MonusDef{Monoid: monoid1150, Name: relation_id1151, Body: abstraction_with_arity1152[0].(*pb.Abstraction), Attrs: _t2014, ValueArity: abstraction_with_arity1152[1].(int64)} - result1155 := _t2015 - p.recordSpan(int(span_start1154), "MonusDef") - return result1155 + _t2029 := &pb.MonusDef{Monoid: monoid1158, Name: relation_id1159, Body: abstraction_with_arity1160[0].(*pb.Abstraction), Attrs: _t2028, ValueArity: abstraction_with_arity1160[1].(int64)} + result1163 := _t2029 + p.recordSpan(int(span_start1162), "MonusDef") + return result1163 } func (p *Parser) parse_constraint() *pb.Constraint { - span_start1160 := int64(p.spanStart()) + span_start1168 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("functional_dependency") - _t2016 := p.parse_relation_id() - relation_id1156 := _t2016 - _t2017 := p.parse_abstraction() - abstraction1157 := _t2017 - _t2018 := p.parse_functional_dependency_keys() - functional_dependency_keys1158 := _t2018 - _t2019 := p.parse_functional_dependency_values() - functional_dependency_values1159 := _t2019 + _t2030 := p.parse_relation_id() + relation_id1164 := _t2030 + _t2031 := p.parse_abstraction() + abstraction1165 := _t2031 + _t2032 := p.parse_functional_dependency_keys() + functional_dependency_keys1166 := _t2032 + _t2033 := p.parse_functional_dependency_values() + functional_dependency_values1167 := _t2033 p.consumeLiteral(")") - _t2020 := &pb.FunctionalDependency{Guard: abstraction1157, Keys: functional_dependency_keys1158, Values: functional_dependency_values1159} - _t2021 := &pb.Constraint{Name: relation_id1156} - _t2021.ConstraintType = &pb.Constraint_FunctionalDependency{FunctionalDependency: _t2020} - result1161 := _t2021 - p.recordSpan(int(span_start1160), "Constraint") - return result1161 + _t2034 := &pb.FunctionalDependency{Guard: abstraction1165, Keys: functional_dependency_keys1166, Values: functional_dependency_values1167} + _t2035 := &pb.Constraint{Name: relation_id1164} + _t2035.ConstraintType = &pb.Constraint_FunctionalDependency{FunctionalDependency: _t2034} + result1169 := _t2035 + p.recordSpan(int(span_start1168), "Constraint") + return result1169 } func (p *Parser) parse_functional_dependency_keys() []*pb.Var { p.consumeLiteral("(") p.consumeLiteral("keys") - xs1162 := []*pb.Var{} - cond1163 := p.matchLookaheadTerminal("SYMBOL", 0) - for cond1163 { - _t2022 := p.parse_var() - item1164 := _t2022 - xs1162 = append(xs1162, item1164) - cond1163 = p.matchLookaheadTerminal("SYMBOL", 0) - } - vars1165 := xs1162 + xs1170 := []*pb.Var{} + cond1171 := p.matchLookaheadTerminal("SYMBOL", 0) + for cond1171 { + _t2036 := p.parse_var() + item1172 := _t2036 + xs1170 = append(xs1170, item1172) + cond1171 = p.matchLookaheadTerminal("SYMBOL", 0) + } + vars1173 := xs1170 p.consumeLiteral(")") - return vars1165 + return vars1173 } func (p *Parser) parse_functional_dependency_values() []*pb.Var { p.consumeLiteral("(") p.consumeLiteral("values") - xs1166 := []*pb.Var{} - cond1167 := p.matchLookaheadTerminal("SYMBOL", 0) - for cond1167 { - _t2023 := p.parse_var() - item1168 := _t2023 - xs1166 = append(xs1166, item1168) - cond1167 = p.matchLookaheadTerminal("SYMBOL", 0) - } - vars1169 := xs1166 + xs1174 := []*pb.Var{} + cond1175 := p.matchLookaheadTerminal("SYMBOL", 0) + for cond1175 { + _t2037 := p.parse_var() + item1176 := _t2037 + xs1174 = append(xs1174, item1176) + cond1175 = p.matchLookaheadTerminal("SYMBOL", 0) + } + vars1177 := xs1174 p.consumeLiteral(")") - return vars1169 + return vars1177 } func (p *Parser) parse_data() *pb.Data { - span_start1175 := int64(p.spanStart()) - var _t2024 int64 + span_start1183 := int64(p.spanStart()) + var _t2038 int64 if p.matchLookaheadLiteral("(", 0) { - var _t2025 int64 + var _t2039 int64 if p.matchLookaheadLiteral("iceberg_data", 1) { - _t2025 = 3 + _t2039 = 3 } else { - var _t2026 int64 + var _t2040 int64 if p.matchLookaheadLiteral("edb", 1) { - _t2026 = 0 + _t2040 = 0 } else { - var _t2027 int64 + var _t2041 int64 if p.matchLookaheadLiteral("csv_data", 1) { - _t2027 = 2 + _t2041 = 2 } else { - var _t2028 int64 + var _t2042 int64 if p.matchLookaheadLiteral("betree_relation", 1) { - _t2028 = 1 + _t2042 = 1 } else { - _t2028 = -1 + _t2042 = -1 } - _t2027 = _t2028 + _t2041 = _t2042 } - _t2026 = _t2027 + _t2040 = _t2041 } - _t2025 = _t2026 + _t2039 = _t2040 } - _t2024 = _t2025 + _t2038 = _t2039 } else { - _t2024 = -1 - } - prediction1170 := _t2024 - var _t2029 *pb.Data - if prediction1170 == 3 { - _t2030 := p.parse_iceberg_data() - iceberg_data1174 := _t2030 - _t2031 := &pb.Data{} - _t2031.DataType = &pb.Data_IcebergData{IcebergData: iceberg_data1174} - _t2029 = _t2031 + _t2038 = -1 + } + prediction1178 := _t2038 + var _t2043 *pb.Data + if prediction1178 == 3 { + _t2044 := p.parse_iceberg_data() + iceberg_data1182 := _t2044 + _t2045 := &pb.Data{} + _t2045.DataType = &pb.Data_IcebergData{IcebergData: iceberg_data1182} + _t2043 = _t2045 } else { - var _t2032 *pb.Data - if prediction1170 == 2 { - _t2033 := p.parse_csv_data() - csv_data1173 := _t2033 - _t2034 := &pb.Data{} - _t2034.DataType = &pb.Data_CsvData{CsvData: csv_data1173} - _t2032 = _t2034 + var _t2046 *pb.Data + if prediction1178 == 2 { + _t2047 := p.parse_csv_data() + csv_data1181 := _t2047 + _t2048 := &pb.Data{} + _t2048.DataType = &pb.Data_CsvData{CsvData: csv_data1181} + _t2046 = _t2048 } else { - var _t2035 *pb.Data - if prediction1170 == 1 { - _t2036 := p.parse_betree_relation() - betree_relation1172 := _t2036 - _t2037 := &pb.Data{} - _t2037.DataType = &pb.Data_BetreeRelation{BetreeRelation: betree_relation1172} - _t2035 = _t2037 + var _t2049 *pb.Data + if prediction1178 == 1 { + _t2050 := p.parse_betree_relation() + betree_relation1180 := _t2050 + _t2051 := &pb.Data{} + _t2051.DataType = &pb.Data_BetreeRelation{BetreeRelation: betree_relation1180} + _t2049 = _t2051 } else { - var _t2038 *pb.Data - if prediction1170 == 0 { - _t2039 := p.parse_edb() - edb1171 := _t2039 - _t2040 := &pb.Data{} - _t2040.DataType = &pb.Data_Edb{Edb: edb1171} - _t2038 = _t2040 + var _t2052 *pb.Data + if prediction1178 == 0 { + _t2053 := p.parse_edb() + edb1179 := _t2053 + _t2054 := &pb.Data{} + _t2054.DataType = &pb.Data_Edb{Edb: edb1179} + _t2052 = _t2054 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in data", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t2035 = _t2038 + _t2049 = _t2052 } - _t2032 = _t2035 + _t2046 = _t2049 } - _t2029 = _t2032 + _t2043 = _t2046 } - result1176 := _t2029 - p.recordSpan(int(span_start1175), "Data") - return result1176 + result1184 := _t2043 + p.recordSpan(int(span_start1183), "Data") + return result1184 } func (p *Parser) parse_edb() *pb.EDB { - span_start1180 := int64(p.spanStart()) + span_start1188 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("edb") - _t2041 := p.parse_relation_id() - relation_id1177 := _t2041 - _t2042 := p.parse_edb_path() - edb_path1178 := _t2042 - _t2043 := p.parse_edb_types() - edb_types1179 := _t2043 + _t2055 := p.parse_relation_id() + relation_id1185 := _t2055 + _t2056 := p.parse_edb_path() + edb_path1186 := _t2056 + _t2057 := p.parse_edb_types() + edb_types1187 := _t2057 p.consumeLiteral(")") - _t2044 := &pb.EDB{TargetId: relation_id1177, Path: edb_path1178, Types: edb_types1179} - result1181 := _t2044 - p.recordSpan(int(span_start1180), "EDB") - return result1181 + _t2058 := &pb.EDB{TargetId: relation_id1185, Path: edb_path1186, Types: edb_types1187} + result1189 := _t2058 + p.recordSpan(int(span_start1188), "EDB") + return result1189 } func (p *Parser) parse_edb_path() []string { p.consumeLiteral("[") - xs1182 := []string{} - cond1183 := p.matchLookaheadTerminal("STRING", 0) - for cond1183 { - item1184 := p.consumeTerminal("STRING").Value.str - xs1182 = append(xs1182, item1184) - cond1183 = p.matchLookaheadTerminal("STRING", 0) - } - strings1185 := xs1182 + xs1190 := []string{} + cond1191 := p.matchLookaheadTerminal("STRING", 0) + for cond1191 { + item1192 := p.consumeTerminal("STRING").Value.str + xs1190 = append(xs1190, item1192) + cond1191 = p.matchLookaheadTerminal("STRING", 0) + } + strings1193 := xs1190 p.consumeLiteral("]") - return strings1185 + return strings1193 } func (p *Parser) parse_edb_types() []*pb.Type { p.consumeLiteral("[") - xs1186 := []*pb.Type{} - cond1187 := (((((((((((((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 cond1187 { - _t2045 := p.parse_type() - item1188 := _t2045 - xs1186 = append(xs1186, item1188) - cond1187 = (((((((((((((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)) - } - types1189 := xs1186 + xs1194 := []*pb.Type{} + cond1195 := (((((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("BOOLEAN", 0)) || p.matchLookaheadLiteral("DATE", 0)) || p.matchLookaheadLiteral("DATETIME", 0)) || p.matchLookaheadLiteral("FLOAT", 0)) || p.matchLookaheadLiteral("FLOAT32", 0)) || p.matchLookaheadLiteral("INT", 0)) || p.matchLookaheadLiteral("INT128", 0)) || p.matchLookaheadLiteral("INT32", 0)) || p.matchLookaheadLiteral("MISSING", 0)) || p.matchLookaheadLiteral("STRING", 0)) || p.matchLookaheadLiteral("UINT128", 0)) || p.matchLookaheadLiteral("UINT32", 0)) || p.matchLookaheadLiteral("UNKNOWN", 0)) + for cond1195 { + _t2059 := p.parse_type() + item1196 := _t2059 + xs1194 = append(xs1194, item1196) + cond1195 = (((((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("BOOLEAN", 0)) || p.matchLookaheadLiteral("DATE", 0)) || p.matchLookaheadLiteral("DATETIME", 0)) || p.matchLookaheadLiteral("FLOAT", 0)) || p.matchLookaheadLiteral("FLOAT32", 0)) || p.matchLookaheadLiteral("INT", 0)) || p.matchLookaheadLiteral("INT128", 0)) || p.matchLookaheadLiteral("INT32", 0)) || p.matchLookaheadLiteral("MISSING", 0)) || p.matchLookaheadLiteral("STRING", 0)) || p.matchLookaheadLiteral("UINT128", 0)) || p.matchLookaheadLiteral("UINT32", 0)) || p.matchLookaheadLiteral("UNKNOWN", 0)) + } + types1197 := xs1194 p.consumeLiteral("]") - return types1189 + return types1197 } func (p *Parser) parse_betree_relation() *pb.BeTreeRelation { - span_start1192 := int64(p.spanStart()) + span_start1200 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("betree_relation") - _t2046 := p.parse_relation_id() - relation_id1190 := _t2046 - _t2047 := p.parse_betree_info() - betree_info1191 := _t2047 + _t2060 := p.parse_relation_id() + relation_id1198 := _t2060 + _t2061 := p.parse_betree_info() + betree_info1199 := _t2061 p.consumeLiteral(")") - _t2048 := &pb.BeTreeRelation{Name: relation_id1190, RelationInfo: betree_info1191} - result1193 := _t2048 - p.recordSpan(int(span_start1192), "BeTreeRelation") - return result1193 + _t2062 := &pb.BeTreeRelation{Name: relation_id1198, RelationInfo: betree_info1199} + result1201 := _t2062 + p.recordSpan(int(span_start1200), "BeTreeRelation") + return result1201 } func (p *Parser) parse_betree_info() *pb.BeTreeInfo { - span_start1197 := int64(p.spanStart()) + span_start1205 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("betree_info") - _t2049 := p.parse_betree_info_key_types() - betree_info_key_types1194 := _t2049 - _t2050 := p.parse_betree_info_value_types() - betree_info_value_types1195 := _t2050 - _t2051 := p.parse_config_dict() - config_dict1196 := _t2051 + _t2063 := p.parse_betree_info_key_types() + betree_info_key_types1202 := _t2063 + _t2064 := p.parse_betree_info_value_types() + betree_info_value_types1203 := _t2064 + _t2065 := p.parse_config_dict() + config_dict1204 := _t2065 p.consumeLiteral(")") - _t2052 := p.construct_betree_info(betree_info_key_types1194, betree_info_value_types1195, config_dict1196) - result1198 := _t2052 - p.recordSpan(int(span_start1197), "BeTreeInfo") - return result1198 + _t2066 := p.construct_betree_info(betree_info_key_types1202, betree_info_value_types1203, config_dict1204) + result1206 := _t2066 + p.recordSpan(int(span_start1205), "BeTreeInfo") + return result1206 } func (p *Parser) parse_betree_info_key_types() []*pb.Type { p.consumeLiteral("(") p.consumeLiteral("key_types") - xs1199 := []*pb.Type{} - cond1200 := (((((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("BOOLEAN", 0)) || p.matchLookaheadLiteral("DATE", 0)) || p.matchLookaheadLiteral("DATETIME", 0)) || p.matchLookaheadLiteral("FLOAT", 0)) || p.matchLookaheadLiteral("FLOAT32", 0)) || p.matchLookaheadLiteral("INT", 0)) || p.matchLookaheadLiteral("INT128", 0)) || p.matchLookaheadLiteral("INT32", 0)) || p.matchLookaheadLiteral("MISSING", 0)) || p.matchLookaheadLiteral("STRING", 0)) || p.matchLookaheadLiteral("UINT128", 0)) || p.matchLookaheadLiteral("UINT32", 0)) || p.matchLookaheadLiteral("UNKNOWN", 0)) - for cond1200 { - _t2053 := p.parse_type() - item1201 := _t2053 - xs1199 = append(xs1199, item1201) - cond1200 = (((((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("BOOLEAN", 0)) || p.matchLookaheadLiteral("DATE", 0)) || p.matchLookaheadLiteral("DATETIME", 0)) || p.matchLookaheadLiteral("FLOAT", 0)) || p.matchLookaheadLiteral("FLOAT32", 0)) || p.matchLookaheadLiteral("INT", 0)) || p.matchLookaheadLiteral("INT128", 0)) || p.matchLookaheadLiteral("INT32", 0)) || p.matchLookaheadLiteral("MISSING", 0)) || p.matchLookaheadLiteral("STRING", 0)) || p.matchLookaheadLiteral("UINT128", 0)) || p.matchLookaheadLiteral("UINT32", 0)) || p.matchLookaheadLiteral("UNKNOWN", 0)) - } - types1202 := xs1199 + xs1207 := []*pb.Type{} + cond1208 := (((((((((((((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 cond1208 { + _t2067 := p.parse_type() + item1209 := _t2067 + xs1207 = append(xs1207, item1209) + cond1208 = (((((((((((((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)) + } + types1210 := xs1207 p.consumeLiteral(")") - return types1202 + return types1210 } func (p *Parser) parse_betree_info_value_types() []*pb.Type { p.consumeLiteral("(") p.consumeLiteral("value_types") - xs1203 := []*pb.Type{} - cond1204 := (((((((((((((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 cond1204 { - _t2054 := p.parse_type() - item1205 := _t2054 - xs1203 = append(xs1203, item1205) - cond1204 = (((((((((((((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)) - } - types1206 := xs1203 + xs1211 := []*pb.Type{} + cond1212 := (((((((((((((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 cond1212 { + _t2068 := p.parse_type() + item1213 := _t2068 + xs1211 = append(xs1211, item1213) + cond1212 = (((((((((((((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)) + } + types1214 := xs1211 p.consumeLiteral(")") - return types1206 + return types1214 } func (p *Parser) parse_csv_data() *pb.CSVData { - span_start1212 := int64(p.spanStart()) + span_start1220 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("csv_data") - _t2055 := p.parse_csvlocator() - csvlocator1207 := _t2055 - _t2056 := p.parse_csv_config() - csv_config1208 := _t2056 - var _t2057 []*pb.GNFColumn + _t2069 := p.parse_csvlocator() + csvlocator1215 := _t2069 + _t2070 := p.parse_csv_config() + csv_config1216 := _t2070 + var _t2071 []*pb.GNFColumn if (p.matchLookaheadLiteral("(", 0) && p.matchLookaheadLiteral("columns", 1)) { - _t2058 := p.parse_gnf_columns() - _t2057 = _t2058 + _t2072 := p.parse_gnf_columns() + _t2071 = _t2072 } - gnf_columns1209 := _t2057 - var _t2059 *pb.TargetRelations + gnf_columns1217 := _t2071 + var _t2073 *pb.TargetRelations if (p.matchLookaheadLiteral("(", 0) && p.matchLookaheadLiteral("relations", 1)) { - _t2060 := p.parse_target_relations() - _t2059 = _t2060 + _t2074 := p.parse_target_relations() + _t2073 = _t2074 } - target_relations1210 := _t2059 - _t2061 := p.parse_csv_asof() - csv_asof1211 := _t2061 + target_relations1218 := _t2073 + _t2075 := p.parse_csv_asof() + csv_asof1219 := _t2075 p.consumeLiteral(")") - _t2062 := p.construct_csv_data(csvlocator1207, csv_config1208, gnf_columns1209, target_relations1210, csv_asof1211) - result1213 := _t2062 - p.recordSpan(int(span_start1212), "CSVData") - return result1213 + _t2076 := p.construct_csv_data(csvlocator1215, csv_config1216, gnf_columns1217, target_relations1218, csv_asof1219) + result1221 := _t2076 + p.recordSpan(int(span_start1220), "CSVData") + return result1221 } func (p *Parser) parse_csvlocator() *pb.CSVLocator { - span_start1216 := int64(p.spanStart()) + span_start1224 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("csv_locator") - var _t2063 []string + var _t2077 []string if (p.matchLookaheadLiteral("(", 0) && p.matchLookaheadLiteral("paths", 1)) { - _t2064 := p.parse_csv_locator_paths() - _t2063 = _t2064 + _t2078 := p.parse_csv_locator_paths() + _t2077 = _t2078 } - csv_locator_paths1214 := _t2063 - var _t2065 *string + csv_locator_paths1222 := _t2077 + var _t2079 *string if p.matchLookaheadLiteral("(", 0) { - _t2066 := p.parse_csv_locator_inline_data() - _t2065 = ptr(_t2066) + _t2080 := p.parse_csv_locator_inline_data() + _t2079 = ptr(_t2080) } - csv_locator_inline_data1215 := _t2065 + csv_locator_inline_data1223 := _t2079 p.consumeLiteral(")") - _t2067 := csv_locator_paths1214 - if csv_locator_paths1214 == nil { - _t2067 = []string{} + _t2081 := csv_locator_paths1222 + if csv_locator_paths1222 == nil { + _t2081 = []string{} } - _t2068 := &pb.CSVLocator{Paths: _t2067, InlineData: []byte(deref(csv_locator_inline_data1215, ""))} - result1217 := _t2068 - p.recordSpan(int(span_start1216), "CSVLocator") - return result1217 + _t2082 := &pb.CSVLocator{Paths: _t2081, InlineData: []byte(deref(csv_locator_inline_data1223, ""))} + result1225 := _t2082 + p.recordSpan(int(span_start1224), "CSVLocator") + return result1225 } func (p *Parser) parse_csv_locator_paths() []string { p.consumeLiteral("(") p.consumeLiteral("paths") - xs1218 := []string{} - cond1219 := p.matchLookaheadTerminal("STRING", 0) - for cond1219 { - item1220 := p.consumeTerminal("STRING").Value.str - xs1218 = append(xs1218, item1220) - cond1219 = p.matchLookaheadTerminal("STRING", 0) - } - strings1221 := xs1218 + xs1226 := []string{} + cond1227 := p.matchLookaheadTerminal("STRING", 0) + for cond1227 { + item1228 := p.consumeTerminal("STRING").Value.str + xs1226 = append(xs1226, item1228) + cond1227 = p.matchLookaheadTerminal("STRING", 0) + } + strings1229 := xs1226 p.consumeLiteral(")") - return strings1221 + return strings1229 } func (p *Parser) parse_csv_locator_inline_data() string { p.consumeLiteral("(") p.consumeLiteral("inline_data") - formatted_string1222 := p.consumeTerminal("STRING").Value.str + formatted_string1230 := p.consumeTerminal("STRING").Value.str p.consumeLiteral(")") - return formatted_string1222 + return formatted_string1230 } func (p *Parser) parse_csv_config() *pb.CSVConfig { - span_start1225 := int64(p.spanStart()) + span_start1233 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("csv_config") - _t2069 := p.parse_config_dict() - config_dict1223 := _t2069 - var _t2070 [][]interface{} + _t2083 := p.parse_config_dict() + config_dict1231 := _t2083 + var _t2084 [][]interface{} if p.matchLookaheadLiteral("(", 0) { - _t2071 := p.parse__storage_integration() - _t2070 = _t2071 + _t2085 := p.parse__storage_integration() + _t2084 = _t2085 } - _storage_integration1224 := _t2070 + _storage_integration1232 := _t2084 p.consumeLiteral(")") - _t2072 := p.construct_csv_config(config_dict1223, _storage_integration1224) - result1226 := _t2072 - p.recordSpan(int(span_start1225), "CSVConfig") - return result1226 + _t2086 := p.construct_csv_config(config_dict1231, _storage_integration1232) + result1234 := _t2086 + p.recordSpan(int(span_start1233), "CSVConfig") + return result1234 } func (p *Parser) parse__storage_integration() [][]interface{} { p.consumeLiteral("(") p.consumeLiteral("storage_integration") - _t2073 := p.parse_config_dict() - config_dict1227 := _t2073 + _t2087 := p.parse_config_dict() + config_dict1235 := _t2087 p.consumeLiteral(")") - return config_dict1227 + return config_dict1235 } func (p *Parser) parse_gnf_columns() []*pb.GNFColumn { p.consumeLiteral("(") p.consumeLiteral("columns") - xs1228 := []*pb.GNFColumn{} - cond1229 := p.matchLookaheadLiteral("(", 0) - for cond1229 { - _t2074 := p.parse_gnf_column() - item1230 := _t2074 - xs1228 = append(xs1228, item1230) - cond1229 = p.matchLookaheadLiteral("(", 0) - } - gnf_columns1231 := xs1228 + xs1236 := []*pb.GNFColumn{} + cond1237 := p.matchLookaheadLiteral("(", 0) + for cond1237 { + _t2088 := p.parse_gnf_column() + item1238 := _t2088 + xs1236 = append(xs1236, item1238) + cond1237 = p.matchLookaheadLiteral("(", 0) + } + gnf_columns1239 := xs1236 p.consumeLiteral(")") - return gnf_columns1231 + return gnf_columns1239 } func (p *Parser) parse_gnf_column() *pb.GNFColumn { - span_start1238 := int64(p.spanStart()) + span_start1246 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("column") - _t2075 := p.parse_gnf_column_path() - gnf_column_path1232 := _t2075 - var _t2076 *pb.RelationId + _t2089 := p.parse_gnf_column_path() + gnf_column_path1240 := _t2089 + var _t2090 *pb.RelationId if (p.matchLookaheadLiteral(":", 0) || p.matchLookaheadTerminal("UINT128", 0)) { - _t2077 := p.parse_relation_id() - _t2076 = _t2077 + _t2091 := p.parse_relation_id() + _t2090 = _t2091 } - relation_id1233 := _t2076 + relation_id1241 := _t2090 p.consumeLiteral("[") - xs1234 := []*pb.Type{} - cond1235 := (((((((((((((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 cond1235 { - _t2078 := p.parse_type() - item1236 := _t2078 - xs1234 = append(xs1234, item1236) - cond1235 = (((((((((((((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)) - } - types1237 := xs1234 + xs1242 := []*pb.Type{} + cond1243 := (((((((((((((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 cond1243 { + _t2092 := p.parse_type() + item1244 := _t2092 + xs1242 = append(xs1242, item1244) + cond1243 = (((((((((((((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)) + } + types1245 := xs1242 p.consumeLiteral("]") p.consumeLiteral(")") - _t2079 := &pb.GNFColumn{ColumnPath: gnf_column_path1232, TargetId: relation_id1233, Types: types1237} - result1239 := _t2079 - p.recordSpan(int(span_start1238), "GNFColumn") - return result1239 + _t2093 := &pb.GNFColumn{ColumnPath: gnf_column_path1240, TargetId: relation_id1241, Types: types1245} + result1247 := _t2093 + p.recordSpan(int(span_start1246), "GNFColumn") + return result1247 } func (p *Parser) parse_gnf_column_path() []string { - var _t2080 int64 + var _t2094 int64 if p.matchLookaheadLiteral("[", 0) { - _t2080 = 1 + _t2094 = 1 } else { - var _t2081 int64 + var _t2095 int64 if p.matchLookaheadTerminal("STRING", 0) { - _t2081 = 0 + _t2095 = 0 } else { - _t2081 = -1 + _t2095 = -1 } - _t2080 = _t2081 + _t2094 = _t2095 } - prediction1240 := _t2080 - var _t2082 []string - if prediction1240 == 1 { + prediction1248 := _t2094 + var _t2096 []string + if prediction1248 == 1 { p.consumeLiteral("[") - xs1242 := []string{} - cond1243 := p.matchLookaheadTerminal("STRING", 0) - for cond1243 { - item1244 := p.consumeTerminal("STRING").Value.str - xs1242 = append(xs1242, item1244) - cond1243 = p.matchLookaheadTerminal("STRING", 0) + xs1250 := []string{} + cond1251 := p.matchLookaheadTerminal("STRING", 0) + for cond1251 { + item1252 := p.consumeTerminal("STRING").Value.str + xs1250 = append(xs1250, item1252) + cond1251 = p.matchLookaheadTerminal("STRING", 0) } - strings1245 := xs1242 + strings1253 := xs1250 p.consumeLiteral("]") - _t2082 = strings1245 + _t2096 = strings1253 } else { - var _t2083 []string - if prediction1240 == 0 { - string1241 := p.consumeTerminal("STRING").Value.str - _ = string1241 - _t2083 = []string{string1241} + var _t2097 []string + if prediction1248 == 0 { + string1249 := p.consumeTerminal("STRING").Value.str + _ = string1249 + _t2097 = []string{string1249} } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in gnf_column_path", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t2082 = _t2083 + _t2096 = _t2097 } - return _t2082 + return _t2096 } func (p *Parser) parse_target_relations() *pb.TargetRelations { - span_start1249 := int64(p.spanStart()) + span_start1257 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("relations") - _t2084 := p.parse_relation_keys() - relation_keys1246 := _t2084 - _t2085 := p.parse_relation_body() - relation_body1247 := _t2085 - var _t2086 *pb.RelationId + _t2098 := p.parse_relation_keys() + relation_keys1254 := _t2098 + _t2099 := p.parse_relation_body() + relation_body1255 := _t2099 + var _t2100 *pb.RelationId if p.matchLookaheadLiteral("(", 0) { - _t2087 := p.parse_load_errors() - _t2086 = _t2087 + _t2101 := p.parse_load_errors() + _t2100 = _t2101 } - load_errors1248 := _t2086 + load_errors1256 := _t2100 p.consumeLiteral(")") - _t2088 := p.construct_relations(relation_keys1246, relation_body1247, load_errors1248) - result1250 := _t2088 - p.recordSpan(int(span_start1249), "TargetRelations") - return result1250 + _t2102 := p.construct_relations(relation_keys1254, relation_body1255, load_errors1256) + result1258 := _t2102 + p.recordSpan(int(span_start1257), "TargetRelations") + return result1258 } func (p *Parser) parse_relation_keys() []interface{} { - var _t2089 int64 + var _t2103 int64 if p.matchLookaheadLiteral("(", 0) { - var _t2090 int64 + var _t2104 int64 if p.matchLookaheadLiteral("keys", 1) { - var _t2091 int64 + var _t2105 int64 if p.matchLookaheadLiteral("synthetic", 2) { - _t2091 = 1 + _t2105 = 1 } else { - var _t2092 int64 + var _t2106 int64 if p.matchLookaheadLiteral(")", 2) { - _t2092 = 0 + _t2106 = 0 } else { - var _t2093 int64 + var _t2107 int64 if p.matchLookaheadLiteral("(", 2) { - _t2093 = 0 + _t2107 = 0 } else { - _t2093 = -1 + _t2107 = -1 } - _t2092 = _t2093 + _t2106 = _t2107 } - _t2091 = _t2092 + _t2105 = _t2106 } - _t2090 = _t2091 + _t2104 = _t2105 } else { - _t2090 = -1 + _t2104 = -1 } - _t2089 = _t2090 + _t2103 = _t2104 } else { - _t2089 = -1 + _t2103 = -1 } - prediction1251 := _t2089 - var _t2094 []interface{} - if prediction1251 == 1 { + prediction1259 := _t2103 + var _t2108 []interface{} + if prediction1259 == 1 { p.consumeLiteral("(") p.consumeLiteral("keys") p.consumeLiteral("synthetic") p.consumeLiteral(")") - _t2094 = []interface{}{[]*pb.NamedColumn{}, true} + _t2108 = []interface{}{[]*pb.NamedColumn{}, true} } else { - var _t2095 []interface{} - if prediction1251 == 0 { + var _t2109 []interface{} + if prediction1259 == 0 { p.consumeLiteral("(") p.consumeLiteral("keys") - xs1252 := []*pb.NamedColumn{} - cond1253 := p.matchLookaheadLiteral("(", 0) - for cond1253 { - _t2096 := p.parse_named_column() - item1254 := _t2096 - xs1252 = append(xs1252, item1254) - cond1253 = p.matchLookaheadLiteral("(", 0) + xs1260 := []*pb.NamedColumn{} + cond1261 := p.matchLookaheadLiteral("(", 0) + for cond1261 { + _t2110 := p.parse_named_column() + item1262 := _t2110 + xs1260 = append(xs1260, item1262) + cond1261 = p.matchLookaheadLiteral("(", 0) } - named_columns1255 := xs1252 + named_columns1263 := xs1260 p.consumeLiteral(")") - _t2095 = []interface{}{named_columns1255, false} + _t2109 = []interface{}{named_columns1263, false} } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in relation_keys", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t2094 = _t2095 + _t2108 = _t2109 } - return _t2094 + return _t2108 } func (p *Parser) parse_named_column() *pb.NamedColumn { - span_start1258 := int64(p.spanStart()) + span_start1266 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("column") - string1256 := p.consumeTerminal("STRING").Value.str - _t2097 := p.parse_type() - type1257 := _t2097 + string1264 := p.consumeTerminal("STRING").Value.str + _t2111 := p.parse_type() + type1265 := _t2111 p.consumeLiteral(")") - _t2098 := &pb.NamedColumn{Name: string1256, Type: type1257} - result1259 := _t2098 - p.recordSpan(int(span_start1258), "NamedColumn") - return result1259 + _t2112 := &pb.NamedColumn{Name: string1264, Type: type1265} + result1267 := _t2112 + p.recordSpan(int(span_start1266), "NamedColumn") + return result1267 } func (p *Parser) parse_relation_body() *pb.TargetRelations { - span_start1264 := int64(p.spanStart()) - var _t2099 int64 + span_start1272 := int64(p.spanStart()) + var _t2113 int64 if p.matchLookaheadLiteral("(", 0) { - var _t2100 int64 + var _t2114 int64 if p.matchLookaheadLiteral("relation", 1) { - _t2100 = 0 + _t2114 = 0 } else { - var _t2101 int64 + var _t2115 int64 if p.matchLookaheadLiteral("inserts", 1) { - _t2101 = 1 + _t2115 = 1 } else { - _t2101 = 0 + _t2115 = 0 } - _t2100 = _t2101 + _t2114 = _t2115 } - _t2099 = _t2100 + _t2113 = _t2114 } else { - _t2099 = 0 - } - prediction1260 := _t2099 - var _t2102 *pb.TargetRelations - if prediction1260 == 1 { - _t2103 := p.parse_cdc_inserts() - cdc_inserts1262 := _t2103 - _t2104 := p.parse_cdc_deletes() - cdc_deletes1263 := _t2104 - _t2105 := p.construct_cdc_relations(cdc_inserts1262, cdc_deletes1263) - _t2102 = _t2105 + _t2113 = 0 + } + prediction1268 := _t2113 + var _t2116 *pb.TargetRelations + if prediction1268 == 1 { + _t2117 := p.parse_cdc_inserts() + cdc_inserts1270 := _t2117 + _t2118 := p.parse_cdc_deletes() + cdc_deletes1271 := _t2118 + _t2119 := p.construct_cdc_relations(cdc_inserts1270, cdc_deletes1271) + _t2116 = _t2119 } else { - var _t2106 *pb.TargetRelations - if prediction1260 == 0 { - _t2107 := p.parse_non_cdc_relations() - non_cdc_relations1261 := _t2107 - _t2108 := p.construct_non_cdc_relations(non_cdc_relations1261) - _t2106 = _t2108 + var _t2120 *pb.TargetRelations + if prediction1268 == 0 { + _t2121 := p.parse_non_cdc_relations() + non_cdc_relations1269 := _t2121 + _t2122 := p.construct_non_cdc_relations(non_cdc_relations1269) + _t2120 = _t2122 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in relation_body", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t2102 = _t2106 + _t2116 = _t2120 } - result1265 := _t2102 - p.recordSpan(int(span_start1264), "TargetRelations") - return result1265 + result1273 := _t2116 + p.recordSpan(int(span_start1272), "TargetRelations") + return result1273 } func (p *Parser) parse_non_cdc_relations() []*pb.TargetRelation { - xs1266 := []*pb.TargetRelation{} - cond1267 := (p.matchLookaheadLiteral("(", 0) && p.matchLookaheadLiteral("relation", 1)) - for cond1267 { - _t2109 := p.parse_target_relation() - item1268 := _t2109 - xs1266 = append(xs1266, item1268) - cond1267 = (p.matchLookaheadLiteral("(", 0) && p.matchLookaheadLiteral("relation", 1)) + xs1274 := []*pb.TargetRelation{} + cond1275 := (p.matchLookaheadLiteral("(", 0) && p.matchLookaheadLiteral("relation", 1)) + for cond1275 { + _t2123 := p.parse_target_relation() + item1276 := _t2123 + xs1274 = append(xs1274, item1276) + cond1275 = (p.matchLookaheadLiteral("(", 0) && p.matchLookaheadLiteral("relation", 1)) } - return xs1266 + return xs1274 } func (p *Parser) parse_target_relation() *pb.TargetRelation { - span_start1274 := int64(p.spanStart()) + span_start1282 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("relation") - _t2110 := p.parse_relation_id() - relation_id1269 := _t2110 - xs1270 := []*pb.NamedColumn{} - cond1271 := p.matchLookaheadLiteral("(", 0) - for cond1271 { - _t2111 := p.parse_named_column() - item1272 := _t2111 - xs1270 = append(xs1270, item1272) - cond1271 = p.matchLookaheadLiteral("(", 0) - } - named_columns1273 := xs1270 + _t2124 := p.parse_relation_id() + relation_id1277 := _t2124 + xs1278 := []*pb.NamedColumn{} + cond1279 := p.matchLookaheadLiteral("(", 0) + for cond1279 { + _t2125 := p.parse_named_column() + item1280 := _t2125 + xs1278 = append(xs1278, item1280) + cond1279 = p.matchLookaheadLiteral("(", 0) + } + named_columns1281 := xs1278 p.consumeLiteral(")") - _t2112 := &pb.TargetRelation{TargetId: relation_id1269, Values: named_columns1273} - result1275 := _t2112 - p.recordSpan(int(span_start1274), "TargetRelation") - return result1275 + _t2126 := &pb.TargetRelation{TargetId: relation_id1277, Values: named_columns1281} + result1283 := _t2126 + p.recordSpan(int(span_start1282), "TargetRelation") + return result1283 } func (p *Parser) parse_cdc_inserts() []*pb.TargetRelation { p.consumeLiteral("(") p.consumeLiteral("inserts") - xs1276 := []*pb.TargetRelation{} - cond1277 := p.matchLookaheadLiteral("(", 0) - for cond1277 { - _t2113 := p.parse_target_relation() - item1278 := _t2113 - xs1276 = append(xs1276, item1278) - cond1277 = p.matchLookaheadLiteral("(", 0) - } - target_relations1279 := xs1276 + xs1284 := []*pb.TargetRelation{} + cond1285 := p.matchLookaheadLiteral("(", 0) + for cond1285 { + _t2127 := p.parse_target_relation() + item1286 := _t2127 + xs1284 = append(xs1284, item1286) + cond1285 = p.matchLookaheadLiteral("(", 0) + } + target_relations1287 := xs1284 p.consumeLiteral(")") - return target_relations1279 + return target_relations1287 } func (p *Parser) parse_cdc_deletes() []*pb.TargetRelation { p.consumeLiteral("(") p.consumeLiteral("deletes") - xs1280 := []*pb.TargetRelation{} - cond1281 := p.matchLookaheadLiteral("(", 0) - for cond1281 { - _t2114 := p.parse_target_relation() - item1282 := _t2114 - xs1280 = append(xs1280, item1282) - cond1281 = p.matchLookaheadLiteral("(", 0) - } - target_relations1283 := xs1280 + xs1288 := []*pb.TargetRelation{} + cond1289 := p.matchLookaheadLiteral("(", 0) + for cond1289 { + _t2128 := p.parse_target_relation() + item1290 := _t2128 + xs1288 = append(xs1288, item1290) + cond1289 = p.matchLookaheadLiteral("(", 0) + } + target_relations1291 := xs1288 p.consumeLiteral(")") - return target_relations1283 + return target_relations1291 } func (p *Parser) parse_load_errors() *pb.RelationId { - span_start1285 := int64(p.spanStart()) + span_start1293 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("load_errors") - _t2115 := p.parse_relation_id() - relation_id1284 := _t2115 + _t2129 := p.parse_relation_id() + relation_id1292 := _t2129 p.consumeLiteral(")") - result1286 := relation_id1284 - p.recordSpan(int(span_start1285), "RelationId") - return result1286 + result1294 := relation_id1292 + p.recordSpan(int(span_start1293), "RelationId") + return result1294 } func (p *Parser) parse_csv_asof() string { p.consumeLiteral("(") p.consumeLiteral("asof") - string1287 := p.consumeTerminal("STRING").Value.str + string1295 := p.consumeTerminal("STRING").Value.str p.consumeLiteral(")") - return string1287 + return string1295 } func (p *Parser) parse_iceberg_data() *pb.IcebergData { - span_start1294 := int64(p.spanStart()) + span_start1302 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("iceberg_data") - _t2116 := p.parse_iceberg_locator() - iceberg_locator1288 := _t2116 - _t2117 := p.parse_iceberg_catalog_config() - iceberg_catalog_config1289 := _t2117 - _t2118 := p.parse_gnf_columns() - gnf_columns1290 := _t2118 - var _t2119 *string + _t2130 := p.parse_iceberg_locator() + iceberg_locator1296 := _t2130 + _t2131 := p.parse_iceberg_catalog_config() + iceberg_catalog_config1297 := _t2131 + _t2132 := p.parse_gnf_columns() + gnf_columns1298 := _t2132 + var _t2133 *string if (p.matchLookaheadLiteral("(", 0) && p.matchLookaheadLiteral("from_snapshot", 1)) { - _t2120 := p.parse_iceberg_from_snapshot() - _t2119 = ptr(_t2120) + _t2134 := p.parse_iceberg_from_snapshot() + _t2133 = ptr(_t2134) } - iceberg_from_snapshot1291 := _t2119 - var _t2121 *string + iceberg_from_snapshot1299 := _t2133 + var _t2135 *string if p.matchLookaheadLiteral("(", 0) { - _t2122 := p.parse_iceberg_to_snapshot() - _t2121 = ptr(_t2122) + _t2136 := p.parse_iceberg_to_snapshot() + _t2135 = ptr(_t2136) } - iceberg_to_snapshot1292 := _t2121 - _t2123 := p.parse_boolean_value() - boolean_value1293 := _t2123 + iceberg_to_snapshot1300 := _t2135 + _t2137 := p.parse_boolean_value() + boolean_value1301 := _t2137 p.consumeLiteral(")") - _t2124 := p.construct_iceberg_data(iceberg_locator1288, iceberg_catalog_config1289, gnf_columns1290, iceberg_from_snapshot1291, iceberg_to_snapshot1292, boolean_value1293) - result1295 := _t2124 - p.recordSpan(int(span_start1294), "IcebergData") - return result1295 + _t2138 := p.construct_iceberg_data(iceberg_locator1296, iceberg_catalog_config1297, gnf_columns1298, iceberg_from_snapshot1299, iceberg_to_snapshot1300, boolean_value1301) + result1303 := _t2138 + p.recordSpan(int(span_start1302), "IcebergData") + return result1303 } func (p *Parser) parse_iceberg_locator() *pb.IcebergLocator { - span_start1299 := int64(p.spanStart()) + span_start1307 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("iceberg_locator") - _t2125 := p.parse_iceberg_locator_table_name() - iceberg_locator_table_name1296 := _t2125 - _t2126 := p.parse_iceberg_locator_namespace() - iceberg_locator_namespace1297 := _t2126 - _t2127 := p.parse_iceberg_locator_warehouse() - iceberg_locator_warehouse1298 := _t2127 + _t2139 := p.parse_iceberg_locator_table_name() + iceberg_locator_table_name1304 := _t2139 + _t2140 := p.parse_iceberg_locator_namespace() + iceberg_locator_namespace1305 := _t2140 + _t2141 := p.parse_iceberg_locator_warehouse() + iceberg_locator_warehouse1306 := _t2141 p.consumeLiteral(")") - _t2128 := &pb.IcebergLocator{TableName: iceberg_locator_table_name1296, Namespace: iceberg_locator_namespace1297, Warehouse: iceberg_locator_warehouse1298} - result1300 := _t2128 - p.recordSpan(int(span_start1299), "IcebergLocator") - return result1300 + _t2142 := &pb.IcebergLocator{TableName: iceberg_locator_table_name1304, Namespace: iceberg_locator_namespace1305, Warehouse: iceberg_locator_warehouse1306} + result1308 := _t2142 + p.recordSpan(int(span_start1307), "IcebergLocator") + return result1308 } func (p *Parser) parse_iceberg_locator_table_name() string { p.consumeLiteral("(") p.consumeLiteral("table_name") - string1301 := p.consumeTerminal("STRING").Value.str + string1309 := p.consumeTerminal("STRING").Value.str p.consumeLiteral(")") - return string1301 + return string1309 } func (p *Parser) parse_iceberg_locator_namespace() []string { p.consumeLiteral("(") p.consumeLiteral("namespace") - xs1302 := []string{} - cond1303 := p.matchLookaheadTerminal("STRING", 0) - for cond1303 { - item1304 := p.consumeTerminal("STRING").Value.str - xs1302 = append(xs1302, item1304) - cond1303 = p.matchLookaheadTerminal("STRING", 0) - } - strings1305 := xs1302 + xs1310 := []string{} + cond1311 := p.matchLookaheadTerminal("STRING", 0) + for cond1311 { + item1312 := p.consumeTerminal("STRING").Value.str + xs1310 = append(xs1310, item1312) + cond1311 = p.matchLookaheadTerminal("STRING", 0) + } + strings1313 := xs1310 p.consumeLiteral(")") - return strings1305 + return strings1313 } func (p *Parser) parse_iceberg_locator_warehouse() string { p.consumeLiteral("(") p.consumeLiteral("warehouse") - string1306 := p.consumeTerminal("STRING").Value.str + string1314 := p.consumeTerminal("STRING").Value.str p.consumeLiteral(")") - return string1306 + return string1314 } func (p *Parser) parse_iceberg_catalog_config() *pb.IcebergCatalogConfig { - span_start1311 := int64(p.spanStart()) + span_start1319 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("iceberg_catalog_config") - _t2129 := p.parse_iceberg_catalog_uri() - iceberg_catalog_uri1307 := _t2129 - var _t2130 *string + _t2143 := p.parse_iceberg_catalog_uri() + iceberg_catalog_uri1315 := _t2143 + var _t2144 *string if (p.matchLookaheadLiteral("(", 0) && p.matchLookaheadLiteral("scope", 1)) { - _t2131 := p.parse_iceberg_catalog_config_scope() - _t2130 = ptr(_t2131) - } - iceberg_catalog_config_scope1308 := _t2130 - _t2132 := p.parse_iceberg_properties() - iceberg_properties1309 := _t2132 - _t2133 := p.parse_iceberg_auth_properties() - iceberg_auth_properties1310 := _t2133 + _t2145 := p.parse_iceberg_catalog_config_scope() + _t2144 = ptr(_t2145) + } + iceberg_catalog_config_scope1316 := _t2144 + _t2146 := p.parse_iceberg_properties() + iceberg_properties1317 := _t2146 + _t2147 := p.parse_iceberg_auth_properties() + iceberg_auth_properties1318 := _t2147 p.consumeLiteral(")") - _t2134 := p.construct_iceberg_catalog_config(iceberg_catalog_uri1307, iceberg_catalog_config_scope1308, iceberg_properties1309, iceberg_auth_properties1310) - result1312 := _t2134 - p.recordSpan(int(span_start1311), "IcebergCatalogConfig") - return result1312 + _t2148 := p.construct_iceberg_catalog_config(iceberg_catalog_uri1315, iceberg_catalog_config_scope1316, iceberg_properties1317, iceberg_auth_properties1318) + result1320 := _t2148 + p.recordSpan(int(span_start1319), "IcebergCatalogConfig") + return result1320 } func (p *Parser) parse_iceberg_catalog_uri() string { p.consumeLiteral("(") p.consumeLiteral("catalog_uri") - string1313 := p.consumeTerminal("STRING").Value.str + string1321 := p.consumeTerminal("STRING").Value.str p.consumeLiteral(")") - return string1313 + return string1321 } func (p *Parser) parse_iceberg_catalog_config_scope() string { p.consumeLiteral("(") p.consumeLiteral("scope") - string1314 := p.consumeTerminal("STRING").Value.str + string1322 := p.consumeTerminal("STRING").Value.str p.consumeLiteral(")") - return string1314 + return string1322 } func (p *Parser) parse_iceberg_properties() [][]interface{} { p.consumeLiteral("(") p.consumeLiteral("properties") - xs1315 := [][]interface{}{} - cond1316 := p.matchLookaheadLiteral("(", 0) - for cond1316 { - _t2135 := p.parse_iceberg_property_entry() - item1317 := _t2135 - xs1315 = append(xs1315, item1317) - cond1316 = p.matchLookaheadLiteral("(", 0) - } - iceberg_property_entrys1318 := xs1315 + xs1323 := [][]interface{}{} + cond1324 := p.matchLookaheadLiteral("(", 0) + for cond1324 { + _t2149 := p.parse_iceberg_property_entry() + item1325 := _t2149 + xs1323 = append(xs1323, item1325) + cond1324 = p.matchLookaheadLiteral("(", 0) + } + iceberg_property_entrys1326 := xs1323 p.consumeLiteral(")") - return iceberg_property_entrys1318 + return iceberg_property_entrys1326 } func (p *Parser) parse_iceberg_property_entry() []interface{} { p.consumeLiteral("(") p.consumeLiteral("prop") - string1319 := p.consumeTerminal("STRING").Value.str - string_31320 := p.consumeTerminal("STRING").Value.str + string1327 := p.consumeTerminal("STRING").Value.str + string_31328 := p.consumeTerminal("STRING").Value.str p.consumeLiteral(")") - return []interface{}{string1319, string_31320} + return []interface{}{string1327, string_31328} } func (p *Parser) parse_iceberg_auth_properties() [][]interface{} { p.consumeLiteral("(") p.consumeLiteral("auth_properties") - xs1321 := [][]interface{}{} - cond1322 := p.matchLookaheadLiteral("(", 0) - for cond1322 { - _t2136 := p.parse_iceberg_masked_property_entry() - item1323 := _t2136 - xs1321 = append(xs1321, item1323) - cond1322 = p.matchLookaheadLiteral("(", 0) - } - iceberg_masked_property_entrys1324 := xs1321 + xs1329 := [][]interface{}{} + cond1330 := p.matchLookaheadLiteral("(", 0) + for cond1330 { + _t2150 := p.parse_iceberg_masked_property_entry() + item1331 := _t2150 + xs1329 = append(xs1329, item1331) + cond1330 = p.matchLookaheadLiteral("(", 0) + } + iceberg_masked_property_entrys1332 := xs1329 p.consumeLiteral(")") - return iceberg_masked_property_entrys1324 + return iceberg_masked_property_entrys1332 } func (p *Parser) parse_iceberg_masked_property_entry() []interface{} { p.consumeLiteral("(") p.consumeLiteral("prop") - string1325 := p.consumeTerminal("STRING").Value.str - string_31326 := p.consumeTerminal("STRING").Value.str + string1333 := p.consumeTerminal("STRING").Value.str + string_31334 := p.consumeTerminal("STRING").Value.str p.consumeLiteral(")") - return []interface{}{string1325, string_31326} + return []interface{}{string1333, string_31334} } func (p *Parser) parse_iceberg_from_snapshot() string { p.consumeLiteral("(") p.consumeLiteral("from_snapshot") - string1327 := p.consumeTerminal("STRING").Value.str + string1335 := p.consumeTerminal("STRING").Value.str p.consumeLiteral(")") - return string1327 + return string1335 } func (p *Parser) parse_iceberg_to_snapshot() string { p.consumeLiteral("(") p.consumeLiteral("to_snapshot") - string1328 := p.consumeTerminal("STRING").Value.str + string1336 := p.consumeTerminal("STRING").Value.str p.consumeLiteral(")") - return string1328 + return string1336 } func (p *Parser) parse_undefine() *pb.Undefine { - span_start1330 := int64(p.spanStart()) + span_start1338 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("undefine") - _t2137 := p.parse_fragment_id() - fragment_id1329 := _t2137 + _t2151 := p.parse_fragment_id() + fragment_id1337 := _t2151 p.consumeLiteral(")") - _t2138 := &pb.Undefine{FragmentId: fragment_id1329} - result1331 := _t2138 - p.recordSpan(int(span_start1330), "Undefine") - return result1331 + _t2152 := &pb.Undefine{FragmentId: fragment_id1337} + result1339 := _t2152 + p.recordSpan(int(span_start1338), "Undefine") + return result1339 } func (p *Parser) parse_context() *pb.Context { - span_start1336 := int64(p.spanStart()) + span_start1344 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("context") - xs1332 := []*pb.RelationId{} - cond1333 := (p.matchLookaheadLiteral(":", 0) || p.matchLookaheadTerminal("UINT128", 0)) - for cond1333 { - _t2139 := p.parse_relation_id() - item1334 := _t2139 - xs1332 = append(xs1332, item1334) - cond1333 = (p.matchLookaheadLiteral(":", 0) || p.matchLookaheadTerminal("UINT128", 0)) - } - relation_ids1335 := xs1332 + xs1340 := []*pb.RelationId{} + cond1341 := (p.matchLookaheadLiteral(":", 0) || p.matchLookaheadTerminal("UINT128", 0)) + for cond1341 { + _t2153 := p.parse_relation_id() + item1342 := _t2153 + xs1340 = append(xs1340, item1342) + cond1341 = (p.matchLookaheadLiteral(":", 0) || p.matchLookaheadTerminal("UINT128", 0)) + } + relation_ids1343 := xs1340 p.consumeLiteral(")") - _t2140 := &pb.Context{Relations: relation_ids1335} - result1337 := _t2140 - p.recordSpan(int(span_start1336), "Context") - return result1337 + _t2154 := &pb.Context{Relations: relation_ids1343} + result1345 := _t2154 + p.recordSpan(int(span_start1344), "Context") + return result1345 } func (p *Parser) parse_snapshot() *pb.Snapshot { - span_start1343 := int64(p.spanStart()) + span_start1351 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("snapshot") - _t2141 := p.parse_edb_path() - edb_path1338 := _t2141 - xs1339 := []*pb.SnapshotMapping{} - cond1340 := p.matchLookaheadLiteral("[", 0) - for cond1340 { - _t2142 := p.parse_snapshot_mapping() - item1341 := _t2142 - xs1339 = append(xs1339, item1341) - cond1340 = p.matchLookaheadLiteral("[", 0) - } - snapshot_mappings1342 := xs1339 + _t2155 := p.parse_edb_path() + edb_path1346 := _t2155 + xs1347 := []*pb.SnapshotMapping{} + cond1348 := p.matchLookaheadLiteral("[", 0) + for cond1348 { + _t2156 := p.parse_snapshot_mapping() + item1349 := _t2156 + xs1347 = append(xs1347, item1349) + cond1348 = p.matchLookaheadLiteral("[", 0) + } + snapshot_mappings1350 := xs1347 p.consumeLiteral(")") - _t2143 := &pb.Snapshot{Prefix: edb_path1338, Mappings: snapshot_mappings1342} - result1344 := _t2143 - p.recordSpan(int(span_start1343), "Snapshot") - return result1344 + _t2157 := &pb.Snapshot{Prefix: edb_path1346, Mappings: snapshot_mappings1350} + result1352 := _t2157 + p.recordSpan(int(span_start1351), "Snapshot") + return result1352 } func (p *Parser) parse_snapshot_mapping() *pb.SnapshotMapping { - span_start1347 := int64(p.spanStart()) - _t2144 := p.parse_edb_path() - edb_path1345 := _t2144 - _t2145 := p.parse_relation_id() - relation_id1346 := _t2145 - _t2146 := &pb.SnapshotMapping{DestinationPath: edb_path1345, SourceRelation: relation_id1346} - result1348 := _t2146 - p.recordSpan(int(span_start1347), "SnapshotMapping") - return result1348 + span_start1355 := int64(p.spanStart()) + _t2158 := p.parse_edb_path() + edb_path1353 := _t2158 + _t2159 := p.parse_relation_id() + relation_id1354 := _t2159 + _t2160 := &pb.SnapshotMapping{DestinationPath: edb_path1353, SourceRelation: relation_id1354} + result1356 := _t2160 + p.recordSpan(int(span_start1355), "SnapshotMapping") + return result1356 } func (p *Parser) parse_epoch_reads() []*pb.Read { p.consumeLiteral("(") p.consumeLiteral("reads") - xs1349 := []*pb.Read{} - cond1350 := p.matchLookaheadLiteral("(", 0) - for cond1350 { - _t2147 := p.parse_read() - item1351 := _t2147 - xs1349 = append(xs1349, item1351) - cond1350 = p.matchLookaheadLiteral("(", 0) - } - reads1352 := xs1349 + xs1357 := []*pb.Read{} + cond1358 := p.matchLookaheadLiteral("(", 0) + for cond1358 { + _t2161 := p.parse_read() + item1359 := _t2161 + xs1357 = append(xs1357, item1359) + cond1358 = p.matchLookaheadLiteral("(", 0) + } + reads1360 := xs1357 p.consumeLiteral(")") - return reads1352 + return reads1360 } func (p *Parser) parse_read() *pb.Read { - span_start1359 := int64(p.spanStart()) - var _t2148 int64 + span_start1367 := int64(p.spanStart()) + var _t2162 int64 if p.matchLookaheadLiteral("(", 0) { - var _t2149 int64 + var _t2163 int64 if p.matchLookaheadLiteral("what_if", 1) { - _t2149 = 2 + _t2163 = 2 } else { - var _t2150 int64 + var _t2164 int64 if p.matchLookaheadLiteral("output", 1) { - _t2150 = 1 + _t2164 = 1 } else { - var _t2151 int64 + var _t2165 int64 if p.matchLookaheadLiteral("export_iceberg", 1) { - _t2151 = 4 + _t2165 = 4 } else { - var _t2152 int64 + var _t2166 int64 if p.matchLookaheadLiteral("export", 1) { - _t2152 = 4 + _t2166 = 4 } else { - var _t2153 int64 + var _t2167 int64 if p.matchLookaheadLiteral("demand", 1) { - _t2153 = 0 + _t2167 = 0 } else { - var _t2154 int64 + var _t2168 int64 if p.matchLookaheadLiteral("abort", 1) { - _t2154 = 3 + _t2168 = 3 } else { - _t2154 = -1 + _t2168 = -1 } - _t2153 = _t2154 + _t2167 = _t2168 } - _t2152 = _t2153 + _t2166 = _t2167 } - _t2151 = _t2152 + _t2165 = _t2166 } - _t2150 = _t2151 + _t2164 = _t2165 } - _t2149 = _t2150 + _t2163 = _t2164 } - _t2148 = _t2149 + _t2162 = _t2163 } else { - _t2148 = -1 - } - prediction1353 := _t2148 - var _t2155 *pb.Read - if prediction1353 == 4 { - _t2156 := p.parse_export() - export1358 := _t2156 - _t2157 := &pb.Read{} - _t2157.ReadType = &pb.Read_Export{Export: export1358} - _t2155 = _t2157 + _t2162 = -1 + } + prediction1361 := _t2162 + var _t2169 *pb.Read + if prediction1361 == 4 { + _t2170 := p.parse_export() + export1366 := _t2170 + _t2171 := &pb.Read{} + _t2171.ReadType = &pb.Read_Export{Export: export1366} + _t2169 = _t2171 } else { - var _t2158 *pb.Read - if prediction1353 == 3 { - _t2159 := p.parse_abort() - abort1357 := _t2159 - _t2160 := &pb.Read{} - _t2160.ReadType = &pb.Read_Abort{Abort: abort1357} - _t2158 = _t2160 + var _t2172 *pb.Read + if prediction1361 == 3 { + _t2173 := p.parse_abort() + abort1365 := _t2173 + _t2174 := &pb.Read{} + _t2174.ReadType = &pb.Read_Abort{Abort: abort1365} + _t2172 = _t2174 } else { - var _t2161 *pb.Read - if prediction1353 == 2 { - _t2162 := p.parse_what_if() - what_if1356 := _t2162 - _t2163 := &pb.Read{} - _t2163.ReadType = &pb.Read_WhatIf{WhatIf: what_if1356} - _t2161 = _t2163 + var _t2175 *pb.Read + if prediction1361 == 2 { + _t2176 := p.parse_what_if() + what_if1364 := _t2176 + _t2177 := &pb.Read{} + _t2177.ReadType = &pb.Read_WhatIf{WhatIf: what_if1364} + _t2175 = _t2177 } else { - var _t2164 *pb.Read - if prediction1353 == 1 { - _t2165 := p.parse_output() - output1355 := _t2165 - _t2166 := &pb.Read{} - _t2166.ReadType = &pb.Read_Output{Output: output1355} - _t2164 = _t2166 + var _t2178 *pb.Read + if prediction1361 == 1 { + _t2179 := p.parse_output() + output1363 := _t2179 + _t2180 := &pb.Read{} + _t2180.ReadType = &pb.Read_Output{Output: output1363} + _t2178 = _t2180 } else { - var _t2167 *pb.Read - if prediction1353 == 0 { - _t2168 := p.parse_demand() - demand1354 := _t2168 - _t2169 := &pb.Read{} - _t2169.ReadType = &pb.Read_Demand{Demand: demand1354} - _t2167 = _t2169 + var _t2181 *pb.Read + if prediction1361 == 0 { + _t2182 := p.parse_demand() + demand1362 := _t2182 + _t2183 := &pb.Read{} + _t2183.ReadType = &pb.Read_Demand{Demand: demand1362} + _t2181 = _t2183 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in read", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t2164 = _t2167 + _t2178 = _t2181 } - _t2161 = _t2164 + _t2175 = _t2178 } - _t2158 = _t2161 + _t2172 = _t2175 } - _t2155 = _t2158 + _t2169 = _t2172 } - result1360 := _t2155 - p.recordSpan(int(span_start1359), "Read") - return result1360 + result1368 := _t2169 + p.recordSpan(int(span_start1367), "Read") + return result1368 } func (p *Parser) parse_demand() *pb.Demand { - span_start1362 := int64(p.spanStart()) + span_start1370 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("demand") - _t2170 := p.parse_relation_id() - relation_id1361 := _t2170 + _t2184 := p.parse_relation_id() + relation_id1369 := _t2184 p.consumeLiteral(")") - _t2171 := &pb.Demand{RelationId: relation_id1361} - result1363 := _t2171 - p.recordSpan(int(span_start1362), "Demand") - return result1363 + _t2185 := &pb.Demand{RelationId: relation_id1369} + result1371 := _t2185 + p.recordSpan(int(span_start1370), "Demand") + return result1371 } func (p *Parser) parse_output() *pb.Output { - span_start1366 := int64(p.spanStart()) + span_start1374 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("output") - _t2172 := p.parse_name() - name1364 := _t2172 - _t2173 := p.parse_relation_id() - relation_id1365 := _t2173 + _t2186 := p.parse_name() + name1372 := _t2186 + _t2187 := p.parse_relation_id() + relation_id1373 := _t2187 p.consumeLiteral(")") - _t2174 := &pb.Output{Name: name1364, RelationId: relation_id1365} - result1367 := _t2174 - p.recordSpan(int(span_start1366), "Output") - return result1367 + _t2188 := &pb.Output{Name: name1372, RelationId: relation_id1373} + result1375 := _t2188 + p.recordSpan(int(span_start1374), "Output") + return result1375 } func (p *Parser) parse_what_if() *pb.WhatIf { - span_start1370 := int64(p.spanStart()) + span_start1378 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("what_if") - _t2175 := p.parse_name() - name1368 := _t2175 - _t2176 := p.parse_epoch() - epoch1369 := _t2176 + _t2189 := p.parse_name() + name1376 := _t2189 + _t2190 := p.parse_epoch() + epoch1377 := _t2190 p.consumeLiteral(")") - _t2177 := &pb.WhatIf{Branch: name1368, Epoch: epoch1369} - result1371 := _t2177 - p.recordSpan(int(span_start1370), "WhatIf") - return result1371 + _t2191 := &pb.WhatIf{Branch: name1376, Epoch: epoch1377} + result1379 := _t2191 + p.recordSpan(int(span_start1378), "WhatIf") + return result1379 } func (p *Parser) parse_abort() *pb.Abort { - span_start1374 := int64(p.spanStart()) + span_start1382 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("abort") - var _t2178 *string + var _t2192 *string if (p.matchLookaheadLiteral(":", 0) && p.matchLookaheadTerminal("SYMBOL", 1)) { - _t2179 := p.parse_name() - _t2178 = ptr(_t2179) + _t2193 := p.parse_name() + _t2192 = ptr(_t2193) } - name1372 := _t2178 - _t2180 := p.parse_relation_id() - relation_id1373 := _t2180 + name1380 := _t2192 + _t2194 := p.parse_relation_id() + relation_id1381 := _t2194 p.consumeLiteral(")") - _t2181 := &pb.Abort{Name: deref(name1372, "abort"), RelationId: relation_id1373} - result1375 := _t2181 - p.recordSpan(int(span_start1374), "Abort") - return result1375 + _t2195 := &pb.Abort{Name: deref(name1380, "abort"), RelationId: relation_id1381} + result1383 := _t2195 + p.recordSpan(int(span_start1382), "Abort") + return result1383 } func (p *Parser) parse_export() *pb.Export { - span_start1379 := int64(p.spanStart()) - var _t2182 int64 + span_start1387 := int64(p.spanStart()) + var _t2196 int64 if p.matchLookaheadLiteral("(", 0) { - var _t2183 int64 + var _t2197 int64 if p.matchLookaheadLiteral("export_iceberg", 1) { - _t2183 = 1 + _t2197 = 1 } else { - var _t2184 int64 + var _t2198 int64 if p.matchLookaheadLiteral("export", 1) { - _t2184 = 0 + _t2198 = 0 } else { - _t2184 = -1 + _t2198 = -1 } - _t2183 = _t2184 + _t2197 = _t2198 } - _t2182 = _t2183 + _t2196 = _t2197 } else { - _t2182 = -1 + _t2196 = -1 } - prediction1376 := _t2182 - var _t2185 *pb.Export - if prediction1376 == 1 { + prediction1384 := _t2196 + var _t2199 *pb.Export + if prediction1384 == 1 { p.consumeLiteral("(") p.consumeLiteral("export_iceberg") - _t2186 := p.parse_export_iceberg_config() - export_iceberg_config1378 := _t2186 + _t2200 := p.parse_export_iceberg_config() + export_iceberg_config1386 := _t2200 p.consumeLiteral(")") - _t2187 := &pb.Export{} - _t2187.ExportConfig = &pb.Export_IcebergConfig{IcebergConfig: export_iceberg_config1378} - _t2185 = _t2187 + _t2201 := &pb.Export{} + _t2201.ExportConfig = &pb.Export_IcebergConfig{IcebergConfig: export_iceberg_config1386} + _t2199 = _t2201 } else { - var _t2188 *pb.Export - if prediction1376 == 0 { + var _t2202 *pb.Export + if prediction1384 == 0 { p.consumeLiteral("(") p.consumeLiteral("export") - _t2189 := p.parse_export_csv_config() - export_csv_config1377 := _t2189 + _t2203 := p.parse_export_csv_config() + export_csv_config1385 := _t2203 p.consumeLiteral(")") - _t2190 := &pb.Export{} - _t2190.ExportConfig = &pb.Export_CsvConfig{CsvConfig: export_csv_config1377} - _t2188 = _t2190 + _t2204 := &pb.Export{} + _t2204.ExportConfig = &pb.Export_CsvConfig{CsvConfig: export_csv_config1385} + _t2202 = _t2204 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in export", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t2185 = _t2188 + _t2199 = _t2202 } - result1380 := _t2185 - p.recordSpan(int(span_start1379), "Export") - return result1380 + result1388 := _t2199 + p.recordSpan(int(span_start1387), "Export") + return result1388 } func (p *Parser) parse_export_csv_config() *pb.ExportCSVConfig { - span_start1388 := int64(p.spanStart()) - var _t2191 int64 + span_start1396 := int64(p.spanStart()) + var _t2205 int64 if p.matchLookaheadLiteral("(", 0) { - var _t2192 int64 + var _t2206 int64 if p.matchLookaheadLiteral("export_csv_config_v2", 1) { - _t2192 = 0 + _t2206 = 0 } else { - var _t2193 int64 + var _t2207 int64 if p.matchLookaheadLiteral("export_csv_config", 1) { - _t2193 = 1 + _t2207 = 1 } else { - _t2193 = -1 + _t2207 = -1 } - _t2192 = _t2193 + _t2206 = _t2207 } - _t2191 = _t2192 + _t2205 = _t2206 } else { - _t2191 = -1 + _t2205 = -1 } - prediction1381 := _t2191 - var _t2194 *pb.ExportCSVConfig - if prediction1381 == 1 { + prediction1389 := _t2205 + var _t2208 *pb.ExportCSVConfig + if prediction1389 == 1 { p.consumeLiteral("(") p.consumeLiteral("export_csv_config") - _t2195 := p.parse_export_csv_path() - export_csv_path1385 := _t2195 - _t2196 := p.parse_export_csv_columns_list() - export_csv_columns_list1386 := _t2196 - _t2197 := p.parse_config_dict() - config_dict1387 := _t2197 + _t2209 := p.parse_export_csv_path() + export_csv_path1393 := _t2209 + _t2210 := p.parse_export_csv_columns_list() + export_csv_columns_list1394 := _t2210 + _t2211 := p.parse_config_dict() + config_dict1395 := _t2211 p.consumeLiteral(")") - _t2198 := p.construct_export_csv_config(export_csv_path1385, export_csv_columns_list1386, config_dict1387) - _t2194 = _t2198 + _t2212 := p.construct_export_csv_config(export_csv_path1393, export_csv_columns_list1394, config_dict1395) + _t2208 = _t2212 } else { - var _t2199 *pb.ExportCSVConfig - if prediction1381 == 0 { + var _t2213 *pb.ExportCSVConfig + if prediction1389 == 0 { p.consumeLiteral("(") p.consumeLiteral("export_csv_config_v2") - _t2200 := p.parse_export_csv_output_location() - export_csv_output_location1382 := _t2200 - _t2201 := p.parse_export_csv_source() - export_csv_source1383 := _t2201 - _t2202 := p.parse_csv_config() - csv_config1384 := _t2202 + _t2214 := p.parse_export_csv_output_location() + export_csv_output_location1390 := _t2214 + _t2215 := p.parse_export_csv_source() + export_csv_source1391 := _t2215 + _t2216 := p.parse_csv_config() + csv_config1392 := _t2216 p.consumeLiteral(")") - _t2203 := p.construct_export_csv_config_with_location(export_csv_output_location1382, export_csv_source1383, csv_config1384) - _t2199 = _t2203 + _t2217 := p.construct_export_csv_config_with_location(export_csv_output_location1390, export_csv_source1391, csv_config1392) + _t2213 = _t2217 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in export_csv_config", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t2194 = _t2199 + _t2208 = _t2213 } - result1389 := _t2194 - p.recordSpan(int(span_start1388), "ExportCSVConfig") - return result1389 + result1397 := _t2208 + p.recordSpan(int(span_start1396), "ExportCSVConfig") + return result1397 } func (p *Parser) parse_export_csv_output_location() []interface{} { - var _t2204 int64 + var _t2218 int64 if p.matchLookaheadLiteral("(", 0) { - var _t2205 int64 + var _t2219 int64 if p.matchLookaheadLiteral("transaction_output_name", 1) { - _t2205 = 1 + _t2219 = 1 } else { - var _t2206 int64 + var _t2220 int64 if p.matchLookaheadLiteral("path", 1) { - _t2206 = 0 + _t2220 = 0 } else { - _t2206 = -1 + _t2220 = -1 } - _t2205 = _t2206 + _t2219 = _t2220 } - _t2204 = _t2205 + _t2218 = _t2219 } else { - _t2204 = -1 + _t2218 = -1 } - prediction1390 := _t2204 - var _t2207 []interface{} - if prediction1390 == 1 { + prediction1398 := _t2218 + var _t2221 []interface{} + if prediction1398 == 1 { p.consumeLiteral("(") p.consumeLiteral("transaction_output_name") - _t2208 := p.parse_name() - name1392 := _t2208 + _t2222 := p.parse_name() + name1400 := _t2222 p.consumeLiteral(")") - _t2207 = []interface{}{"", name1392} + _t2221 = []interface{}{"", name1400} } else { - var _t2209 []interface{} - if prediction1390 == 0 { + var _t2223 []interface{} + if prediction1398 == 0 { p.consumeLiteral("(") p.consumeLiteral("path") - string1391 := p.consumeTerminal("STRING").Value.str + string1399 := p.consumeTerminal("STRING").Value.str p.consumeLiteral(")") - _t2209 = []interface{}{string1391, ""} + _t2223 = []interface{}{string1399, ""} } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in export_csv_output_location", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t2207 = _t2209 + _t2221 = _t2223 } - return _t2207 + return _t2221 } func (p *Parser) parse_export_csv_source() *pb.ExportCSVSource { - span_start1399 := int64(p.spanStart()) - var _t2210 int64 + span_start1407 := int64(p.spanStart()) + var _t2224 int64 if p.matchLookaheadLiteral("(", 0) { - var _t2211 int64 + var _t2225 int64 if p.matchLookaheadLiteral("table_def", 1) { - _t2211 = 1 + _t2225 = 1 } else { - var _t2212 int64 + var _t2226 int64 if p.matchLookaheadLiteral("gnf_columns", 1) { - _t2212 = 0 + _t2226 = 0 } else { - _t2212 = -1 + _t2226 = -1 } - _t2211 = _t2212 + _t2225 = _t2226 } - _t2210 = _t2211 + _t2224 = _t2225 } else { - _t2210 = -1 + _t2224 = -1 } - prediction1393 := _t2210 - var _t2213 *pb.ExportCSVSource - if prediction1393 == 1 { + prediction1401 := _t2224 + var _t2227 *pb.ExportCSVSource + if prediction1401 == 1 { p.consumeLiteral("(") p.consumeLiteral("table_def") - _t2214 := p.parse_relation_id() - relation_id1398 := _t2214 + _t2228 := p.parse_relation_id() + relation_id1406 := _t2228 p.consumeLiteral(")") - _t2215 := &pb.ExportCSVSource{} - _t2215.CsvSource = &pb.ExportCSVSource_TableDef{TableDef: relation_id1398} - _t2213 = _t2215 + _t2229 := &pb.ExportCSVSource{} + _t2229.CsvSource = &pb.ExportCSVSource_TableDef{TableDef: relation_id1406} + _t2227 = _t2229 } else { - var _t2216 *pb.ExportCSVSource - if prediction1393 == 0 { + var _t2230 *pb.ExportCSVSource + if prediction1401 == 0 { p.consumeLiteral("(") p.consumeLiteral("gnf_columns") - xs1394 := []*pb.ExportCSVColumn{} - cond1395 := p.matchLookaheadLiteral("(", 0) - for cond1395 { - _t2217 := p.parse_export_csv_column() - item1396 := _t2217 - xs1394 = append(xs1394, item1396) - cond1395 = p.matchLookaheadLiteral("(", 0) + xs1402 := []*pb.ExportCSVColumn{} + cond1403 := p.matchLookaheadLiteral("(", 0) + for cond1403 { + _t2231 := p.parse_export_csv_column() + item1404 := _t2231 + xs1402 = append(xs1402, item1404) + cond1403 = p.matchLookaheadLiteral("(", 0) } - export_csv_columns1397 := xs1394 + export_csv_columns1405 := xs1402 p.consumeLiteral(")") - _t2218 := &pb.ExportCSVColumns{Columns: export_csv_columns1397} - _t2219 := &pb.ExportCSVSource{} - _t2219.CsvSource = &pb.ExportCSVSource_GnfColumns{GnfColumns: _t2218} - _t2216 = _t2219 + _t2232 := &pb.ExportCSVColumns{Columns: export_csv_columns1405} + _t2233 := &pb.ExportCSVSource{} + _t2233.CsvSource = &pb.ExportCSVSource_GnfColumns{GnfColumns: _t2232} + _t2230 = _t2233 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in export_csv_source", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t2213 = _t2216 + _t2227 = _t2230 } - result1400 := _t2213 - p.recordSpan(int(span_start1399), "ExportCSVSource") - return result1400 + result1408 := _t2227 + p.recordSpan(int(span_start1407), "ExportCSVSource") + return result1408 } func (p *Parser) parse_export_csv_column() *pb.ExportCSVColumn { - span_start1403 := int64(p.spanStart()) + span_start1411 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("column") - string1401 := p.consumeTerminal("STRING").Value.str - _t2220 := p.parse_relation_id() - relation_id1402 := _t2220 + string1409 := p.consumeTerminal("STRING").Value.str + _t2234 := p.parse_relation_id() + relation_id1410 := _t2234 p.consumeLiteral(")") - _t2221 := &pb.ExportCSVColumn{ColumnName: string1401, ColumnData: relation_id1402} - result1404 := _t2221 - p.recordSpan(int(span_start1403), "ExportCSVColumn") - return result1404 + _t2235 := &pb.ExportCSVColumn{ColumnName: string1409, ColumnData: relation_id1410} + result1412 := _t2235 + p.recordSpan(int(span_start1411), "ExportCSVColumn") + return result1412 } func (p *Parser) parse_export_csv_path() string { p.consumeLiteral("(") p.consumeLiteral("path") - string1405 := p.consumeTerminal("STRING").Value.str + string1413 := p.consumeTerminal("STRING").Value.str p.consumeLiteral(")") - return string1405 + return string1413 } func (p *Parser) parse_export_csv_columns_list() []*pb.ExportCSVColumn { p.consumeLiteral("(") p.consumeLiteral("columns") - xs1406 := []*pb.ExportCSVColumn{} - cond1407 := p.matchLookaheadLiteral("(", 0) - for cond1407 { - _t2222 := p.parse_export_csv_column() - item1408 := _t2222 - xs1406 = append(xs1406, item1408) - cond1407 = p.matchLookaheadLiteral("(", 0) - } - export_csv_columns1409 := xs1406 + xs1414 := []*pb.ExportCSVColumn{} + cond1415 := p.matchLookaheadLiteral("(", 0) + for cond1415 { + _t2236 := p.parse_export_csv_column() + item1416 := _t2236 + xs1414 = append(xs1414, item1416) + cond1415 = p.matchLookaheadLiteral("(", 0) + } + export_csv_columns1417 := xs1414 p.consumeLiteral(")") - return export_csv_columns1409 + return export_csv_columns1417 } func (p *Parser) parse_export_iceberg_config() *pb.ExportIcebergConfig { - span_start1415 := int64(p.spanStart()) + span_start1423 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("export_iceberg_config") - _t2223 := p.parse_iceberg_locator() - iceberg_locator1410 := _t2223 - _t2224 := p.parse_iceberg_catalog_config() - iceberg_catalog_config1411 := _t2224 - _t2225 := p.parse_export_iceberg_table_def() - export_iceberg_table_def1412 := _t2225 - _t2226 := p.parse_iceberg_table_properties() - iceberg_table_properties1413 := _t2226 - var _t2227 [][]interface{} + _t2237 := p.parse_iceberg_locator() + iceberg_locator1418 := _t2237 + _t2238 := p.parse_iceberg_catalog_config() + iceberg_catalog_config1419 := _t2238 + _t2239 := p.parse_export_iceberg_table_def() + export_iceberg_table_def1420 := _t2239 + _t2240 := p.parse_iceberg_table_properties() + iceberg_table_properties1421 := _t2240 + var _t2241 [][]interface{} if p.matchLookaheadLiteral("{", 0) { - _t2228 := p.parse_config_dict() - _t2227 = _t2228 + _t2242 := p.parse_config_dict() + _t2241 = _t2242 } - config_dict1414 := _t2227 + config_dict1422 := _t2241 p.consumeLiteral(")") - _t2229 := p.construct_export_iceberg_config_full(iceberg_locator1410, iceberg_catalog_config1411, export_iceberg_table_def1412, iceberg_table_properties1413, config_dict1414) - result1416 := _t2229 - p.recordSpan(int(span_start1415), "ExportIcebergConfig") - return result1416 + _t2243 := p.construct_export_iceberg_config_full(iceberg_locator1418, iceberg_catalog_config1419, export_iceberg_table_def1420, iceberg_table_properties1421, config_dict1422) + result1424 := _t2243 + p.recordSpan(int(span_start1423), "ExportIcebergConfig") + return result1424 } func (p *Parser) parse_export_iceberg_table_def() *pb.RelationId { - span_start1418 := int64(p.spanStart()) + span_start1426 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("table_def") - _t2230 := p.parse_relation_id() - relation_id1417 := _t2230 + _t2244 := p.parse_relation_id() + relation_id1425 := _t2244 p.consumeLiteral(")") - result1419 := relation_id1417 - p.recordSpan(int(span_start1418), "RelationId") - return result1419 + result1427 := relation_id1425 + p.recordSpan(int(span_start1426), "RelationId") + return result1427 } func (p *Parser) parse_iceberg_table_properties() [][]interface{} { p.consumeLiteral("(") p.consumeLiteral("table_properties") - xs1420 := [][]interface{}{} - cond1421 := p.matchLookaheadLiteral("(", 0) - for cond1421 { - _t2231 := p.parse_iceberg_property_entry() - item1422 := _t2231 - xs1420 = append(xs1420, item1422) - cond1421 = p.matchLookaheadLiteral("(", 0) - } - iceberg_property_entrys1423 := xs1420 + xs1428 := [][]interface{}{} + cond1429 := p.matchLookaheadLiteral("(", 0) + for cond1429 { + _t2245 := p.parse_iceberg_property_entry() + item1430 := _t2245 + xs1428 = append(xs1428, item1430) + cond1429 = p.matchLookaheadLiteral("(", 0) + } + iceberg_property_entrys1431 := xs1428 p.consumeLiteral(")") - return iceberg_property_entrys1423 + return iceberg_property_entrys1431 } diff --git a/sdks/go/src/pretty.go b/sdks/go/src/pretty.go index 63aa196d..df53fb02 100644 --- a/sdks/go/src/pretty.go +++ b/sdks/go/src/pretty.go @@ -364,29 +364,29 @@ func (p *PrettyPrinter) deconstruct_relation_keys(msg *pb.TargetRelations) []int } func (p *PrettyPrinter) deconstruct_load_errors_optional(msg *pb.TargetRelations) *pb.RelationId { - var _t1863 interface{} + var _t1874 interface{} if hasProtoField(msg, "load_errors") { return msg.GetLoadErrors() } - _ = _t1863 + _ = _t1874 return nil } func (p *PrettyPrinter) deconstruct_csv_data_columns_optional(msg *pb.CSVData) []*pb.GNFColumn { - var _t1864 interface{} + var _t1875 interface{} if hasProtoField(msg, "relations") { return nil } - _ = _t1864 + _ = _t1875 return msg.GetColumns() } func (p *PrettyPrinter) deconstruct_csv_data_relations_optional(msg *pb.CSVData) *pb.TargetRelations { - var _t1865 interface{} + var _t1876 interface{} if hasProtoField(msg, "relations") { return msg.GetRelations() } - _ = _t1865 + _ = _t1876 return nil } @@ -395,59 +395,59 @@ func (p *PrettyPrinter) deconstruct_export_csv_output_location(msg *pb.ExportCSV } func (p *PrettyPrinter) _make_value_int32(v int32) *pb.Value { - _t1866 := &pb.Value{} - _t1866.Value = &pb.Value_Int32Value{Int32Value: v} - return _t1866 + _t1877 := &pb.Value{} + _t1877.Value = &pb.Value_Int32Value{Int32Value: v} + return _t1877 } func (p *PrettyPrinter) _make_value_int64(v int64) *pb.Value { - _t1867 := &pb.Value{} - _t1867.Value = &pb.Value_IntValue{IntValue: v} - return _t1867 + _t1878 := &pb.Value{} + _t1878.Value = &pb.Value_IntValue{IntValue: v} + return _t1878 } func (p *PrettyPrinter) _make_value_float64(v float64) *pb.Value { - _t1868 := &pb.Value{} - _t1868.Value = &pb.Value_FloatValue{FloatValue: v} - return _t1868 + _t1879 := &pb.Value{} + _t1879.Value = &pb.Value_FloatValue{FloatValue: v} + return _t1879 } func (p *PrettyPrinter) _make_value_string(v string) *pb.Value { - _t1869 := &pb.Value{} - _t1869.Value = &pb.Value_StringValue{StringValue: v} - return _t1869 + _t1880 := &pb.Value{} + _t1880.Value = &pb.Value_StringValue{StringValue: v} + return _t1880 } func (p *PrettyPrinter) _make_value_boolean(v bool) *pb.Value { - _t1870 := &pb.Value{} - _t1870.Value = &pb.Value_BooleanValue{BooleanValue: v} - return _t1870 + _t1881 := &pb.Value{} + _t1881.Value = &pb.Value_BooleanValue{BooleanValue: v} + return _t1881 } func (p *PrettyPrinter) _make_value_uint128(v *pb.UInt128Value) *pb.Value { - _t1871 := &pb.Value{} - _t1871.Value = &pb.Value_Uint128Value{Uint128Value: v} - return _t1871 + _t1882 := &pb.Value{} + _t1882.Value = &pb.Value_Uint128Value{Uint128Value: v} + return _t1882 } func (p *PrettyPrinter) deconstruct_configure(msg *pb.Configure) [][]interface{} { result := [][]interface{}{} if msg.GetIvmConfig().GetLevel() == pb.MaintenanceLevel_MAINTENANCE_LEVEL_AUTO { - _t1872 := p._make_value_string("auto") - result = append(result, []interface{}{"ivm.maintenance_level", _t1872}) + _t1883 := p._make_value_string("auto") + result = append(result, []interface{}{"ivm.maintenance_level", _t1883}) } else { if msg.GetIvmConfig().GetLevel() == pb.MaintenanceLevel_MAINTENANCE_LEVEL_ALL { - _t1873 := p._make_value_string("all") - result = append(result, []interface{}{"ivm.maintenance_level", _t1873}) + _t1884 := p._make_value_string("all") + result = append(result, []interface{}{"ivm.maintenance_level", _t1884}) } else { if msg.GetIvmConfig().GetLevel() == pb.MaintenanceLevel_MAINTENANCE_LEVEL_OFF { - _t1874 := p._make_value_string("off") - result = append(result, []interface{}{"ivm.maintenance_level", _t1874}) + _t1885 := p._make_value_string("off") + result = append(result, []interface{}{"ivm.maintenance_level", _t1885}) } } } - _t1875 := p._make_value_int64(msg.GetSemanticsVersion()) - result = append(result, []interface{}{"semantics_version", _t1875}) + _t1886 := p._make_value_int64(msg.GetSemanticsVersion()) + result = append(result, []interface{}{"semantics_version", _t1886}) for _, pair := range valueMapToPairs(msg.GetConfigurationValues()) { result = append(result, pair) } @@ -456,130 +456,130 @@ func (p *PrettyPrinter) deconstruct_configure(msg *pb.Configure) [][]interface{} func (p *PrettyPrinter) deconstruct_csv_config(msg *pb.CSVConfig) [][]interface{} { result := [][]interface{}{} - _t1876 := p._make_value_int32(msg.GetHeaderRow()) - result = append(result, []interface{}{"csv_header_row", _t1876}) - _t1877 := p._make_value_int64(msg.GetSkip()) - result = append(result, []interface{}{"csv_skip", _t1877}) + _t1887 := p._make_value_int32(msg.GetHeaderRow()) + result = append(result, []interface{}{"csv_header_row", _t1887}) + _t1888 := p._make_value_int64(msg.GetSkip()) + result = append(result, []interface{}{"csv_skip", _t1888}) if msg.GetNewLine() != "" { - _t1878 := p._make_value_string(msg.GetNewLine()) - result = append(result, []interface{}{"csv_new_line", _t1878}) - } - _t1879 := p._make_value_string(msg.GetDelimiter()) - result = append(result, []interface{}{"csv_delimiter", _t1879}) - _t1880 := p._make_value_string(msg.GetQuotechar()) - result = append(result, []interface{}{"csv_quotechar", _t1880}) - _t1881 := p._make_value_string(msg.GetEscapechar()) - result = append(result, []interface{}{"csv_escapechar", _t1881}) + _t1889 := p._make_value_string(msg.GetNewLine()) + result = append(result, []interface{}{"csv_new_line", _t1889}) + } + _t1890 := p._make_value_string(msg.GetDelimiter()) + result = append(result, []interface{}{"csv_delimiter", _t1890}) + _t1891 := p._make_value_string(msg.GetQuotechar()) + result = append(result, []interface{}{"csv_quotechar", _t1891}) + _t1892 := p._make_value_string(msg.GetEscapechar()) + result = append(result, []interface{}{"csv_escapechar", _t1892}) if msg.GetComment() != "" { - _t1882 := p._make_value_string(msg.GetComment()) - result = append(result, []interface{}{"csv_comment", _t1882}) + _t1893 := p._make_value_string(msg.GetComment()) + result = append(result, []interface{}{"csv_comment", _t1893}) } for _, missing_string := range msg.GetMissingStrings() { - _t1883 := p._make_value_string(missing_string) - result = append(result, []interface{}{"csv_missing_strings", _t1883}) - } - _t1884 := p._make_value_string(msg.GetDecimalSeparator()) - result = append(result, []interface{}{"csv_decimal_separator", _t1884}) - _t1885 := p._make_value_string(msg.GetEncoding()) - result = append(result, []interface{}{"csv_encoding", _t1885}) - _t1886 := p._make_value_string(msg.GetCompression()) - result = append(result, []interface{}{"csv_compression", _t1886}) + _t1894 := p._make_value_string(missing_string) + result = append(result, []interface{}{"csv_missing_strings", _t1894}) + } + _t1895 := p._make_value_string(msg.GetDecimalSeparator()) + result = append(result, []interface{}{"csv_decimal_separator", _t1895}) + _t1896 := p._make_value_string(msg.GetEncoding()) + result = append(result, []interface{}{"csv_encoding", _t1896}) + _t1897 := p._make_value_string(msg.GetCompression()) + result = append(result, []interface{}{"csv_compression", _t1897}) if msg.GetPartitionSizeMb() != 0 { - _t1887 := p._make_value_int64(msg.GetPartitionSizeMb()) - result = append(result, []interface{}{"csv_partition_size_mb", _t1887}) + _t1898 := p._make_value_int64(msg.GetPartitionSizeMb()) + result = append(result, []interface{}{"csv_partition_size_mb", _t1898}) } return listSort(result) } func (p *PrettyPrinter) deconstruct_csv_storage_integration_optional(msg *pb.CSVConfig) [][]interface{} { - var _t1888 interface{} + var _t1899 interface{} if !(hasProtoField(msg, "storage_integration")) { return nil } - _ = _t1888 + _ = _t1899 si := msg.GetStorageIntegration() result := [][]interface{}{} if si.GetProvider() != "" { - _t1889 := p._make_value_string(si.GetProvider()) - result = append(result, []interface{}{"provider", _t1889}) + _t1900 := p._make_value_string(si.GetProvider()) + result = append(result, []interface{}{"provider", _t1900}) } if si.GetAzureSasToken() != "" { - _t1890 := p._make_value_string("***") - result = append(result, []interface{}{"azure_sas_token", _t1890}) + _t1901 := p._make_value_string("***") + result = append(result, []interface{}{"azure_sas_token", _t1901}) } if si.GetS3Region() != "" { - _t1891 := p._make_value_string(si.GetS3Region()) - result = append(result, []interface{}{"s3_region", _t1891}) + _t1902 := p._make_value_string(si.GetS3Region()) + result = append(result, []interface{}{"s3_region", _t1902}) } if si.GetS3AccessKeyId() != "" { - _t1892 := p._make_value_string("***") - result = append(result, []interface{}{"s3_access_key_id", _t1892}) + _t1903 := p._make_value_string("***") + result = append(result, []interface{}{"s3_access_key_id", _t1903}) } if si.GetS3SecretAccessKey() != "" { - _t1893 := p._make_value_string("***") - result = append(result, []interface{}{"s3_secret_access_key", _t1893}) + _t1904 := p._make_value_string("***") + result = append(result, []interface{}{"s3_secret_access_key", _t1904}) } return listSort(result) } func (p *PrettyPrinter) deconstruct_betree_info_config(msg *pb.BeTreeInfo) [][]interface{} { result := [][]interface{}{} - _t1894 := p._make_value_float64(msg.GetStorageConfig().GetEpsilon()) - result = append(result, []interface{}{"betree_config_epsilon", _t1894}) - _t1895 := p._make_value_int64(msg.GetStorageConfig().GetMaxPivots()) - result = append(result, []interface{}{"betree_config_max_pivots", _t1895}) - _t1896 := p._make_value_int64(msg.GetStorageConfig().GetMaxDeltas()) - result = append(result, []interface{}{"betree_config_max_deltas", _t1896}) - _t1897 := p._make_value_int64(msg.GetStorageConfig().GetMaxLeaf()) - result = append(result, []interface{}{"betree_config_max_leaf", _t1897}) + _t1905 := p._make_value_float64(msg.GetStorageConfig().GetEpsilon()) + result = append(result, []interface{}{"betree_config_epsilon", _t1905}) + _t1906 := p._make_value_int64(msg.GetStorageConfig().GetMaxPivots()) + result = append(result, []interface{}{"betree_config_max_pivots", _t1906}) + _t1907 := p._make_value_int64(msg.GetStorageConfig().GetMaxDeltas()) + result = append(result, []interface{}{"betree_config_max_deltas", _t1907}) + _t1908 := p._make_value_int64(msg.GetStorageConfig().GetMaxLeaf()) + result = append(result, []interface{}{"betree_config_max_leaf", _t1908}) if hasProtoField(msg.GetRelationLocator(), "root_pageid") { if msg.GetRelationLocator().GetRootPageid() != nil { - _t1898 := p._make_value_uint128(msg.GetRelationLocator().GetRootPageid()) - result = append(result, []interface{}{"betree_locator_root_pageid", _t1898}) + _t1909 := p._make_value_uint128(msg.GetRelationLocator().GetRootPageid()) + result = append(result, []interface{}{"betree_locator_root_pageid", _t1909}) } } if hasProtoField(msg.GetRelationLocator(), "inline_data") { if msg.GetRelationLocator().GetInlineData() != nil { - _t1899 := p._make_value_string(string(msg.GetRelationLocator().GetInlineData())) - result = append(result, []interface{}{"betree_locator_inline_data", _t1899}) + _t1910 := p._make_value_string(string(msg.GetRelationLocator().GetInlineData())) + result = append(result, []interface{}{"betree_locator_inline_data", _t1910}) } } - _t1900 := p._make_value_int64(msg.GetRelationLocator().GetElementCount()) - result = append(result, []interface{}{"betree_locator_element_count", _t1900}) - _t1901 := p._make_value_int64(msg.GetRelationLocator().GetTreeHeight()) - result = append(result, []interface{}{"betree_locator_tree_height", _t1901}) + _t1911 := p._make_value_int64(msg.GetRelationLocator().GetElementCount()) + result = append(result, []interface{}{"betree_locator_element_count", _t1911}) + _t1912 := p._make_value_int64(msg.GetRelationLocator().GetTreeHeight()) + result = append(result, []interface{}{"betree_locator_tree_height", _t1912}) return listSort(result) } func (p *PrettyPrinter) deconstruct_export_csv_config(msg *pb.ExportCSVConfig) [][]interface{} { result := [][]interface{}{} if msg.PartitionSize != nil { - _t1902 := p._make_value_int64(*msg.PartitionSize) - result = append(result, []interface{}{"partition_size", _t1902}) + _t1913 := p._make_value_int64(*msg.PartitionSize) + result = append(result, []interface{}{"partition_size", _t1913}) } if msg.Compression != nil { - _t1903 := p._make_value_string(*msg.Compression) - result = append(result, []interface{}{"compression", _t1903}) + _t1914 := p._make_value_string(*msg.Compression) + result = append(result, []interface{}{"compression", _t1914}) } if msg.SyntaxHeaderRow != nil { - _t1904 := p._make_value_boolean(*msg.SyntaxHeaderRow) - result = append(result, []interface{}{"syntax_header_row", _t1904}) + _t1915 := p._make_value_boolean(*msg.SyntaxHeaderRow) + result = append(result, []interface{}{"syntax_header_row", _t1915}) } if msg.SyntaxMissingString != nil { - _t1905 := p._make_value_string(*msg.SyntaxMissingString) - result = append(result, []interface{}{"syntax_missing_string", _t1905}) + _t1916 := p._make_value_string(*msg.SyntaxMissingString) + result = append(result, []interface{}{"syntax_missing_string", _t1916}) } if msg.SyntaxDelim != nil { - _t1906 := p._make_value_string(*msg.SyntaxDelim) - result = append(result, []interface{}{"syntax_delim", _t1906}) + _t1917 := p._make_value_string(*msg.SyntaxDelim) + result = append(result, []interface{}{"syntax_delim", _t1917}) } if msg.SyntaxQuotechar != nil { - _t1907 := p._make_value_string(*msg.SyntaxQuotechar) - result = append(result, []interface{}{"syntax_quotechar", _t1907}) + _t1918 := p._make_value_string(*msg.SyntaxQuotechar) + result = append(result, []interface{}{"syntax_quotechar", _t1918}) } if msg.SyntaxEscapechar != nil { - _t1908 := p._make_value_string(*msg.SyntaxEscapechar) - result = append(result, []interface{}{"syntax_escapechar", _t1908}) + _t1919 := p._make_value_string(*msg.SyntaxEscapechar) + result = append(result, []interface{}{"syntax_escapechar", _t1919}) } return listSort(result) } @@ -589,51 +589,51 @@ func (p *PrettyPrinter) mask_secret_value(pair []interface{}) string { } func (p *PrettyPrinter) deconstruct_iceberg_catalog_config_scope_optional(msg *pb.IcebergCatalogConfig) *string { - var _t1909 interface{} + var _t1920 interface{} if *msg.Scope != "" { return ptr(*msg.Scope) } - _ = _t1909 + _ = _t1920 return nil } func (p *PrettyPrinter) deconstruct_iceberg_data_from_snapshot_optional(msg *pb.IcebergData) *string { - var _t1910 interface{} + var _t1921 interface{} if *msg.FromSnapshot != "" { return ptr(*msg.FromSnapshot) } - _ = _t1910 + _ = _t1921 return nil } func (p *PrettyPrinter) deconstruct_iceberg_data_to_snapshot_optional(msg *pb.IcebergData) *string { - var _t1911 interface{} + var _t1922 interface{} if *msg.ToSnapshot != "" { return ptr(*msg.ToSnapshot) } - _ = _t1911 + _ = _t1922 return nil } func (p *PrettyPrinter) deconstruct_export_iceberg_config_optional(msg *pb.ExportIcebergConfig) [][]interface{} { result := [][]interface{}{} if *msg.Prefix != "" { - _t1912 := p._make_value_string(*msg.Prefix) - result = append(result, []interface{}{"prefix", _t1912}) + _t1923 := p._make_value_string(*msg.Prefix) + result = append(result, []interface{}{"prefix", _t1923}) } if *msg.TargetFileSizeBytes != 0 { - _t1913 := p._make_value_int64(*msg.TargetFileSizeBytes) - result = append(result, []interface{}{"target_file_size_bytes", _t1913}) + _t1924 := p._make_value_int64(*msg.TargetFileSizeBytes) + result = append(result, []interface{}{"target_file_size_bytes", _t1924}) } if msg.GetCompression() != "" { - _t1914 := p._make_value_string(msg.GetCompression()) - result = append(result, []interface{}{"compression", _t1914}) + _t1925 := p._make_value_string(msg.GetCompression()) + result = append(result, []interface{}{"compression", _t1925}) } - var _t1915 interface{} + var _t1926 interface{} if int64(len(result)) == 0 { return nil } - _ = _t1915 + _ = _t1926 return listSort(result) } @@ -644,11 +644,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 _t1916 interface{} + var _t1927 interface{} if name == nil { return p.relationIdToUint128(msg) } - _ = _t1916 + _ = _t1927 return nil } @@ -666,45 +666,45 @@ func (p *PrettyPrinter) deconstruct_bindings_with_arity(abs *pb.Abstraction, val // --- Pretty-print methods --- func (p *PrettyPrinter) pretty_transaction(msg *pb.Transaction) interface{} { - flat863 := p.tryFlat(msg, func() { p.pretty_transaction(msg) }) - if flat863 != nil { - p.write(*flat863) + flat868 := p.tryFlat(msg, func() { p.pretty_transaction(msg) }) + if flat868 != nil { + p.write(*flat868) return nil } else { _dollar_dollar := msg - var _t1708 *pb.Configure + var _t1718 *pb.Configure if hasProtoField(_dollar_dollar, "configure") { - _t1708 = _dollar_dollar.GetConfigure() + _t1718 = _dollar_dollar.GetConfigure() } - var _t1709 *pb.Sync + var _t1719 *pb.Sync if hasProtoField(_dollar_dollar, "sync") { - _t1709 = _dollar_dollar.GetSync() + _t1719 = _dollar_dollar.GetSync() } - fields854 := []interface{}{_t1708, _t1709, _dollar_dollar.GetEpochs()} - unwrapped_fields855 := fields854 + fields859 := []interface{}{_t1718, _t1719, _dollar_dollar.GetEpochs()} + unwrapped_fields860 := fields859 p.write("(") p.write("transaction") p.indentSexp() - field856 := unwrapped_fields855[0].(*pb.Configure) - if field856 != nil { + field861 := unwrapped_fields860[0].(*pb.Configure) + if field861 != nil { p.newline() - opt_val857 := field856 - p.pretty_configure(opt_val857) + opt_val862 := field861 + p.pretty_configure(opt_val862) } - field858 := unwrapped_fields855[1].(*pb.Sync) - if field858 != nil { + field863 := unwrapped_fields860[1].(*pb.Sync) + if field863 != nil { p.newline() - opt_val859 := field858 - p.pretty_sync(opt_val859) + opt_val864 := field863 + p.pretty_sync(opt_val864) } - field860 := unwrapped_fields855[2].([]*pb.Epoch) - if !(len(field860) == 0) { + field865 := unwrapped_fields860[2].([]*pb.Epoch) + if !(len(field865) == 0) { p.newline() - for i862, elem861 := range field860 { - if (i862 > 0) { + for i867, elem866 := range field865 { + if (i867 > 0) { p.newline() } - p.pretty_epoch(elem861) + p.pretty_epoch(elem866) } } p.dedent() @@ -714,20 +714,20 @@ func (p *PrettyPrinter) pretty_transaction(msg *pb.Transaction) interface{} { } func (p *PrettyPrinter) pretty_configure(msg *pb.Configure) interface{} { - flat866 := p.tryFlat(msg, func() { p.pretty_configure(msg) }) - if flat866 != nil { - p.write(*flat866) + flat871 := p.tryFlat(msg, func() { p.pretty_configure(msg) }) + if flat871 != nil { + p.write(*flat871) return nil } else { _dollar_dollar := msg - _t1710 := p.deconstruct_configure(_dollar_dollar) - fields864 := _t1710 - unwrapped_fields865 := fields864 + _t1720 := p.deconstruct_configure(_dollar_dollar) + fields869 := _t1720 + unwrapped_fields870 := fields869 p.write("(") p.write("configure") p.indentSexp() p.newline() - p.pretty_config_dict(unwrapped_fields865) + p.pretty_config_dict(unwrapped_fields870) p.dedent() p.write(")") } @@ -735,21 +735,21 @@ func (p *PrettyPrinter) pretty_configure(msg *pb.Configure) interface{} { } func (p *PrettyPrinter) pretty_config_dict(msg [][]interface{}) interface{} { - flat870 := p.tryFlat(msg, func() { p.pretty_config_dict(msg) }) - if flat870 != nil { - p.write(*flat870) + flat875 := p.tryFlat(msg, func() { p.pretty_config_dict(msg) }) + if flat875 != nil { + p.write(*flat875) return nil } else { - fields867 := msg + fields872 := msg p.write("{") p.indent() - if !(len(fields867) == 0) { + if !(len(fields872) == 0) { p.newline() - for i869, elem868 := range fields867 { - if (i869 > 0) { + for i874, elem873 := range fields872 { + if (i874 > 0) { p.newline() } - p.pretty_config_key_value(elem868) + p.pretty_config_key_value(elem873) } } p.dedent() @@ -759,152 +759,152 @@ func (p *PrettyPrinter) pretty_config_dict(msg [][]interface{}) interface{} { } func (p *PrettyPrinter) pretty_config_key_value(msg []interface{}) interface{} { - flat875 := p.tryFlat(msg, func() { p.pretty_config_key_value(msg) }) - if flat875 != nil { - p.write(*flat875) + flat880 := p.tryFlat(msg, func() { p.pretty_config_key_value(msg) }) + if flat880 != nil { + p.write(*flat880) return nil } else { _dollar_dollar := msg - fields871 := []interface{}{_dollar_dollar[0].(string), _dollar_dollar[1].(*pb.Value)} - unwrapped_fields872 := fields871 + fields876 := []interface{}{_dollar_dollar[0].(string), _dollar_dollar[1].(*pb.Value)} + unwrapped_fields877 := fields876 p.write(":") - field873 := unwrapped_fields872[0].(string) - p.write(field873) + field878 := unwrapped_fields877[0].(string) + p.write(field878) p.write(" ") - field874 := unwrapped_fields872[1].(*pb.Value) - p.pretty_raw_value(field874) + field879 := unwrapped_fields877[1].(*pb.Value) + p.pretty_raw_value(field879) } return nil } func (p *PrettyPrinter) pretty_raw_value(msg *pb.Value) interface{} { - flat901 := p.tryFlat(msg, func() { p.pretty_raw_value(msg) }) - if flat901 != nil { - p.write(*flat901) + flat906 := p.tryFlat(msg, func() { p.pretty_raw_value(msg) }) + if flat906 != nil { + p.write(*flat906) return nil } else { _dollar_dollar := msg - var _t1711 *pb.DateValue + var _t1721 *pb.DateValue if hasProtoField(_dollar_dollar, "date_value") { - _t1711 = _dollar_dollar.GetDateValue() + _t1721 = _dollar_dollar.GetDateValue() } - deconstruct_result899 := _t1711 - if deconstruct_result899 != nil { - unwrapped900 := deconstruct_result899 - p.pretty_raw_date(unwrapped900) + deconstruct_result904 := _t1721 + if deconstruct_result904 != nil { + unwrapped905 := deconstruct_result904 + p.pretty_raw_date(unwrapped905) } else { _dollar_dollar := msg - var _t1712 *pb.DateTimeValue + var _t1722 *pb.DateTimeValue if hasProtoField(_dollar_dollar, "datetime_value") { - _t1712 = _dollar_dollar.GetDatetimeValue() + _t1722 = _dollar_dollar.GetDatetimeValue() } - deconstruct_result897 := _t1712 - if deconstruct_result897 != nil { - unwrapped898 := deconstruct_result897 - p.pretty_raw_datetime(unwrapped898) + deconstruct_result902 := _t1722 + if deconstruct_result902 != nil { + unwrapped903 := deconstruct_result902 + p.pretty_raw_datetime(unwrapped903) } else { _dollar_dollar := msg - var _t1713 *string + var _t1723 *string if hasProtoField(_dollar_dollar, "string_value") { - _t1713 = ptr(_dollar_dollar.GetStringValue()) + _t1723 = ptr(_dollar_dollar.GetStringValue()) } - deconstruct_result895 := _t1713 - if deconstruct_result895 != nil { - unwrapped896 := *deconstruct_result895 - p.write(p.formatStringValue(unwrapped896)) + deconstruct_result900 := _t1723 + if deconstruct_result900 != nil { + unwrapped901 := *deconstruct_result900 + p.write(p.formatStringValue(unwrapped901)) } else { _dollar_dollar := msg - var _t1714 *int32 + var _t1724 *int32 if hasProtoField(_dollar_dollar, "int32_value") { - _t1714 = ptr(_dollar_dollar.GetInt32Value()) + _t1724 = ptr(_dollar_dollar.GetInt32Value()) } - deconstruct_result893 := _t1714 - if deconstruct_result893 != nil { - unwrapped894 := *deconstruct_result893 - p.write(fmt.Sprintf("%di32", unwrapped894)) + deconstruct_result898 := _t1724 + if deconstruct_result898 != nil { + unwrapped899 := *deconstruct_result898 + p.write(fmt.Sprintf("%di32", unwrapped899)) } else { _dollar_dollar := msg - var _t1715 *int64 + var _t1725 *int64 if hasProtoField(_dollar_dollar, "int_value") { - _t1715 = ptr(_dollar_dollar.GetIntValue()) + _t1725 = ptr(_dollar_dollar.GetIntValue()) } - deconstruct_result891 := _t1715 - if deconstruct_result891 != nil { - unwrapped892 := *deconstruct_result891 - p.write(fmt.Sprintf("%d", unwrapped892)) + deconstruct_result896 := _t1725 + if deconstruct_result896 != nil { + unwrapped897 := *deconstruct_result896 + p.write(fmt.Sprintf("%d", unwrapped897)) } else { _dollar_dollar := msg - var _t1716 *float32 + var _t1726 *float32 if hasProtoField(_dollar_dollar, "float32_value") { - _t1716 = ptr(_dollar_dollar.GetFloat32Value()) + _t1726 = ptr(_dollar_dollar.GetFloat32Value()) } - deconstruct_result889 := _t1716 - if deconstruct_result889 != nil { - unwrapped890 := *deconstruct_result889 - p.write(formatFloat32(unwrapped890)) + deconstruct_result894 := _t1726 + if deconstruct_result894 != nil { + unwrapped895 := *deconstruct_result894 + p.write(formatFloat32(unwrapped895)) } else { _dollar_dollar := msg - var _t1717 *float64 + var _t1727 *float64 if hasProtoField(_dollar_dollar, "float_value") { - _t1717 = ptr(_dollar_dollar.GetFloatValue()) + _t1727 = ptr(_dollar_dollar.GetFloatValue()) } - deconstruct_result887 := _t1717 - if deconstruct_result887 != nil { - unwrapped888 := *deconstruct_result887 - p.write(formatFloat64(unwrapped888)) + deconstruct_result892 := _t1727 + if deconstruct_result892 != nil { + unwrapped893 := *deconstruct_result892 + p.write(formatFloat64(unwrapped893)) } else { _dollar_dollar := msg - var _t1718 *uint32 + var _t1728 *uint32 if hasProtoField(_dollar_dollar, "uint32_value") { - _t1718 = ptr(_dollar_dollar.GetUint32Value()) + _t1728 = ptr(_dollar_dollar.GetUint32Value()) } - deconstruct_result885 := _t1718 - if deconstruct_result885 != nil { - unwrapped886 := *deconstruct_result885 - p.write(fmt.Sprintf("%du32", unwrapped886)) + deconstruct_result890 := _t1728 + if deconstruct_result890 != nil { + unwrapped891 := *deconstruct_result890 + p.write(fmt.Sprintf("%du32", unwrapped891)) } else { _dollar_dollar := msg - var _t1719 *pb.UInt128Value + var _t1729 *pb.UInt128Value if hasProtoField(_dollar_dollar, "uint128_value") { - _t1719 = _dollar_dollar.GetUint128Value() + _t1729 = _dollar_dollar.GetUint128Value() } - deconstruct_result883 := _t1719 - if deconstruct_result883 != nil { - unwrapped884 := deconstruct_result883 - p.write(p.formatUint128(unwrapped884)) + deconstruct_result888 := _t1729 + if deconstruct_result888 != nil { + unwrapped889 := deconstruct_result888 + p.write(p.formatUint128(unwrapped889)) } else { _dollar_dollar := msg - var _t1720 *pb.Int128Value + var _t1730 *pb.Int128Value if hasProtoField(_dollar_dollar, "int128_value") { - _t1720 = _dollar_dollar.GetInt128Value() + _t1730 = _dollar_dollar.GetInt128Value() } - deconstruct_result881 := _t1720 - if deconstruct_result881 != nil { - unwrapped882 := deconstruct_result881 - p.write(p.formatInt128(unwrapped882)) + deconstruct_result886 := _t1730 + if deconstruct_result886 != nil { + unwrapped887 := deconstruct_result886 + p.write(p.formatInt128(unwrapped887)) } else { _dollar_dollar := msg - var _t1721 *pb.DecimalValue + var _t1731 *pb.DecimalValue if hasProtoField(_dollar_dollar, "decimal_value") { - _t1721 = _dollar_dollar.GetDecimalValue() + _t1731 = _dollar_dollar.GetDecimalValue() } - deconstruct_result879 := _t1721 - if deconstruct_result879 != nil { - unwrapped880 := deconstruct_result879 - p.write(p.formatDecimal(unwrapped880)) + deconstruct_result884 := _t1731 + if deconstruct_result884 != nil { + unwrapped885 := deconstruct_result884 + p.write(p.formatDecimal(unwrapped885)) } else { _dollar_dollar := msg - var _t1722 *bool + var _t1732 *bool if hasProtoField(_dollar_dollar, "boolean_value") { - _t1722 = ptr(_dollar_dollar.GetBooleanValue()) + _t1732 = ptr(_dollar_dollar.GetBooleanValue()) } - deconstruct_result877 := _t1722 - if deconstruct_result877 != nil { - unwrapped878 := *deconstruct_result877 - p.pretty_boolean_value(unwrapped878) + deconstruct_result882 := _t1732 + if deconstruct_result882 != nil { + unwrapped883 := *deconstruct_result882 + p.pretty_boolean_value(unwrapped883) } else { - fields876 := msg - _ = fields876 + fields881 := msg + _ = fields881 p.write("missing") } } @@ -923,26 +923,26 @@ func (p *PrettyPrinter) pretty_raw_value(msg *pb.Value) interface{} { } func (p *PrettyPrinter) pretty_raw_date(msg *pb.DateValue) interface{} { - flat907 := p.tryFlat(msg, func() { p.pretty_raw_date(msg) }) - if flat907 != nil { - p.write(*flat907) + flat912 := p.tryFlat(msg, func() { p.pretty_raw_date(msg) }) + if flat912 != nil { + p.write(*flat912) return nil } else { _dollar_dollar := msg - fields902 := []interface{}{int64(_dollar_dollar.GetYear()), int64(_dollar_dollar.GetMonth()), int64(_dollar_dollar.GetDay())} - unwrapped_fields903 := fields902 + fields907 := []interface{}{int64(_dollar_dollar.GetYear()), int64(_dollar_dollar.GetMonth()), int64(_dollar_dollar.GetDay())} + unwrapped_fields908 := fields907 p.write("(") p.write("date") p.indentSexp() p.newline() - field904 := unwrapped_fields903[0].(int64) - p.write(fmt.Sprintf("%d", field904)) + field909 := unwrapped_fields908[0].(int64) + p.write(fmt.Sprintf("%d", field909)) p.newline() - field905 := unwrapped_fields903[1].(int64) - p.write(fmt.Sprintf("%d", field905)) + field910 := unwrapped_fields908[1].(int64) + p.write(fmt.Sprintf("%d", field910)) p.newline() - field906 := unwrapped_fields903[2].(int64) - p.write(fmt.Sprintf("%d", field906)) + field911 := unwrapped_fields908[2].(int64) + p.write(fmt.Sprintf("%d", field911)) p.dedent() p.write(")") } @@ -950,40 +950,40 @@ func (p *PrettyPrinter) pretty_raw_date(msg *pb.DateValue) interface{} { } func (p *PrettyPrinter) pretty_raw_datetime(msg *pb.DateTimeValue) interface{} { - flat918 := p.tryFlat(msg, func() { p.pretty_raw_datetime(msg) }) - if flat918 != nil { - p.write(*flat918) + flat923 := p.tryFlat(msg, func() { p.pretty_raw_datetime(msg) }) + if flat923 != nil { + p.write(*flat923) return nil } else { _dollar_dollar := msg - fields908 := []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_fields909 := fields908 + fields913 := []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_fields914 := fields913 p.write("(") p.write("datetime") p.indentSexp() p.newline() - field910 := unwrapped_fields909[0].(int64) - p.write(fmt.Sprintf("%d", field910)) + field915 := unwrapped_fields914[0].(int64) + p.write(fmt.Sprintf("%d", field915)) p.newline() - field911 := unwrapped_fields909[1].(int64) - p.write(fmt.Sprintf("%d", field911)) + field916 := unwrapped_fields914[1].(int64) + p.write(fmt.Sprintf("%d", field916)) p.newline() - field912 := unwrapped_fields909[2].(int64) - p.write(fmt.Sprintf("%d", field912)) + field917 := unwrapped_fields914[2].(int64) + p.write(fmt.Sprintf("%d", field917)) p.newline() - field913 := unwrapped_fields909[3].(int64) - p.write(fmt.Sprintf("%d", field913)) + field918 := unwrapped_fields914[3].(int64) + p.write(fmt.Sprintf("%d", field918)) p.newline() - field914 := unwrapped_fields909[4].(int64) - p.write(fmt.Sprintf("%d", field914)) + field919 := unwrapped_fields914[4].(int64) + p.write(fmt.Sprintf("%d", field919)) p.newline() - field915 := unwrapped_fields909[5].(int64) - p.write(fmt.Sprintf("%d", field915)) - field916 := unwrapped_fields909[6].(*int64) - if field916 != nil { + field920 := unwrapped_fields914[5].(int64) + p.write(fmt.Sprintf("%d", field920)) + field921 := unwrapped_fields914[6].(*int64) + if field921 != nil { p.newline() - opt_val917 := *field916 - p.write(fmt.Sprintf("%d", opt_val917)) + opt_val922 := *field921 + p.write(fmt.Sprintf("%d", opt_val922)) } p.dedent() p.write(")") @@ -993,25 +993,25 @@ func (p *PrettyPrinter) pretty_raw_datetime(msg *pb.DateTimeValue) interface{} { func (p *PrettyPrinter) pretty_boolean_value(msg bool) interface{} { _dollar_dollar := msg - var _t1723 []interface{} + var _t1733 []interface{} if _dollar_dollar { - _t1723 = []interface{}{} + _t1733 = []interface{}{} } - deconstruct_result921 := _t1723 - if deconstruct_result921 != nil { - unwrapped922 := deconstruct_result921 - _ = unwrapped922 + deconstruct_result926 := _t1733 + if deconstruct_result926 != nil { + unwrapped927 := deconstruct_result926 + _ = unwrapped927 p.write("true") } else { _dollar_dollar := msg - var _t1724 []interface{} + var _t1734 []interface{} if !(_dollar_dollar) { - _t1724 = []interface{}{} + _t1734 = []interface{}{} } - deconstruct_result919 := _t1724 - if deconstruct_result919 != nil { - unwrapped920 := deconstruct_result919 - _ = unwrapped920 + deconstruct_result924 := _t1734 + if deconstruct_result924 != nil { + unwrapped925 := deconstruct_result924 + _ = unwrapped925 p.write("false") } else { panic(ParseError{msg: "No matching rule for boolean_value"}) @@ -1021,24 +1021,24 @@ func (p *PrettyPrinter) pretty_boolean_value(msg bool) interface{} { } func (p *PrettyPrinter) pretty_sync(msg *pb.Sync) interface{} { - flat927 := p.tryFlat(msg, func() { p.pretty_sync(msg) }) - if flat927 != nil { - p.write(*flat927) + flat932 := p.tryFlat(msg, func() { p.pretty_sync(msg) }) + if flat932 != nil { + p.write(*flat932) return nil } else { _dollar_dollar := msg - fields923 := _dollar_dollar.GetFragments() - unwrapped_fields924 := fields923 + fields928 := _dollar_dollar.GetFragments() + unwrapped_fields929 := fields928 p.write("(") p.write("sync") p.indentSexp() - if !(len(unwrapped_fields924) == 0) { + if !(len(unwrapped_fields929) == 0) { p.newline() - for i926, elem925 := range unwrapped_fields924 { - if (i926 > 0) { + for i931, elem930 := range unwrapped_fields929 { + if (i931 > 0) { p.newline() } - p.pretty_fragment_id(elem925) + p.pretty_fragment_id(elem930) } } p.dedent() @@ -1048,51 +1048,51 @@ func (p *PrettyPrinter) pretty_sync(msg *pb.Sync) interface{} { } func (p *PrettyPrinter) pretty_fragment_id(msg *pb.FragmentId) interface{} { - flat930 := p.tryFlat(msg, func() { p.pretty_fragment_id(msg) }) - if flat930 != nil { - p.write(*flat930) + flat935 := p.tryFlat(msg, func() { p.pretty_fragment_id(msg) }) + if flat935 != nil { + p.write(*flat935) return nil } else { _dollar_dollar := msg - fields928 := p.fragmentIdToString(_dollar_dollar) - unwrapped_fields929 := fields928 + fields933 := p.fragmentIdToString(_dollar_dollar) + unwrapped_fields934 := fields933 p.write(":") - p.write(unwrapped_fields929) + p.write(unwrapped_fields934) } return nil } func (p *PrettyPrinter) pretty_epoch(msg *pb.Epoch) interface{} { - flat937 := p.tryFlat(msg, func() { p.pretty_epoch(msg) }) - if flat937 != nil { - p.write(*flat937) + flat942 := p.tryFlat(msg, func() { p.pretty_epoch(msg) }) + if flat942 != nil { + p.write(*flat942) return nil } else { _dollar_dollar := msg - var _t1725 []*pb.Write + var _t1735 []*pb.Write if !(len(_dollar_dollar.GetWrites()) == 0) { - _t1725 = _dollar_dollar.GetWrites() + _t1735 = _dollar_dollar.GetWrites() } - var _t1726 []*pb.Read + var _t1736 []*pb.Read if !(len(_dollar_dollar.GetReads()) == 0) { - _t1726 = _dollar_dollar.GetReads() + _t1736 = _dollar_dollar.GetReads() } - fields931 := []interface{}{_t1725, _t1726} - unwrapped_fields932 := fields931 + fields936 := []interface{}{_t1735, _t1736} + unwrapped_fields937 := fields936 p.write("(") p.write("epoch") p.indentSexp() - field933 := unwrapped_fields932[0].([]*pb.Write) - if field933 != nil { + field938 := unwrapped_fields937[0].([]*pb.Write) + if field938 != nil { p.newline() - opt_val934 := field933 - p.pretty_epoch_writes(opt_val934) + opt_val939 := field938 + p.pretty_epoch_writes(opt_val939) } - field935 := unwrapped_fields932[1].([]*pb.Read) - if field935 != nil { + field940 := unwrapped_fields937[1].([]*pb.Read) + if field940 != nil { p.newline() - opt_val936 := field935 - p.pretty_epoch_reads(opt_val936) + opt_val941 := field940 + p.pretty_epoch_reads(opt_val941) } p.dedent() p.write(")") @@ -1101,22 +1101,22 @@ func (p *PrettyPrinter) pretty_epoch(msg *pb.Epoch) interface{} { } func (p *PrettyPrinter) pretty_epoch_writes(msg []*pb.Write) interface{} { - flat941 := p.tryFlat(msg, func() { p.pretty_epoch_writes(msg) }) - if flat941 != nil { - p.write(*flat941) + flat946 := p.tryFlat(msg, func() { p.pretty_epoch_writes(msg) }) + if flat946 != nil { + p.write(*flat946) return nil } else { - fields938 := msg + fields943 := msg p.write("(") p.write("writes") p.indentSexp() - if !(len(fields938) == 0) { + if !(len(fields943) == 0) { p.newline() - for i940, elem939 := range fields938 { - if (i940 > 0) { + for i945, elem944 := range fields943 { + if (i945 > 0) { p.newline() } - p.pretty_write(elem939) + p.pretty_write(elem944) } } p.dedent() @@ -1126,50 +1126,50 @@ func (p *PrettyPrinter) pretty_epoch_writes(msg []*pb.Write) interface{} { } func (p *PrettyPrinter) pretty_write(msg *pb.Write) interface{} { - flat950 := p.tryFlat(msg, func() { p.pretty_write(msg) }) - if flat950 != nil { - p.write(*flat950) + flat955 := p.tryFlat(msg, func() { p.pretty_write(msg) }) + if flat955 != nil { + p.write(*flat955) return nil } else { _dollar_dollar := msg - var _t1727 *pb.Define + var _t1737 *pb.Define if hasProtoField(_dollar_dollar, "define") { - _t1727 = _dollar_dollar.GetDefine() + _t1737 = _dollar_dollar.GetDefine() } - deconstruct_result948 := _t1727 - if deconstruct_result948 != nil { - unwrapped949 := deconstruct_result948 - p.pretty_define(unwrapped949) + deconstruct_result953 := _t1737 + if deconstruct_result953 != nil { + unwrapped954 := deconstruct_result953 + p.pretty_define(unwrapped954) } else { _dollar_dollar := msg - var _t1728 *pb.Undefine + var _t1738 *pb.Undefine if hasProtoField(_dollar_dollar, "undefine") { - _t1728 = _dollar_dollar.GetUndefine() + _t1738 = _dollar_dollar.GetUndefine() } - deconstruct_result946 := _t1728 - if deconstruct_result946 != nil { - unwrapped947 := deconstruct_result946 - p.pretty_undefine(unwrapped947) + deconstruct_result951 := _t1738 + if deconstruct_result951 != nil { + unwrapped952 := deconstruct_result951 + p.pretty_undefine(unwrapped952) } else { _dollar_dollar := msg - var _t1729 *pb.Context + var _t1739 *pb.Context if hasProtoField(_dollar_dollar, "context") { - _t1729 = _dollar_dollar.GetContext() + _t1739 = _dollar_dollar.GetContext() } - deconstruct_result944 := _t1729 - if deconstruct_result944 != nil { - unwrapped945 := deconstruct_result944 - p.pretty_context(unwrapped945) + deconstruct_result949 := _t1739 + if deconstruct_result949 != nil { + unwrapped950 := deconstruct_result949 + p.pretty_context(unwrapped950) } else { _dollar_dollar := msg - var _t1730 *pb.Snapshot + var _t1740 *pb.Snapshot if hasProtoField(_dollar_dollar, "snapshot") { - _t1730 = _dollar_dollar.GetSnapshot() + _t1740 = _dollar_dollar.GetSnapshot() } - deconstruct_result942 := _t1730 - if deconstruct_result942 != nil { - unwrapped943 := deconstruct_result942 - p.pretty_snapshot(unwrapped943) + deconstruct_result947 := _t1740 + if deconstruct_result947 != nil { + unwrapped948 := deconstruct_result947 + p.pretty_snapshot(unwrapped948) } else { panic(ParseError{msg: "No matching rule for write"}) } @@ -1181,19 +1181,19 @@ func (p *PrettyPrinter) pretty_write(msg *pb.Write) interface{} { } func (p *PrettyPrinter) pretty_define(msg *pb.Define) interface{} { - flat953 := p.tryFlat(msg, func() { p.pretty_define(msg) }) - if flat953 != nil { - p.write(*flat953) + flat958 := p.tryFlat(msg, func() { p.pretty_define(msg) }) + if flat958 != nil { + p.write(*flat958) return nil } else { _dollar_dollar := msg - fields951 := _dollar_dollar.GetFragment() - unwrapped_fields952 := fields951 + fields956 := _dollar_dollar.GetFragment() + unwrapped_fields957 := fields956 p.write("(") p.write("define") p.indentSexp() p.newline() - p.pretty_fragment(unwrapped_fields952) + p.pretty_fragment(unwrapped_fields957) p.dedent() p.write(")") } @@ -1201,29 +1201,29 @@ func (p *PrettyPrinter) pretty_define(msg *pb.Define) interface{} { } func (p *PrettyPrinter) pretty_fragment(msg *pb.Fragment) interface{} { - flat960 := p.tryFlat(msg, func() { p.pretty_fragment(msg) }) - if flat960 != nil { - p.write(*flat960) + flat965 := p.tryFlat(msg, func() { p.pretty_fragment(msg) }) + if flat965 != nil { + p.write(*flat965) return nil } else { _dollar_dollar := msg p.startPrettyFragment(_dollar_dollar) - fields954 := []interface{}{_dollar_dollar.GetId(), _dollar_dollar.GetDeclarations()} - unwrapped_fields955 := fields954 + fields959 := []interface{}{_dollar_dollar.GetId(), _dollar_dollar.GetDeclarations()} + unwrapped_fields960 := fields959 p.write("(") p.write("fragment") p.indentSexp() p.newline() - field956 := unwrapped_fields955[0].(*pb.FragmentId) - p.pretty_new_fragment_id(field956) - field957 := unwrapped_fields955[1].([]*pb.Declaration) - if !(len(field957) == 0) { + field961 := unwrapped_fields960[0].(*pb.FragmentId) + p.pretty_new_fragment_id(field961) + field962 := unwrapped_fields960[1].([]*pb.Declaration) + if !(len(field962) == 0) { p.newline() - for i959, elem958 := range field957 { - if (i959 > 0) { + for i964, elem963 := range field962 { + if (i964 > 0) { p.newline() } - p.pretty_declaration(elem958) + p.pretty_declaration(elem963) } } p.dedent() @@ -1233,62 +1233,62 @@ func (p *PrettyPrinter) pretty_fragment(msg *pb.Fragment) interface{} { } func (p *PrettyPrinter) pretty_new_fragment_id(msg *pb.FragmentId) interface{} { - flat962 := p.tryFlat(msg, func() { p.pretty_new_fragment_id(msg) }) - if flat962 != nil { - p.write(*flat962) + flat967 := p.tryFlat(msg, func() { p.pretty_new_fragment_id(msg) }) + if flat967 != nil { + p.write(*flat967) return nil } else { - fields961 := msg - p.pretty_fragment_id(fields961) + fields966 := msg + p.pretty_fragment_id(fields966) } return nil } func (p *PrettyPrinter) pretty_declaration(msg *pb.Declaration) interface{} { - flat971 := p.tryFlat(msg, func() { p.pretty_declaration(msg) }) - if flat971 != nil { - p.write(*flat971) + flat976 := p.tryFlat(msg, func() { p.pretty_declaration(msg) }) + if flat976 != nil { + p.write(*flat976) return nil } else { _dollar_dollar := msg - var _t1731 *pb.Def + var _t1741 *pb.Def if hasProtoField(_dollar_dollar, "def") { - _t1731 = _dollar_dollar.GetDef() + _t1741 = _dollar_dollar.GetDef() } - deconstruct_result969 := _t1731 - if deconstruct_result969 != nil { - unwrapped970 := deconstruct_result969 - p.pretty_def(unwrapped970) + deconstruct_result974 := _t1741 + if deconstruct_result974 != nil { + unwrapped975 := deconstruct_result974 + p.pretty_def(unwrapped975) } else { _dollar_dollar := msg - var _t1732 *pb.Algorithm + var _t1742 *pb.Algorithm if hasProtoField(_dollar_dollar, "algorithm") { - _t1732 = _dollar_dollar.GetAlgorithm() + _t1742 = _dollar_dollar.GetAlgorithm() } - deconstruct_result967 := _t1732 - if deconstruct_result967 != nil { - unwrapped968 := deconstruct_result967 - p.pretty_algorithm(unwrapped968) + deconstruct_result972 := _t1742 + if deconstruct_result972 != nil { + unwrapped973 := deconstruct_result972 + p.pretty_algorithm(unwrapped973) } else { _dollar_dollar := msg - var _t1733 *pb.Constraint + var _t1743 *pb.Constraint if hasProtoField(_dollar_dollar, "constraint") { - _t1733 = _dollar_dollar.GetConstraint() + _t1743 = _dollar_dollar.GetConstraint() } - deconstruct_result965 := _t1733 - if deconstruct_result965 != nil { - unwrapped966 := deconstruct_result965 - p.pretty_constraint(unwrapped966) + deconstruct_result970 := _t1743 + if deconstruct_result970 != nil { + unwrapped971 := deconstruct_result970 + p.pretty_constraint(unwrapped971) } else { _dollar_dollar := msg - var _t1734 *pb.Data + var _t1744 *pb.Data if hasProtoField(_dollar_dollar, "data") { - _t1734 = _dollar_dollar.GetData() + _t1744 = _dollar_dollar.GetData() } - deconstruct_result963 := _t1734 - if deconstruct_result963 != nil { - unwrapped964 := deconstruct_result963 - p.pretty_data(unwrapped964) + deconstruct_result968 := _t1744 + if deconstruct_result968 != nil { + unwrapped969 := deconstruct_result968 + p.pretty_data(unwrapped969) } else { panic(ParseError{msg: "No matching rule for declaration"}) } @@ -1300,32 +1300,32 @@ func (p *PrettyPrinter) pretty_declaration(msg *pb.Declaration) interface{} { } func (p *PrettyPrinter) pretty_def(msg *pb.Def) interface{} { - flat978 := p.tryFlat(msg, func() { p.pretty_def(msg) }) - if flat978 != nil { - p.write(*flat978) + flat983 := p.tryFlat(msg, func() { p.pretty_def(msg) }) + if flat983 != nil { + p.write(*flat983) return nil } else { _dollar_dollar := msg - var _t1735 []*pb.Attribute + var _t1745 []*pb.Attribute if !(len(_dollar_dollar.GetAttrs()) == 0) { - _t1735 = _dollar_dollar.GetAttrs() + _t1745 = _dollar_dollar.GetAttrs() } - fields972 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetBody(), _t1735} - unwrapped_fields973 := fields972 + fields977 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetBody(), _t1745} + unwrapped_fields978 := fields977 p.write("(") p.write("def") p.indentSexp() p.newline() - field974 := unwrapped_fields973[0].(*pb.RelationId) - p.pretty_relation_id(field974) + field979 := unwrapped_fields978[0].(*pb.RelationId) + p.pretty_relation_id(field979) p.newline() - field975 := unwrapped_fields973[1].(*pb.Abstraction) - p.pretty_abstraction(field975) - field976 := unwrapped_fields973[2].([]*pb.Attribute) - if field976 != nil { + field980 := unwrapped_fields978[1].(*pb.Abstraction) + p.pretty_abstraction(field980) + field981 := unwrapped_fields978[2].([]*pb.Attribute) + if field981 != nil { p.newline() - opt_val977 := field976 - p.pretty_attrs(opt_val977) + opt_val982 := field981 + p.pretty_attrs(opt_val982) } p.dedent() p.write(")") @@ -1334,29 +1334,29 @@ func (p *PrettyPrinter) pretty_def(msg *pb.Def) interface{} { } func (p *PrettyPrinter) pretty_relation_id(msg *pb.RelationId) interface{} { - flat983 := p.tryFlat(msg, func() { p.pretty_relation_id(msg) }) - if flat983 != nil { - p.write(*flat983) + flat988 := p.tryFlat(msg, func() { p.pretty_relation_id(msg) }) + if flat988 != nil { + p.write(*flat988) return nil } else { _dollar_dollar := msg - var _t1736 *string + var _t1746 *string if p.relationIdToString(_dollar_dollar) != nil { - _t1737 := p.deconstruct_relation_id_string(_dollar_dollar) - _t1736 = ptr(_t1737) + _t1747 := p.deconstruct_relation_id_string(_dollar_dollar) + _t1746 = ptr(_t1747) } - deconstruct_result981 := _t1736 - if deconstruct_result981 != nil { - unwrapped982 := *deconstruct_result981 + deconstruct_result986 := _t1746 + if deconstruct_result986 != nil { + unwrapped987 := *deconstruct_result986 p.write(":") - p.write(unwrapped982) + p.write(unwrapped987) } else { _dollar_dollar := msg - _t1738 := p.deconstruct_relation_id_uint128(_dollar_dollar) - deconstruct_result979 := _t1738 - if deconstruct_result979 != nil { - unwrapped980 := deconstruct_result979 - p.write(p.formatUint128(unwrapped980)) + _t1748 := p.deconstruct_relation_id_uint128(_dollar_dollar) + deconstruct_result984 := _t1748 + if deconstruct_result984 != nil { + unwrapped985 := deconstruct_result984 + p.write(p.formatUint128(unwrapped985)) } else { panic(ParseError{msg: "No matching rule for relation_id"}) } @@ -1366,22 +1366,22 @@ func (p *PrettyPrinter) pretty_relation_id(msg *pb.RelationId) interface{} { } func (p *PrettyPrinter) pretty_abstraction(msg *pb.Abstraction) interface{} { - flat988 := p.tryFlat(msg, func() { p.pretty_abstraction(msg) }) - if flat988 != nil { - p.write(*flat988) + flat993 := p.tryFlat(msg, func() { p.pretty_abstraction(msg) }) + if flat993 != nil { + p.write(*flat993) return nil } else { _dollar_dollar := msg - _t1739 := p.deconstruct_bindings(_dollar_dollar) - fields984 := []interface{}{_t1739, _dollar_dollar.GetValue()} - unwrapped_fields985 := fields984 + _t1749 := p.deconstruct_bindings(_dollar_dollar) + fields989 := []interface{}{_t1749, _dollar_dollar.GetValue()} + unwrapped_fields990 := fields989 p.write("(") p.indent() - field986 := unwrapped_fields985[0].([]interface{}) - p.pretty_bindings(field986) + field991 := unwrapped_fields990[0].([]interface{}) + p.pretty_bindings(field991) p.newline() - field987 := unwrapped_fields985[1].(*pb.Formula) - p.pretty_formula(field987) + field992 := unwrapped_fields990[1].(*pb.Formula) + p.pretty_formula(field992) p.dedent() p.write(")") } @@ -1389,32 +1389,32 @@ func (p *PrettyPrinter) pretty_abstraction(msg *pb.Abstraction) interface{} { } func (p *PrettyPrinter) pretty_bindings(msg []interface{}) interface{} { - flat996 := p.tryFlat(msg, func() { p.pretty_bindings(msg) }) - if flat996 != nil { - p.write(*flat996) + flat1001 := p.tryFlat(msg, func() { p.pretty_bindings(msg) }) + if flat1001 != nil { + p.write(*flat1001) return nil } else { _dollar_dollar := msg - var _t1740 []*pb.Binding + var _t1750 []*pb.Binding if !(len(_dollar_dollar[1].([]*pb.Binding)) == 0) { - _t1740 = _dollar_dollar[1].([]*pb.Binding) + _t1750 = _dollar_dollar[1].([]*pb.Binding) } - fields989 := []interface{}{_dollar_dollar[0].([]*pb.Binding), _t1740} - unwrapped_fields990 := fields989 + fields994 := []interface{}{_dollar_dollar[0].([]*pb.Binding), _t1750} + unwrapped_fields995 := fields994 p.write("[") p.indent() - field991 := unwrapped_fields990[0].([]*pb.Binding) - for i993, elem992 := range field991 { - if (i993 > 0) { + field996 := unwrapped_fields995[0].([]*pb.Binding) + for i998, elem997 := range field996 { + if (i998 > 0) { p.newline() } - p.pretty_binding(elem992) + p.pretty_binding(elem997) } - field994 := unwrapped_fields990[1].([]*pb.Binding) - if field994 != nil { + field999 := unwrapped_fields995[1].([]*pb.Binding) + if field999 != nil { p.newline() - opt_val995 := field994 - p.pretty_value_bindings(opt_val995) + opt_val1000 := field999 + p.pretty_value_bindings(opt_val1000) } p.dedent() p.write("]") @@ -1423,170 +1423,181 @@ func (p *PrettyPrinter) pretty_bindings(msg []interface{}) interface{} { } func (p *PrettyPrinter) pretty_binding(msg *pb.Binding) interface{} { - flat1001 := p.tryFlat(msg, func() { p.pretty_binding(msg) }) - if flat1001 != nil { - p.write(*flat1001) + flat1006 := p.tryFlat(msg, func() { p.pretty_binding(msg) }) + if flat1006 != nil { + p.write(*flat1006) return nil } else { _dollar_dollar := msg - fields997 := []interface{}{_dollar_dollar.GetVar().GetName(), _dollar_dollar.GetType()} - unwrapped_fields998 := fields997 - field999 := unwrapped_fields998[0].(string) - p.write(field999) + fields1002 := []interface{}{_dollar_dollar.GetVar().GetName(), _dollar_dollar.GetType()} + unwrapped_fields1003 := fields1002 + field1004 := unwrapped_fields1003[0].(string) + p.write(field1004) p.write("::") - field1000 := unwrapped_fields998[1].(*pb.Type) - p.pretty_type(field1000) + field1005 := unwrapped_fields1003[1].(*pb.Type) + p.pretty_type(field1005) } return nil } func (p *PrettyPrinter) pretty_type(msg *pb.Type) interface{} { - flat1030 := p.tryFlat(msg, func() { p.pretty_type(msg) }) - if flat1030 != nil { - p.write(*flat1030) + flat1037 := p.tryFlat(msg, func() { p.pretty_type(msg) }) + if flat1037 != nil { + p.write(*flat1037) return nil } else { _dollar_dollar := msg - var _t1741 *pb.UnspecifiedType + var _t1751 *pb.UnspecifiedType if hasProtoField(_dollar_dollar, "unspecified_type") { - _t1741 = _dollar_dollar.GetUnspecifiedType() + _t1751 = _dollar_dollar.GetUnspecifiedType() } - deconstruct_result1028 := _t1741 - if deconstruct_result1028 != nil { - unwrapped1029 := deconstruct_result1028 - p.pretty_unspecified_type(unwrapped1029) + deconstruct_result1035 := _t1751 + if deconstruct_result1035 != nil { + unwrapped1036 := deconstruct_result1035 + p.pretty_unspecified_type(unwrapped1036) } else { _dollar_dollar := msg - var _t1742 *pb.StringType + var _t1752 *pb.StringType if hasProtoField(_dollar_dollar, "string_type") { - _t1742 = _dollar_dollar.GetStringType() + _t1752 = _dollar_dollar.GetStringType() } - deconstruct_result1026 := _t1742 - if deconstruct_result1026 != nil { - unwrapped1027 := deconstruct_result1026 - p.pretty_string_type(unwrapped1027) + deconstruct_result1033 := _t1752 + if deconstruct_result1033 != nil { + unwrapped1034 := deconstruct_result1033 + p.pretty_string_type(unwrapped1034) } else { _dollar_dollar := msg - var _t1743 *pb.IntType + var _t1753 *pb.IntType if hasProtoField(_dollar_dollar, "int_type") { - _t1743 = _dollar_dollar.GetIntType() + _t1753 = _dollar_dollar.GetIntType() } - deconstruct_result1024 := _t1743 - if deconstruct_result1024 != nil { - unwrapped1025 := deconstruct_result1024 - p.pretty_int_type(unwrapped1025) + deconstruct_result1031 := _t1753 + if deconstruct_result1031 != nil { + unwrapped1032 := deconstruct_result1031 + p.pretty_int_type(unwrapped1032) } else { _dollar_dollar := msg - var _t1744 *pb.FloatType + var _t1754 *pb.FloatType if hasProtoField(_dollar_dollar, "float_type") { - _t1744 = _dollar_dollar.GetFloatType() + _t1754 = _dollar_dollar.GetFloatType() } - deconstruct_result1022 := _t1744 - if deconstruct_result1022 != nil { - unwrapped1023 := deconstruct_result1022 - p.pretty_float_type(unwrapped1023) + deconstruct_result1029 := _t1754 + if deconstruct_result1029 != nil { + unwrapped1030 := deconstruct_result1029 + p.pretty_float_type(unwrapped1030) } else { _dollar_dollar := msg - var _t1745 *pb.UInt128Type + var _t1755 *pb.UInt128Type if hasProtoField(_dollar_dollar, "uint128_type") { - _t1745 = _dollar_dollar.GetUint128Type() + _t1755 = _dollar_dollar.GetUint128Type() } - deconstruct_result1020 := _t1745 - if deconstruct_result1020 != nil { - unwrapped1021 := deconstruct_result1020 - p.pretty_uint128_type(unwrapped1021) + deconstruct_result1027 := _t1755 + if deconstruct_result1027 != nil { + unwrapped1028 := deconstruct_result1027 + p.pretty_uint128_type(unwrapped1028) } else { _dollar_dollar := msg - var _t1746 *pb.Int128Type + var _t1756 *pb.Int128Type if hasProtoField(_dollar_dollar, "int128_type") { - _t1746 = _dollar_dollar.GetInt128Type() + _t1756 = _dollar_dollar.GetInt128Type() } - deconstruct_result1018 := _t1746 - if deconstruct_result1018 != nil { - unwrapped1019 := deconstruct_result1018 - p.pretty_int128_type(unwrapped1019) + deconstruct_result1025 := _t1756 + if deconstruct_result1025 != nil { + unwrapped1026 := deconstruct_result1025 + p.pretty_int128_type(unwrapped1026) } else { _dollar_dollar := msg - var _t1747 *pb.DateType + var _t1757 *pb.DateType if hasProtoField(_dollar_dollar, "date_type") { - _t1747 = _dollar_dollar.GetDateType() + _t1757 = _dollar_dollar.GetDateType() } - deconstruct_result1016 := _t1747 - if deconstruct_result1016 != nil { - unwrapped1017 := deconstruct_result1016 - p.pretty_date_type(unwrapped1017) + deconstruct_result1023 := _t1757 + if deconstruct_result1023 != nil { + unwrapped1024 := deconstruct_result1023 + p.pretty_date_type(unwrapped1024) } else { _dollar_dollar := msg - var _t1748 *pb.DateTimeType + var _t1758 *pb.DateTimeType if hasProtoField(_dollar_dollar, "datetime_type") { - _t1748 = _dollar_dollar.GetDatetimeType() + _t1758 = _dollar_dollar.GetDatetimeType() } - deconstruct_result1014 := _t1748 - if deconstruct_result1014 != nil { - unwrapped1015 := deconstruct_result1014 - p.pretty_datetime_type(unwrapped1015) + deconstruct_result1021 := _t1758 + if deconstruct_result1021 != nil { + unwrapped1022 := deconstruct_result1021 + p.pretty_datetime_type(unwrapped1022) } else { _dollar_dollar := msg - var _t1749 *pb.MissingType + var _t1759 *pb.MissingType if hasProtoField(_dollar_dollar, "missing_type") { - _t1749 = _dollar_dollar.GetMissingType() + _t1759 = _dollar_dollar.GetMissingType() } - deconstruct_result1012 := _t1749 - if deconstruct_result1012 != nil { - unwrapped1013 := deconstruct_result1012 - p.pretty_missing_type(unwrapped1013) + deconstruct_result1019 := _t1759 + if deconstruct_result1019 != nil { + unwrapped1020 := deconstruct_result1019 + p.pretty_missing_type(unwrapped1020) } else { _dollar_dollar := msg - var _t1750 *pb.DecimalType + var _t1760 *pb.DecimalType if hasProtoField(_dollar_dollar, "decimal_type") { - _t1750 = _dollar_dollar.GetDecimalType() + _t1760 = _dollar_dollar.GetDecimalType() } - deconstruct_result1010 := _t1750 - if deconstruct_result1010 != nil { - unwrapped1011 := deconstruct_result1010 - p.pretty_decimal_type(unwrapped1011) + deconstruct_result1017 := _t1760 + if deconstruct_result1017 != nil { + unwrapped1018 := deconstruct_result1017 + p.pretty_decimal_type(unwrapped1018) } else { _dollar_dollar := msg - var _t1751 *pb.BooleanType + var _t1761 *pb.BooleanType if hasProtoField(_dollar_dollar, "boolean_type") { - _t1751 = _dollar_dollar.GetBooleanType() + _t1761 = _dollar_dollar.GetBooleanType() } - deconstruct_result1008 := _t1751 - if deconstruct_result1008 != nil { - unwrapped1009 := deconstruct_result1008 - p.pretty_boolean_type(unwrapped1009) + deconstruct_result1015 := _t1761 + if deconstruct_result1015 != nil { + unwrapped1016 := deconstruct_result1015 + p.pretty_boolean_type(unwrapped1016) } else { _dollar_dollar := msg - var _t1752 *pb.Int32Type + var _t1762 *pb.Int32Type if hasProtoField(_dollar_dollar, "int32_type") { - _t1752 = _dollar_dollar.GetInt32Type() + _t1762 = _dollar_dollar.GetInt32Type() } - deconstruct_result1006 := _t1752 - if deconstruct_result1006 != nil { - unwrapped1007 := deconstruct_result1006 - p.pretty_int32_type(unwrapped1007) + deconstruct_result1013 := _t1762 + if deconstruct_result1013 != nil { + unwrapped1014 := deconstruct_result1013 + p.pretty_int32_type(unwrapped1014) } else { _dollar_dollar := msg - var _t1753 *pb.Float32Type + var _t1763 *pb.Float32Type if hasProtoField(_dollar_dollar, "float32_type") { - _t1753 = _dollar_dollar.GetFloat32Type() + _t1763 = _dollar_dollar.GetFloat32Type() } - deconstruct_result1004 := _t1753 - if deconstruct_result1004 != nil { - unwrapped1005 := deconstruct_result1004 - p.pretty_float32_type(unwrapped1005) + deconstruct_result1011 := _t1763 + if deconstruct_result1011 != nil { + unwrapped1012 := deconstruct_result1011 + p.pretty_float32_type(unwrapped1012) } else { _dollar_dollar := msg - var _t1754 *pb.UInt32Type + var _t1764 *pb.UInt32Type if hasProtoField(_dollar_dollar, "uint32_type") { - _t1754 = _dollar_dollar.GetUint32Type() + _t1764 = _dollar_dollar.GetUint32Type() } - deconstruct_result1002 := _t1754 - if deconstruct_result1002 != nil { - unwrapped1003 := deconstruct_result1002 - p.pretty_uint32_type(unwrapped1003) + deconstruct_result1009 := _t1764 + if deconstruct_result1009 != nil { + unwrapped1010 := deconstruct_result1009 + p.pretty_uint32_type(unwrapped1010) } else { - panic(ParseError{msg: "No matching rule for type"}) + _dollar_dollar := msg + var _t1765 *pb.FixedType + if hasProtoField(_dollar_dollar, "fixed_type") { + _t1765 = _dollar_dollar.GetFixedType() + } + deconstruct_result1007 := _t1765 + if deconstruct_result1007 != nil { + unwrapped1008 := deconstruct_result1007 + p.pretty_fixed_type(unwrapped1008) + } else { + panic(ParseError{msg: "No matching rule for type"}) + } } } } @@ -1606,86 +1617,86 @@ func (p *PrettyPrinter) pretty_type(msg *pb.Type) interface{} { } func (p *PrettyPrinter) pretty_unspecified_type(msg *pb.UnspecifiedType) interface{} { - fields1031 := msg - _ = fields1031 + fields1038 := msg + _ = fields1038 p.write("UNKNOWN") return nil } func (p *PrettyPrinter) pretty_string_type(msg *pb.StringType) interface{} { - fields1032 := msg - _ = fields1032 + fields1039 := msg + _ = fields1039 p.write("STRING") return nil } func (p *PrettyPrinter) pretty_int_type(msg *pb.IntType) interface{} { - fields1033 := msg - _ = fields1033 + fields1040 := msg + _ = fields1040 p.write("INT") return nil } func (p *PrettyPrinter) pretty_float_type(msg *pb.FloatType) interface{} { - fields1034 := msg - _ = fields1034 + fields1041 := msg + _ = fields1041 p.write("FLOAT") return nil } func (p *PrettyPrinter) pretty_uint128_type(msg *pb.UInt128Type) interface{} { - fields1035 := msg - _ = fields1035 + fields1042 := msg + _ = fields1042 p.write("UINT128") return nil } func (p *PrettyPrinter) pretty_int128_type(msg *pb.Int128Type) interface{} { - fields1036 := msg - _ = fields1036 + fields1043 := msg + _ = fields1043 p.write("INT128") return nil } func (p *PrettyPrinter) pretty_date_type(msg *pb.DateType) interface{} { - fields1037 := msg - _ = fields1037 + fields1044 := msg + _ = fields1044 p.write("DATE") return nil } func (p *PrettyPrinter) pretty_datetime_type(msg *pb.DateTimeType) interface{} { - fields1038 := msg - _ = fields1038 + fields1045 := msg + _ = fields1045 p.write("DATETIME") return nil } func (p *PrettyPrinter) pretty_missing_type(msg *pb.MissingType) interface{} { - fields1039 := msg - _ = fields1039 + fields1046 := msg + _ = fields1046 p.write("MISSING") return nil } func (p *PrettyPrinter) pretty_decimal_type(msg *pb.DecimalType) interface{} { - flat1044 := p.tryFlat(msg, func() { p.pretty_decimal_type(msg) }) - if flat1044 != nil { - p.write(*flat1044) + flat1051 := p.tryFlat(msg, func() { p.pretty_decimal_type(msg) }) + if flat1051 != nil { + p.write(*flat1051) return nil } else { _dollar_dollar := msg - fields1040 := []interface{}{int64(_dollar_dollar.GetPrecision()), int64(_dollar_dollar.GetScale())} - unwrapped_fields1041 := fields1040 + fields1047 := []interface{}{int64(_dollar_dollar.GetPrecision()), int64(_dollar_dollar.GetScale())} + unwrapped_fields1048 := fields1047 p.write("(") p.write("DECIMAL") p.indentSexp() p.newline() - field1042 := unwrapped_fields1041[0].(int64) - p.write(fmt.Sprintf("%d", field1042)) + field1049 := unwrapped_fields1048[0].(int64) + p.write(fmt.Sprintf("%d", field1049)) p.newline() - field1043 := unwrapped_fields1041[1].(int64) - p.write(fmt.Sprintf("%d", field1043)) + field1050 := unwrapped_fields1048[1].(int64) + p.write(fmt.Sprintf("%d", field1050)) p.dedent() p.write(")") } @@ -1693,48 +1704,68 @@ func (p *PrettyPrinter) pretty_decimal_type(msg *pb.DecimalType) interface{} { } func (p *PrettyPrinter) pretty_boolean_type(msg *pb.BooleanType) interface{} { - fields1045 := msg - _ = fields1045 + fields1052 := msg + _ = fields1052 p.write("BOOLEAN") return nil } func (p *PrettyPrinter) pretty_int32_type(msg *pb.Int32Type) interface{} { - fields1046 := msg - _ = fields1046 + fields1053 := msg + _ = fields1053 p.write("INT32") return nil } func (p *PrettyPrinter) pretty_float32_type(msg *pb.Float32Type) interface{} { - fields1047 := msg - _ = fields1047 + fields1054 := msg + _ = fields1054 p.write("FLOAT32") return nil } func (p *PrettyPrinter) pretty_uint32_type(msg *pb.UInt32Type) interface{} { - fields1048 := msg - _ = fields1048 + fields1055 := msg + _ = fields1055 p.write("UINT32") return nil } +func (p *PrettyPrinter) pretty_fixed_type(msg *pb.FixedType) interface{} { + flat1058 := p.tryFlat(msg, func() { p.pretty_fixed_type(msg) }) + if flat1058 != nil { + p.write(*flat1058) + return nil + } else { + _dollar_dollar := msg + fields1056 := int64(_dollar_dollar.GetLength()) + unwrapped_fields1057 := fields1056 + p.write("(") + p.write("FIXED") + p.indentSexp() + p.newline() + p.write(fmt.Sprintf("%d", unwrapped_fields1057)) + p.dedent() + p.write(")") + } + return nil +} + func (p *PrettyPrinter) pretty_value_bindings(msg []*pb.Binding) interface{} { - flat1052 := p.tryFlat(msg, func() { p.pretty_value_bindings(msg) }) - if flat1052 != nil { - p.write(*flat1052) + flat1062 := p.tryFlat(msg, func() { p.pretty_value_bindings(msg) }) + if flat1062 != nil { + p.write(*flat1062) return nil } else { - fields1049 := msg + fields1059 := msg p.write("|") - if !(len(fields1049) == 0) { + if !(len(fields1059) == 0) { p.write(" ") - for i1051, elem1050 := range fields1049 { - if (i1051 > 0) { + for i1061, elem1060 := range fields1059 { + if (i1061 > 0) { p.newline() } - p.pretty_binding(elem1050) + p.pretty_binding(elem1060) } } } @@ -1742,140 +1773,140 @@ func (p *PrettyPrinter) pretty_value_bindings(msg []*pb.Binding) interface{} { } func (p *PrettyPrinter) pretty_formula(msg *pb.Formula) interface{} { - flat1079 := p.tryFlat(msg, func() { p.pretty_formula(msg) }) - if flat1079 != nil { - p.write(*flat1079) + flat1089 := p.tryFlat(msg, func() { p.pretty_formula(msg) }) + if flat1089 != nil { + p.write(*flat1089) return nil } else { _dollar_dollar := msg - var _t1755 *pb.Conjunction + var _t1766 *pb.Conjunction if (hasProtoField(_dollar_dollar, "conjunction") && len(_dollar_dollar.GetConjunction().GetArgs()) == 0) { - _t1755 = _dollar_dollar.GetConjunction() + _t1766 = _dollar_dollar.GetConjunction() } - deconstruct_result1077 := _t1755 - if deconstruct_result1077 != nil { - unwrapped1078 := deconstruct_result1077 - p.pretty_true(unwrapped1078) + deconstruct_result1087 := _t1766 + if deconstruct_result1087 != nil { + unwrapped1088 := deconstruct_result1087 + p.pretty_true(unwrapped1088) } else { _dollar_dollar := msg - var _t1756 *pb.Disjunction + var _t1767 *pb.Disjunction if (hasProtoField(_dollar_dollar, "disjunction") && len(_dollar_dollar.GetDisjunction().GetArgs()) == 0) { - _t1756 = _dollar_dollar.GetDisjunction() + _t1767 = _dollar_dollar.GetDisjunction() } - deconstruct_result1075 := _t1756 - if deconstruct_result1075 != nil { - unwrapped1076 := deconstruct_result1075 - p.pretty_false(unwrapped1076) + deconstruct_result1085 := _t1767 + if deconstruct_result1085 != nil { + unwrapped1086 := deconstruct_result1085 + p.pretty_false(unwrapped1086) } else { _dollar_dollar := msg - var _t1757 *pb.Exists + var _t1768 *pb.Exists if hasProtoField(_dollar_dollar, "exists") { - _t1757 = _dollar_dollar.GetExists() + _t1768 = _dollar_dollar.GetExists() } - deconstruct_result1073 := _t1757 - if deconstruct_result1073 != nil { - unwrapped1074 := deconstruct_result1073 - p.pretty_exists(unwrapped1074) + deconstruct_result1083 := _t1768 + if deconstruct_result1083 != nil { + unwrapped1084 := deconstruct_result1083 + p.pretty_exists(unwrapped1084) } else { _dollar_dollar := msg - var _t1758 *pb.Reduce + var _t1769 *pb.Reduce if hasProtoField(_dollar_dollar, "reduce") { - _t1758 = _dollar_dollar.GetReduce() + _t1769 = _dollar_dollar.GetReduce() } - deconstruct_result1071 := _t1758 - if deconstruct_result1071 != nil { - unwrapped1072 := deconstruct_result1071 - p.pretty_reduce(unwrapped1072) + deconstruct_result1081 := _t1769 + if deconstruct_result1081 != nil { + unwrapped1082 := deconstruct_result1081 + p.pretty_reduce(unwrapped1082) } else { _dollar_dollar := msg - var _t1759 *pb.Conjunction + var _t1770 *pb.Conjunction if (hasProtoField(_dollar_dollar, "conjunction") && !(len(_dollar_dollar.GetConjunction().GetArgs()) == 0)) { - _t1759 = _dollar_dollar.GetConjunction() + _t1770 = _dollar_dollar.GetConjunction() } - deconstruct_result1069 := _t1759 - if deconstruct_result1069 != nil { - unwrapped1070 := deconstruct_result1069 - p.pretty_conjunction(unwrapped1070) + deconstruct_result1079 := _t1770 + if deconstruct_result1079 != nil { + unwrapped1080 := deconstruct_result1079 + p.pretty_conjunction(unwrapped1080) } else { _dollar_dollar := msg - var _t1760 *pb.Disjunction + var _t1771 *pb.Disjunction if (hasProtoField(_dollar_dollar, "disjunction") && !(len(_dollar_dollar.GetDisjunction().GetArgs()) == 0)) { - _t1760 = _dollar_dollar.GetDisjunction() + _t1771 = _dollar_dollar.GetDisjunction() } - deconstruct_result1067 := _t1760 - if deconstruct_result1067 != nil { - unwrapped1068 := deconstruct_result1067 - p.pretty_disjunction(unwrapped1068) + deconstruct_result1077 := _t1771 + if deconstruct_result1077 != nil { + unwrapped1078 := deconstruct_result1077 + p.pretty_disjunction(unwrapped1078) } else { _dollar_dollar := msg - var _t1761 *pb.Not + var _t1772 *pb.Not if hasProtoField(_dollar_dollar, "not") { - _t1761 = _dollar_dollar.GetNot() + _t1772 = _dollar_dollar.GetNot() } - deconstruct_result1065 := _t1761 - if deconstruct_result1065 != nil { - unwrapped1066 := deconstruct_result1065 - p.pretty_not(unwrapped1066) + deconstruct_result1075 := _t1772 + if deconstruct_result1075 != nil { + unwrapped1076 := deconstruct_result1075 + p.pretty_not(unwrapped1076) } else { _dollar_dollar := msg - var _t1762 *pb.FFI + var _t1773 *pb.FFI if hasProtoField(_dollar_dollar, "ffi") { - _t1762 = _dollar_dollar.GetFfi() + _t1773 = _dollar_dollar.GetFfi() } - deconstruct_result1063 := _t1762 - if deconstruct_result1063 != nil { - unwrapped1064 := deconstruct_result1063 - p.pretty_ffi(unwrapped1064) + deconstruct_result1073 := _t1773 + if deconstruct_result1073 != nil { + unwrapped1074 := deconstruct_result1073 + p.pretty_ffi(unwrapped1074) } else { _dollar_dollar := msg - var _t1763 *pb.Atom + var _t1774 *pb.Atom if hasProtoField(_dollar_dollar, "atom") { - _t1763 = _dollar_dollar.GetAtom() + _t1774 = _dollar_dollar.GetAtom() } - deconstruct_result1061 := _t1763 - if deconstruct_result1061 != nil { - unwrapped1062 := deconstruct_result1061 - p.pretty_atom(unwrapped1062) + deconstruct_result1071 := _t1774 + if deconstruct_result1071 != nil { + unwrapped1072 := deconstruct_result1071 + p.pretty_atom(unwrapped1072) } else { _dollar_dollar := msg - var _t1764 *pb.Pragma + var _t1775 *pb.Pragma if hasProtoField(_dollar_dollar, "pragma") { - _t1764 = _dollar_dollar.GetPragma() + _t1775 = _dollar_dollar.GetPragma() } - deconstruct_result1059 := _t1764 - if deconstruct_result1059 != nil { - unwrapped1060 := deconstruct_result1059 - p.pretty_pragma(unwrapped1060) + deconstruct_result1069 := _t1775 + if deconstruct_result1069 != nil { + unwrapped1070 := deconstruct_result1069 + p.pretty_pragma(unwrapped1070) } else { _dollar_dollar := msg - var _t1765 *pb.Primitive + var _t1776 *pb.Primitive if hasProtoField(_dollar_dollar, "primitive") { - _t1765 = _dollar_dollar.GetPrimitive() + _t1776 = _dollar_dollar.GetPrimitive() } - deconstruct_result1057 := _t1765 - if deconstruct_result1057 != nil { - unwrapped1058 := deconstruct_result1057 - p.pretty_primitive(unwrapped1058) + deconstruct_result1067 := _t1776 + if deconstruct_result1067 != nil { + unwrapped1068 := deconstruct_result1067 + p.pretty_primitive(unwrapped1068) } else { _dollar_dollar := msg - var _t1766 *pb.RelAtom + var _t1777 *pb.RelAtom if hasProtoField(_dollar_dollar, "rel_atom") { - _t1766 = _dollar_dollar.GetRelAtom() + _t1777 = _dollar_dollar.GetRelAtom() } - deconstruct_result1055 := _t1766 - if deconstruct_result1055 != nil { - unwrapped1056 := deconstruct_result1055 - p.pretty_rel_atom(unwrapped1056) + deconstruct_result1065 := _t1777 + if deconstruct_result1065 != nil { + unwrapped1066 := deconstruct_result1065 + p.pretty_rel_atom(unwrapped1066) } else { _dollar_dollar := msg - var _t1767 *pb.Cast + var _t1778 *pb.Cast if hasProtoField(_dollar_dollar, "cast") { - _t1767 = _dollar_dollar.GetCast() + _t1778 = _dollar_dollar.GetCast() } - deconstruct_result1053 := _t1767 - if deconstruct_result1053 != nil { - unwrapped1054 := deconstruct_result1053 - p.pretty_cast(unwrapped1054) + deconstruct_result1063 := _t1778 + if deconstruct_result1063 != nil { + unwrapped1064 := deconstruct_result1063 + p.pretty_cast(unwrapped1064) } else { panic(ParseError{msg: "No matching rule for formula"}) } @@ -1896,8 +1927,8 @@ func (p *PrettyPrinter) pretty_formula(msg *pb.Formula) interface{} { } func (p *PrettyPrinter) pretty_true(msg *pb.Conjunction) interface{} { - fields1080 := msg - _ = fields1080 + fields1090 := msg + _ = fields1090 p.write("(") p.write("true") p.write(")") @@ -1905,8 +1936,8 @@ func (p *PrettyPrinter) pretty_true(msg *pb.Conjunction) interface{} { } func (p *PrettyPrinter) pretty_false(msg *pb.Disjunction) interface{} { - fields1081 := msg - _ = fields1081 + fields1091 := msg + _ = fields1091 p.write("(") p.write("false") p.write(")") @@ -1914,24 +1945,24 @@ func (p *PrettyPrinter) pretty_false(msg *pb.Disjunction) interface{} { } func (p *PrettyPrinter) pretty_exists(msg *pb.Exists) interface{} { - flat1086 := p.tryFlat(msg, func() { p.pretty_exists(msg) }) - if flat1086 != nil { - p.write(*flat1086) + flat1096 := p.tryFlat(msg, func() { p.pretty_exists(msg) }) + if flat1096 != nil { + p.write(*flat1096) return nil } else { _dollar_dollar := msg - _t1768 := p.deconstruct_bindings(_dollar_dollar.GetBody()) - fields1082 := []interface{}{_t1768, _dollar_dollar.GetBody().GetValue()} - unwrapped_fields1083 := fields1082 + _t1779 := p.deconstruct_bindings(_dollar_dollar.GetBody()) + fields1092 := []interface{}{_t1779, _dollar_dollar.GetBody().GetValue()} + unwrapped_fields1093 := fields1092 p.write("(") p.write("exists") p.indentSexp() p.newline() - field1084 := unwrapped_fields1083[0].([]interface{}) - p.pretty_bindings(field1084) + field1094 := unwrapped_fields1093[0].([]interface{}) + p.pretty_bindings(field1094) p.newline() - field1085 := unwrapped_fields1083[1].(*pb.Formula) - p.pretty_formula(field1085) + field1095 := unwrapped_fields1093[1].(*pb.Formula) + p.pretty_formula(field1095) p.dedent() p.write(")") } @@ -1939,26 +1970,26 @@ func (p *PrettyPrinter) pretty_exists(msg *pb.Exists) interface{} { } func (p *PrettyPrinter) pretty_reduce(msg *pb.Reduce) interface{} { - flat1092 := p.tryFlat(msg, func() { p.pretty_reduce(msg) }) - if flat1092 != nil { - p.write(*flat1092) + flat1102 := p.tryFlat(msg, func() { p.pretty_reduce(msg) }) + if flat1102 != nil { + p.write(*flat1102) return nil } else { _dollar_dollar := msg - fields1087 := []interface{}{_dollar_dollar.GetOp(), _dollar_dollar.GetBody(), _dollar_dollar.GetTerms()} - unwrapped_fields1088 := fields1087 + fields1097 := []interface{}{_dollar_dollar.GetOp(), _dollar_dollar.GetBody(), _dollar_dollar.GetTerms()} + unwrapped_fields1098 := fields1097 p.write("(") p.write("reduce") p.indentSexp() p.newline() - field1089 := unwrapped_fields1088[0].(*pb.Abstraction) - p.pretty_abstraction(field1089) + field1099 := unwrapped_fields1098[0].(*pb.Abstraction) + p.pretty_abstraction(field1099) p.newline() - field1090 := unwrapped_fields1088[1].(*pb.Abstraction) - p.pretty_abstraction(field1090) + field1100 := unwrapped_fields1098[1].(*pb.Abstraction) + p.pretty_abstraction(field1100) p.newline() - field1091 := unwrapped_fields1088[2].([]*pb.Term) - p.pretty_terms(field1091) + field1101 := unwrapped_fields1098[2].([]*pb.Term) + p.pretty_terms(field1101) p.dedent() p.write(")") } @@ -1966,22 +1997,22 @@ func (p *PrettyPrinter) pretty_reduce(msg *pb.Reduce) interface{} { } func (p *PrettyPrinter) pretty_terms(msg []*pb.Term) interface{} { - flat1096 := p.tryFlat(msg, func() { p.pretty_terms(msg) }) - if flat1096 != nil { - p.write(*flat1096) + flat1106 := p.tryFlat(msg, func() { p.pretty_terms(msg) }) + if flat1106 != nil { + p.write(*flat1106) return nil } else { - fields1093 := msg + fields1103 := msg p.write("(") p.write("terms") p.indentSexp() - if !(len(fields1093) == 0) { + if !(len(fields1103) == 0) { p.newline() - for i1095, elem1094 := range fields1093 { - if (i1095 > 0) { + for i1105, elem1104 := range fields1103 { + if (i1105 > 0) { p.newline() } - p.pretty_term(elem1094) + p.pretty_term(elem1104) } } p.dedent() @@ -1991,30 +2022,30 @@ func (p *PrettyPrinter) pretty_terms(msg []*pb.Term) interface{} { } func (p *PrettyPrinter) pretty_term(msg *pb.Term) interface{} { - flat1101 := p.tryFlat(msg, func() { p.pretty_term(msg) }) - if flat1101 != nil { - p.write(*flat1101) + flat1111 := p.tryFlat(msg, func() { p.pretty_term(msg) }) + if flat1111 != nil { + p.write(*flat1111) return nil } else { _dollar_dollar := msg - var _t1769 *pb.Var + var _t1780 *pb.Var if hasProtoField(_dollar_dollar, "var") { - _t1769 = _dollar_dollar.GetVar() + _t1780 = _dollar_dollar.GetVar() } - deconstruct_result1099 := _t1769 - if deconstruct_result1099 != nil { - unwrapped1100 := deconstruct_result1099 - p.pretty_var(unwrapped1100) + deconstruct_result1109 := _t1780 + if deconstruct_result1109 != nil { + unwrapped1110 := deconstruct_result1109 + p.pretty_var(unwrapped1110) } else { _dollar_dollar := msg - var _t1770 *pb.Value + var _t1781 *pb.Value if hasProtoField(_dollar_dollar, "constant") { - _t1770 = _dollar_dollar.GetConstant() + _t1781 = _dollar_dollar.GetConstant() } - deconstruct_result1097 := _t1770 - if deconstruct_result1097 != nil { - unwrapped1098 := deconstruct_result1097 - p.pretty_value(unwrapped1098) + deconstruct_result1107 := _t1781 + if deconstruct_result1107 != nil { + unwrapped1108 := deconstruct_result1107 + p.pretty_value(unwrapped1108) } else { panic(ParseError{msg: "No matching rule for term"}) } @@ -2024,147 +2055,147 @@ func (p *PrettyPrinter) pretty_term(msg *pb.Term) interface{} { } func (p *PrettyPrinter) pretty_var(msg *pb.Var) interface{} { - flat1104 := p.tryFlat(msg, func() { p.pretty_var(msg) }) - if flat1104 != nil { - p.write(*flat1104) + flat1114 := p.tryFlat(msg, func() { p.pretty_var(msg) }) + if flat1114 != nil { + p.write(*flat1114) return nil } else { _dollar_dollar := msg - fields1102 := _dollar_dollar.GetName() - unwrapped_fields1103 := fields1102 - p.write(unwrapped_fields1103) + fields1112 := _dollar_dollar.GetName() + unwrapped_fields1113 := fields1112 + p.write(unwrapped_fields1113) } return nil } func (p *PrettyPrinter) pretty_value(msg *pb.Value) interface{} { - flat1130 := p.tryFlat(msg, func() { p.pretty_value(msg) }) - if flat1130 != nil { - p.write(*flat1130) + flat1140 := p.tryFlat(msg, func() { p.pretty_value(msg) }) + if flat1140 != nil { + p.write(*flat1140) return nil } else { _dollar_dollar := msg - var _t1771 *pb.DateValue + var _t1782 *pb.DateValue if hasProtoField(_dollar_dollar, "date_value") { - _t1771 = _dollar_dollar.GetDateValue() + _t1782 = _dollar_dollar.GetDateValue() } - deconstruct_result1128 := _t1771 - if deconstruct_result1128 != nil { - unwrapped1129 := deconstruct_result1128 - p.pretty_date(unwrapped1129) + deconstruct_result1138 := _t1782 + if deconstruct_result1138 != nil { + unwrapped1139 := deconstruct_result1138 + p.pretty_date(unwrapped1139) } else { _dollar_dollar := msg - var _t1772 *pb.DateTimeValue + var _t1783 *pb.DateTimeValue if hasProtoField(_dollar_dollar, "datetime_value") { - _t1772 = _dollar_dollar.GetDatetimeValue() + _t1783 = _dollar_dollar.GetDatetimeValue() } - deconstruct_result1126 := _t1772 - if deconstruct_result1126 != nil { - unwrapped1127 := deconstruct_result1126 - p.pretty_datetime(unwrapped1127) + deconstruct_result1136 := _t1783 + if deconstruct_result1136 != nil { + unwrapped1137 := deconstruct_result1136 + p.pretty_datetime(unwrapped1137) } else { _dollar_dollar := msg - var _t1773 *string + var _t1784 *string if hasProtoField(_dollar_dollar, "string_value") { - _t1773 = ptr(_dollar_dollar.GetStringValue()) + _t1784 = ptr(_dollar_dollar.GetStringValue()) } - deconstruct_result1124 := _t1773 - if deconstruct_result1124 != nil { - unwrapped1125 := *deconstruct_result1124 - p.write(p.formatStringValue(unwrapped1125)) + deconstruct_result1134 := _t1784 + if deconstruct_result1134 != nil { + unwrapped1135 := *deconstruct_result1134 + p.write(p.formatStringValue(unwrapped1135)) } else { _dollar_dollar := msg - var _t1774 *int32 + var _t1785 *int32 if hasProtoField(_dollar_dollar, "int32_value") { - _t1774 = ptr(_dollar_dollar.GetInt32Value()) + _t1785 = ptr(_dollar_dollar.GetInt32Value()) } - deconstruct_result1122 := _t1774 - if deconstruct_result1122 != nil { - unwrapped1123 := *deconstruct_result1122 - p.write(fmt.Sprintf("%di32", unwrapped1123)) + deconstruct_result1132 := _t1785 + if deconstruct_result1132 != nil { + unwrapped1133 := *deconstruct_result1132 + p.write(fmt.Sprintf("%di32", unwrapped1133)) } else { _dollar_dollar := msg - var _t1775 *int64 + var _t1786 *int64 if hasProtoField(_dollar_dollar, "int_value") { - _t1775 = ptr(_dollar_dollar.GetIntValue()) + _t1786 = ptr(_dollar_dollar.GetIntValue()) } - deconstruct_result1120 := _t1775 - if deconstruct_result1120 != nil { - unwrapped1121 := *deconstruct_result1120 - p.write(fmt.Sprintf("%d", unwrapped1121)) + deconstruct_result1130 := _t1786 + if deconstruct_result1130 != nil { + unwrapped1131 := *deconstruct_result1130 + p.write(fmt.Sprintf("%d", unwrapped1131)) } else { _dollar_dollar := msg - var _t1776 *float32 + var _t1787 *float32 if hasProtoField(_dollar_dollar, "float32_value") { - _t1776 = ptr(_dollar_dollar.GetFloat32Value()) + _t1787 = ptr(_dollar_dollar.GetFloat32Value()) } - deconstruct_result1118 := _t1776 - if deconstruct_result1118 != nil { - unwrapped1119 := *deconstruct_result1118 - p.write(formatFloat32(unwrapped1119)) + deconstruct_result1128 := _t1787 + if deconstruct_result1128 != nil { + unwrapped1129 := *deconstruct_result1128 + p.write(formatFloat32(unwrapped1129)) } else { _dollar_dollar := msg - var _t1777 *float64 + var _t1788 *float64 if hasProtoField(_dollar_dollar, "float_value") { - _t1777 = ptr(_dollar_dollar.GetFloatValue()) + _t1788 = ptr(_dollar_dollar.GetFloatValue()) } - deconstruct_result1116 := _t1777 - if deconstruct_result1116 != nil { - unwrapped1117 := *deconstruct_result1116 - p.write(formatFloat64(unwrapped1117)) + deconstruct_result1126 := _t1788 + if deconstruct_result1126 != nil { + unwrapped1127 := *deconstruct_result1126 + p.write(formatFloat64(unwrapped1127)) } else { _dollar_dollar := msg - var _t1778 *uint32 + var _t1789 *uint32 if hasProtoField(_dollar_dollar, "uint32_value") { - _t1778 = ptr(_dollar_dollar.GetUint32Value()) + _t1789 = ptr(_dollar_dollar.GetUint32Value()) } - deconstruct_result1114 := _t1778 - if deconstruct_result1114 != nil { - unwrapped1115 := *deconstruct_result1114 - p.write(fmt.Sprintf("%du32", unwrapped1115)) + deconstruct_result1124 := _t1789 + if deconstruct_result1124 != nil { + unwrapped1125 := *deconstruct_result1124 + p.write(fmt.Sprintf("%du32", unwrapped1125)) } else { _dollar_dollar := msg - var _t1779 *pb.UInt128Value + var _t1790 *pb.UInt128Value if hasProtoField(_dollar_dollar, "uint128_value") { - _t1779 = _dollar_dollar.GetUint128Value() + _t1790 = _dollar_dollar.GetUint128Value() } - deconstruct_result1112 := _t1779 - if deconstruct_result1112 != nil { - unwrapped1113 := deconstruct_result1112 - p.write(p.formatUint128(unwrapped1113)) + deconstruct_result1122 := _t1790 + if deconstruct_result1122 != nil { + unwrapped1123 := deconstruct_result1122 + p.write(p.formatUint128(unwrapped1123)) } else { _dollar_dollar := msg - var _t1780 *pb.Int128Value + var _t1791 *pb.Int128Value if hasProtoField(_dollar_dollar, "int128_value") { - _t1780 = _dollar_dollar.GetInt128Value() + _t1791 = _dollar_dollar.GetInt128Value() } - deconstruct_result1110 := _t1780 - if deconstruct_result1110 != nil { - unwrapped1111 := deconstruct_result1110 - p.write(p.formatInt128(unwrapped1111)) + deconstruct_result1120 := _t1791 + if deconstruct_result1120 != nil { + unwrapped1121 := deconstruct_result1120 + p.write(p.formatInt128(unwrapped1121)) } else { _dollar_dollar := msg - var _t1781 *pb.DecimalValue + var _t1792 *pb.DecimalValue if hasProtoField(_dollar_dollar, "decimal_value") { - _t1781 = _dollar_dollar.GetDecimalValue() + _t1792 = _dollar_dollar.GetDecimalValue() } - deconstruct_result1108 := _t1781 - if deconstruct_result1108 != nil { - unwrapped1109 := deconstruct_result1108 - p.write(p.formatDecimal(unwrapped1109)) + deconstruct_result1118 := _t1792 + if deconstruct_result1118 != nil { + unwrapped1119 := deconstruct_result1118 + p.write(p.formatDecimal(unwrapped1119)) } else { _dollar_dollar := msg - var _t1782 *bool + var _t1793 *bool if hasProtoField(_dollar_dollar, "boolean_value") { - _t1782 = ptr(_dollar_dollar.GetBooleanValue()) + _t1793 = ptr(_dollar_dollar.GetBooleanValue()) } - deconstruct_result1106 := _t1782 - if deconstruct_result1106 != nil { - unwrapped1107 := *deconstruct_result1106 - p.pretty_boolean_value(unwrapped1107) + deconstruct_result1116 := _t1793 + if deconstruct_result1116 != nil { + unwrapped1117 := *deconstruct_result1116 + p.pretty_boolean_value(unwrapped1117) } else { - fields1105 := msg - _ = fields1105 + fields1115 := msg + _ = fields1115 p.write("missing") } } @@ -2183,26 +2214,26 @@ func (p *PrettyPrinter) pretty_value(msg *pb.Value) interface{} { } func (p *PrettyPrinter) pretty_date(msg *pb.DateValue) interface{} { - flat1136 := p.tryFlat(msg, func() { p.pretty_date(msg) }) - if flat1136 != nil { - p.write(*flat1136) + flat1146 := p.tryFlat(msg, func() { p.pretty_date(msg) }) + if flat1146 != nil { + p.write(*flat1146) return nil } else { _dollar_dollar := msg - fields1131 := []interface{}{int64(_dollar_dollar.GetYear()), int64(_dollar_dollar.GetMonth()), int64(_dollar_dollar.GetDay())} - unwrapped_fields1132 := fields1131 + fields1141 := []interface{}{int64(_dollar_dollar.GetYear()), int64(_dollar_dollar.GetMonth()), int64(_dollar_dollar.GetDay())} + unwrapped_fields1142 := fields1141 p.write("(") p.write("date") p.indentSexp() p.newline() - field1133 := unwrapped_fields1132[0].(int64) - p.write(fmt.Sprintf("%d", field1133)) + field1143 := unwrapped_fields1142[0].(int64) + p.write(fmt.Sprintf("%d", field1143)) p.newline() - field1134 := unwrapped_fields1132[1].(int64) - p.write(fmt.Sprintf("%d", field1134)) + field1144 := unwrapped_fields1142[1].(int64) + p.write(fmt.Sprintf("%d", field1144)) p.newline() - field1135 := unwrapped_fields1132[2].(int64) - p.write(fmt.Sprintf("%d", field1135)) + field1145 := unwrapped_fields1142[2].(int64) + p.write(fmt.Sprintf("%d", field1145)) p.dedent() p.write(")") } @@ -2210,40 +2241,40 @@ func (p *PrettyPrinter) pretty_date(msg *pb.DateValue) interface{} { } func (p *PrettyPrinter) pretty_datetime(msg *pb.DateTimeValue) interface{} { - flat1147 := p.tryFlat(msg, func() { p.pretty_datetime(msg) }) - if flat1147 != nil { - p.write(*flat1147) + flat1157 := p.tryFlat(msg, func() { p.pretty_datetime(msg) }) + if flat1157 != nil { + p.write(*flat1157) return nil } else { _dollar_dollar := msg - fields1137 := []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_fields1138 := fields1137 + fields1147 := []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_fields1148 := fields1147 p.write("(") p.write("datetime") p.indentSexp() p.newline() - field1139 := unwrapped_fields1138[0].(int64) - p.write(fmt.Sprintf("%d", field1139)) + field1149 := unwrapped_fields1148[0].(int64) + p.write(fmt.Sprintf("%d", field1149)) p.newline() - field1140 := unwrapped_fields1138[1].(int64) - p.write(fmt.Sprintf("%d", field1140)) + field1150 := unwrapped_fields1148[1].(int64) + p.write(fmt.Sprintf("%d", field1150)) p.newline() - field1141 := unwrapped_fields1138[2].(int64) - p.write(fmt.Sprintf("%d", field1141)) + field1151 := unwrapped_fields1148[2].(int64) + p.write(fmt.Sprintf("%d", field1151)) p.newline() - field1142 := unwrapped_fields1138[3].(int64) - p.write(fmt.Sprintf("%d", field1142)) + field1152 := unwrapped_fields1148[3].(int64) + p.write(fmt.Sprintf("%d", field1152)) p.newline() - field1143 := unwrapped_fields1138[4].(int64) - p.write(fmt.Sprintf("%d", field1143)) + field1153 := unwrapped_fields1148[4].(int64) + p.write(fmt.Sprintf("%d", field1153)) p.newline() - field1144 := unwrapped_fields1138[5].(int64) - p.write(fmt.Sprintf("%d", field1144)) - field1145 := unwrapped_fields1138[6].(*int64) - if field1145 != nil { + field1154 := unwrapped_fields1148[5].(int64) + p.write(fmt.Sprintf("%d", field1154)) + field1155 := unwrapped_fields1148[6].(*int64) + if field1155 != nil { p.newline() - opt_val1146 := *field1145 - p.write(fmt.Sprintf("%d", opt_val1146)) + opt_val1156 := *field1155 + p.write(fmt.Sprintf("%d", opt_val1156)) } p.dedent() p.write(")") @@ -2252,24 +2283,24 @@ func (p *PrettyPrinter) pretty_datetime(msg *pb.DateTimeValue) interface{} { } func (p *PrettyPrinter) pretty_conjunction(msg *pb.Conjunction) interface{} { - flat1152 := p.tryFlat(msg, func() { p.pretty_conjunction(msg) }) - if flat1152 != nil { - p.write(*flat1152) + flat1162 := p.tryFlat(msg, func() { p.pretty_conjunction(msg) }) + if flat1162 != nil { + p.write(*flat1162) return nil } else { _dollar_dollar := msg - fields1148 := _dollar_dollar.GetArgs() - unwrapped_fields1149 := fields1148 + fields1158 := _dollar_dollar.GetArgs() + unwrapped_fields1159 := fields1158 p.write("(") p.write("and") p.indentSexp() - if !(len(unwrapped_fields1149) == 0) { + if !(len(unwrapped_fields1159) == 0) { p.newline() - for i1151, elem1150 := range unwrapped_fields1149 { - if (i1151 > 0) { + for i1161, elem1160 := range unwrapped_fields1159 { + if (i1161 > 0) { p.newline() } - p.pretty_formula(elem1150) + p.pretty_formula(elem1160) } } p.dedent() @@ -2279,24 +2310,24 @@ func (p *PrettyPrinter) pretty_conjunction(msg *pb.Conjunction) interface{} { } func (p *PrettyPrinter) pretty_disjunction(msg *pb.Disjunction) interface{} { - flat1157 := p.tryFlat(msg, func() { p.pretty_disjunction(msg) }) - if flat1157 != nil { - p.write(*flat1157) + flat1167 := p.tryFlat(msg, func() { p.pretty_disjunction(msg) }) + if flat1167 != nil { + p.write(*flat1167) return nil } else { _dollar_dollar := msg - fields1153 := _dollar_dollar.GetArgs() - unwrapped_fields1154 := fields1153 + fields1163 := _dollar_dollar.GetArgs() + unwrapped_fields1164 := fields1163 p.write("(") p.write("or") p.indentSexp() - if !(len(unwrapped_fields1154) == 0) { + if !(len(unwrapped_fields1164) == 0) { p.newline() - for i1156, elem1155 := range unwrapped_fields1154 { - if (i1156 > 0) { + for i1166, elem1165 := range unwrapped_fields1164 { + if (i1166 > 0) { p.newline() } - p.pretty_formula(elem1155) + p.pretty_formula(elem1165) } } p.dedent() @@ -2306,19 +2337,19 @@ func (p *PrettyPrinter) pretty_disjunction(msg *pb.Disjunction) interface{} { } func (p *PrettyPrinter) pretty_not(msg *pb.Not) interface{} { - flat1160 := p.tryFlat(msg, func() { p.pretty_not(msg) }) - if flat1160 != nil { - p.write(*flat1160) + flat1170 := p.tryFlat(msg, func() { p.pretty_not(msg) }) + if flat1170 != nil { + p.write(*flat1170) return nil } else { _dollar_dollar := msg - fields1158 := _dollar_dollar.GetArg() - unwrapped_fields1159 := fields1158 + fields1168 := _dollar_dollar.GetArg() + unwrapped_fields1169 := fields1168 p.write("(") p.write("not") p.indentSexp() p.newline() - p.pretty_formula(unwrapped_fields1159) + p.pretty_formula(unwrapped_fields1169) p.dedent() p.write(")") } @@ -2326,26 +2357,26 @@ func (p *PrettyPrinter) pretty_not(msg *pb.Not) interface{} { } func (p *PrettyPrinter) pretty_ffi(msg *pb.FFI) interface{} { - flat1166 := p.tryFlat(msg, func() { p.pretty_ffi(msg) }) - if flat1166 != nil { - p.write(*flat1166) + flat1176 := p.tryFlat(msg, func() { p.pretty_ffi(msg) }) + if flat1176 != nil { + p.write(*flat1176) return nil } else { _dollar_dollar := msg - fields1161 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetArgs(), _dollar_dollar.GetTerms()} - unwrapped_fields1162 := fields1161 + fields1171 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetArgs(), _dollar_dollar.GetTerms()} + unwrapped_fields1172 := fields1171 p.write("(") p.write("ffi") p.indentSexp() p.newline() - field1163 := unwrapped_fields1162[0].(string) - p.pretty_name(field1163) + field1173 := unwrapped_fields1172[0].(string) + p.pretty_name(field1173) p.newline() - field1164 := unwrapped_fields1162[1].([]*pb.Abstraction) - p.pretty_ffi_args(field1164) + field1174 := unwrapped_fields1172[1].([]*pb.Abstraction) + p.pretty_ffi_args(field1174) p.newline() - field1165 := unwrapped_fields1162[2].([]*pb.Term) - p.pretty_terms(field1165) + field1175 := unwrapped_fields1172[2].([]*pb.Term) + p.pretty_terms(field1175) p.dedent() p.write(")") } @@ -2353,35 +2384,35 @@ func (p *PrettyPrinter) pretty_ffi(msg *pb.FFI) interface{} { } func (p *PrettyPrinter) pretty_name(msg string) interface{} { - flat1168 := p.tryFlat(msg, func() { p.pretty_name(msg) }) - if flat1168 != nil { - p.write(*flat1168) + flat1178 := p.tryFlat(msg, func() { p.pretty_name(msg) }) + if flat1178 != nil { + p.write(*flat1178) return nil } else { - fields1167 := msg + fields1177 := msg p.write(":") - p.write(fields1167) + p.write(fields1177) } return nil } func (p *PrettyPrinter) pretty_ffi_args(msg []*pb.Abstraction) interface{} { - flat1172 := p.tryFlat(msg, func() { p.pretty_ffi_args(msg) }) - if flat1172 != nil { - p.write(*flat1172) + flat1182 := p.tryFlat(msg, func() { p.pretty_ffi_args(msg) }) + if flat1182 != nil { + p.write(*flat1182) return nil } else { - fields1169 := msg + fields1179 := msg p.write("(") p.write("args") p.indentSexp() - if !(len(fields1169) == 0) { + if !(len(fields1179) == 0) { p.newline() - for i1171, elem1170 := range fields1169 { - if (i1171 > 0) { + for i1181, elem1180 := range fields1179 { + if (i1181 > 0) { p.newline() } - p.pretty_abstraction(elem1170) + p.pretty_abstraction(elem1180) } } p.dedent() @@ -2391,28 +2422,28 @@ func (p *PrettyPrinter) pretty_ffi_args(msg []*pb.Abstraction) interface{} { } func (p *PrettyPrinter) pretty_atom(msg *pb.Atom) interface{} { - flat1179 := p.tryFlat(msg, func() { p.pretty_atom(msg) }) - if flat1179 != nil { - p.write(*flat1179) + flat1189 := p.tryFlat(msg, func() { p.pretty_atom(msg) }) + if flat1189 != nil { + p.write(*flat1189) return nil } else { _dollar_dollar := msg - fields1173 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetTerms()} - unwrapped_fields1174 := fields1173 + fields1183 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetTerms()} + unwrapped_fields1184 := fields1183 p.write("(") p.write("atom") p.indentSexp() p.newline() - field1175 := unwrapped_fields1174[0].(*pb.RelationId) - p.pretty_relation_id(field1175) - field1176 := unwrapped_fields1174[1].([]*pb.Term) - if !(len(field1176) == 0) { + field1185 := unwrapped_fields1184[0].(*pb.RelationId) + p.pretty_relation_id(field1185) + field1186 := unwrapped_fields1184[1].([]*pb.Term) + if !(len(field1186) == 0) { p.newline() - for i1178, elem1177 := range field1176 { - if (i1178 > 0) { + for i1188, elem1187 := range field1186 { + if (i1188 > 0) { p.newline() } - p.pretty_term(elem1177) + p.pretty_term(elem1187) } } p.dedent() @@ -2422,28 +2453,28 @@ func (p *PrettyPrinter) pretty_atom(msg *pb.Atom) interface{} { } func (p *PrettyPrinter) pretty_pragma(msg *pb.Pragma) interface{} { - flat1186 := p.tryFlat(msg, func() { p.pretty_pragma(msg) }) - if flat1186 != nil { - p.write(*flat1186) + flat1196 := p.tryFlat(msg, func() { p.pretty_pragma(msg) }) + if flat1196 != nil { + p.write(*flat1196) return nil } else { _dollar_dollar := msg - fields1180 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetTerms()} - unwrapped_fields1181 := fields1180 + fields1190 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetTerms()} + unwrapped_fields1191 := fields1190 p.write("(") p.write("pragma") p.indentSexp() p.newline() - field1182 := unwrapped_fields1181[0].(string) - p.pretty_name(field1182) - field1183 := unwrapped_fields1181[1].([]*pb.Term) - if !(len(field1183) == 0) { + field1192 := unwrapped_fields1191[0].(string) + p.pretty_name(field1192) + field1193 := unwrapped_fields1191[1].([]*pb.Term) + if !(len(field1193) == 0) { p.newline() - for i1185, elem1184 := range field1183 { - if (i1185 > 0) { + for i1195, elem1194 := range field1193 { + if (i1195 > 0) { p.newline() } - p.pretty_term(elem1184) + p.pretty_term(elem1194) } } p.dedent() @@ -2453,109 +2484,109 @@ func (p *PrettyPrinter) pretty_pragma(msg *pb.Pragma) interface{} { } func (p *PrettyPrinter) pretty_primitive(msg *pb.Primitive) interface{} { - flat1202 := p.tryFlat(msg, func() { p.pretty_primitive(msg) }) - if flat1202 != nil { - p.write(*flat1202) + flat1212 := p.tryFlat(msg, func() { p.pretty_primitive(msg) }) + if flat1212 != nil { + p.write(*flat1212) return nil } else { _dollar_dollar := msg - var _t1783 []interface{} + var _t1794 []interface{} if _dollar_dollar.GetName() == "rel_primitive_eq" { - _t1783 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} + _t1794 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} } - guard_result1201 := _t1783 - if guard_result1201 != nil { + guard_result1211 := _t1794 + if guard_result1211 != nil { p.pretty_eq(msg) } else { _dollar_dollar := msg - var _t1784 []interface{} + var _t1795 []interface{} if _dollar_dollar.GetName() == "rel_primitive_lt_monotype" { - _t1784 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} + _t1795 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} } - guard_result1200 := _t1784 - if guard_result1200 != nil { + guard_result1210 := _t1795 + if guard_result1210 != nil { p.pretty_lt(msg) } else { _dollar_dollar := msg - var _t1785 []interface{} + var _t1796 []interface{} if _dollar_dollar.GetName() == "rel_primitive_lt_eq_monotype" { - _t1785 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} + _t1796 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} } - guard_result1199 := _t1785 - if guard_result1199 != nil { + guard_result1209 := _t1796 + if guard_result1209 != nil { p.pretty_lt_eq(msg) } else { _dollar_dollar := msg - var _t1786 []interface{} + var _t1797 []interface{} if _dollar_dollar.GetName() == "rel_primitive_gt_monotype" { - _t1786 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} + _t1797 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} } - guard_result1198 := _t1786 - if guard_result1198 != nil { + guard_result1208 := _t1797 + if guard_result1208 != nil { p.pretty_gt(msg) } else { _dollar_dollar := msg - var _t1787 []interface{} + var _t1798 []interface{} if _dollar_dollar.GetName() == "rel_primitive_gt_eq_monotype" { - _t1787 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} + _t1798 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} } - guard_result1197 := _t1787 - if guard_result1197 != nil { + guard_result1207 := _t1798 + if guard_result1207 != nil { p.pretty_gt_eq(msg) } else { _dollar_dollar := msg - var _t1788 []interface{} + var _t1799 []interface{} if _dollar_dollar.GetName() == "rel_primitive_add_monotype" { - _t1788 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} + _t1799 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} } - guard_result1196 := _t1788 - if guard_result1196 != nil { + guard_result1206 := _t1799 + if guard_result1206 != nil { p.pretty_add(msg) } else { _dollar_dollar := msg - var _t1789 []interface{} + var _t1800 []interface{} if _dollar_dollar.GetName() == "rel_primitive_subtract_monotype" { - _t1789 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} + _t1800 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} } - guard_result1195 := _t1789 - if guard_result1195 != nil { + guard_result1205 := _t1800 + if guard_result1205 != nil { p.pretty_minus(msg) } else { _dollar_dollar := msg - var _t1790 []interface{} + var _t1801 []interface{} if _dollar_dollar.GetName() == "rel_primitive_multiply_monotype" { - _t1790 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} + _t1801 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} } - guard_result1194 := _t1790 - if guard_result1194 != nil { + guard_result1204 := _t1801 + if guard_result1204 != nil { p.pretty_multiply(msg) } else { _dollar_dollar := msg - var _t1791 []interface{} + var _t1802 []interface{} if _dollar_dollar.GetName() == "rel_primitive_divide_monotype" { - _t1791 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} + _t1802 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} } - guard_result1193 := _t1791 - if guard_result1193 != nil { + guard_result1203 := _t1802 + if guard_result1203 != nil { p.pretty_divide(msg) } else { _dollar_dollar := msg - fields1187 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetTerms()} - unwrapped_fields1188 := fields1187 + fields1197 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetTerms()} + unwrapped_fields1198 := fields1197 p.write("(") p.write("primitive") p.indentSexp() p.newline() - field1189 := unwrapped_fields1188[0].(string) - p.pretty_name(field1189) - field1190 := unwrapped_fields1188[1].([]*pb.RelTerm) - if !(len(field1190) == 0) { + field1199 := unwrapped_fields1198[0].(string) + p.pretty_name(field1199) + field1200 := unwrapped_fields1198[1].([]*pb.RelTerm) + if !(len(field1200) == 0) { p.newline() - for i1192, elem1191 := range field1190 { - if (i1192 > 0) { + for i1202, elem1201 := range field1200 { + if (i1202 > 0) { p.newline() } - p.pretty_rel_term(elem1191) + p.pretty_rel_term(elem1201) } } p.dedent() @@ -2574,27 +2605,27 @@ func (p *PrettyPrinter) pretty_primitive(msg *pb.Primitive) interface{} { } func (p *PrettyPrinter) pretty_eq(msg *pb.Primitive) interface{} { - flat1207 := p.tryFlat(msg, func() { p.pretty_eq(msg) }) - if flat1207 != nil { - p.write(*flat1207) + flat1217 := p.tryFlat(msg, func() { p.pretty_eq(msg) }) + if flat1217 != nil { + p.write(*flat1217) return nil } else { _dollar_dollar := msg - var _t1792 []interface{} + var _t1803 []interface{} if _dollar_dollar.GetName() == "rel_primitive_eq" { - _t1792 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} + _t1803 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} } - fields1203 := _t1792 - unwrapped_fields1204 := fields1203 + fields1213 := _t1803 + unwrapped_fields1214 := fields1213 p.write("(") p.write("=") p.indentSexp() p.newline() - field1205 := unwrapped_fields1204[0].(*pb.Term) - p.pretty_term(field1205) + field1215 := unwrapped_fields1214[0].(*pb.Term) + p.pretty_term(field1215) p.newline() - field1206 := unwrapped_fields1204[1].(*pb.Term) - p.pretty_term(field1206) + field1216 := unwrapped_fields1214[1].(*pb.Term) + p.pretty_term(field1216) p.dedent() p.write(")") } @@ -2602,27 +2633,27 @@ func (p *PrettyPrinter) pretty_eq(msg *pb.Primitive) interface{} { } func (p *PrettyPrinter) pretty_lt(msg *pb.Primitive) interface{} { - flat1212 := p.tryFlat(msg, func() { p.pretty_lt(msg) }) - if flat1212 != nil { - p.write(*flat1212) + flat1222 := p.tryFlat(msg, func() { p.pretty_lt(msg) }) + if flat1222 != nil { + p.write(*flat1222) return nil } else { _dollar_dollar := msg - var _t1793 []interface{} + var _t1804 []interface{} if _dollar_dollar.GetName() == "rel_primitive_lt_monotype" { - _t1793 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} + _t1804 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} } - fields1208 := _t1793 - unwrapped_fields1209 := fields1208 + fields1218 := _t1804 + unwrapped_fields1219 := fields1218 p.write("(") p.write("<") p.indentSexp() p.newline() - field1210 := unwrapped_fields1209[0].(*pb.Term) - p.pretty_term(field1210) + field1220 := unwrapped_fields1219[0].(*pb.Term) + p.pretty_term(field1220) p.newline() - field1211 := unwrapped_fields1209[1].(*pb.Term) - p.pretty_term(field1211) + field1221 := unwrapped_fields1219[1].(*pb.Term) + p.pretty_term(field1221) p.dedent() p.write(")") } @@ -2630,27 +2661,27 @@ func (p *PrettyPrinter) pretty_lt(msg *pb.Primitive) interface{} { } func (p *PrettyPrinter) pretty_lt_eq(msg *pb.Primitive) interface{} { - flat1217 := p.tryFlat(msg, func() { p.pretty_lt_eq(msg) }) - if flat1217 != nil { - p.write(*flat1217) + flat1227 := p.tryFlat(msg, func() { p.pretty_lt_eq(msg) }) + if flat1227 != nil { + p.write(*flat1227) return nil } else { _dollar_dollar := msg - var _t1794 []interface{} + var _t1805 []interface{} if _dollar_dollar.GetName() == "rel_primitive_lt_eq_monotype" { - _t1794 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} + _t1805 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} } - fields1213 := _t1794 - unwrapped_fields1214 := fields1213 + fields1223 := _t1805 + unwrapped_fields1224 := fields1223 p.write("(") p.write("<=") p.indentSexp() p.newline() - field1215 := unwrapped_fields1214[0].(*pb.Term) - p.pretty_term(field1215) + field1225 := unwrapped_fields1224[0].(*pb.Term) + p.pretty_term(field1225) p.newline() - field1216 := unwrapped_fields1214[1].(*pb.Term) - p.pretty_term(field1216) + field1226 := unwrapped_fields1224[1].(*pb.Term) + p.pretty_term(field1226) p.dedent() p.write(")") } @@ -2658,27 +2689,27 @@ func (p *PrettyPrinter) pretty_lt_eq(msg *pb.Primitive) interface{} { } func (p *PrettyPrinter) pretty_gt(msg *pb.Primitive) interface{} { - flat1222 := p.tryFlat(msg, func() { p.pretty_gt(msg) }) - if flat1222 != nil { - p.write(*flat1222) + flat1232 := p.tryFlat(msg, func() { p.pretty_gt(msg) }) + if flat1232 != nil { + p.write(*flat1232) return nil } else { _dollar_dollar := msg - var _t1795 []interface{} + var _t1806 []interface{} if _dollar_dollar.GetName() == "rel_primitive_gt_monotype" { - _t1795 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} + _t1806 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} } - fields1218 := _t1795 - unwrapped_fields1219 := fields1218 + fields1228 := _t1806 + unwrapped_fields1229 := fields1228 p.write("(") p.write(">") p.indentSexp() p.newline() - field1220 := unwrapped_fields1219[0].(*pb.Term) - p.pretty_term(field1220) + field1230 := unwrapped_fields1229[0].(*pb.Term) + p.pretty_term(field1230) p.newline() - field1221 := unwrapped_fields1219[1].(*pb.Term) - p.pretty_term(field1221) + field1231 := unwrapped_fields1229[1].(*pb.Term) + p.pretty_term(field1231) p.dedent() p.write(")") } @@ -2686,27 +2717,27 @@ func (p *PrettyPrinter) pretty_gt(msg *pb.Primitive) interface{} { } func (p *PrettyPrinter) pretty_gt_eq(msg *pb.Primitive) interface{} { - flat1227 := p.tryFlat(msg, func() { p.pretty_gt_eq(msg) }) - if flat1227 != nil { - p.write(*flat1227) + flat1237 := p.tryFlat(msg, func() { p.pretty_gt_eq(msg) }) + if flat1237 != nil { + p.write(*flat1237) return nil } else { _dollar_dollar := msg - var _t1796 []interface{} + var _t1807 []interface{} if _dollar_dollar.GetName() == "rel_primitive_gt_eq_monotype" { - _t1796 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} + _t1807 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} } - fields1223 := _t1796 - unwrapped_fields1224 := fields1223 + fields1233 := _t1807 + unwrapped_fields1234 := fields1233 p.write("(") p.write(">=") p.indentSexp() p.newline() - field1225 := unwrapped_fields1224[0].(*pb.Term) - p.pretty_term(field1225) + field1235 := unwrapped_fields1234[0].(*pb.Term) + p.pretty_term(field1235) p.newline() - field1226 := unwrapped_fields1224[1].(*pb.Term) - p.pretty_term(field1226) + field1236 := unwrapped_fields1234[1].(*pb.Term) + p.pretty_term(field1236) p.dedent() p.write(")") } @@ -2714,30 +2745,30 @@ func (p *PrettyPrinter) pretty_gt_eq(msg *pb.Primitive) interface{} { } func (p *PrettyPrinter) pretty_add(msg *pb.Primitive) interface{} { - flat1233 := p.tryFlat(msg, func() { p.pretty_add(msg) }) - if flat1233 != nil { - p.write(*flat1233) + flat1243 := p.tryFlat(msg, func() { p.pretty_add(msg) }) + if flat1243 != nil { + p.write(*flat1243) return nil } else { _dollar_dollar := msg - var _t1797 []interface{} + var _t1808 []interface{} if _dollar_dollar.GetName() == "rel_primitive_add_monotype" { - _t1797 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} + _t1808 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} } - fields1228 := _t1797 - unwrapped_fields1229 := fields1228 + fields1238 := _t1808 + unwrapped_fields1239 := fields1238 p.write("(") p.write("+") p.indentSexp() p.newline() - field1230 := unwrapped_fields1229[0].(*pb.Term) - p.pretty_term(field1230) + field1240 := unwrapped_fields1239[0].(*pb.Term) + p.pretty_term(field1240) p.newline() - field1231 := unwrapped_fields1229[1].(*pb.Term) - p.pretty_term(field1231) + field1241 := unwrapped_fields1239[1].(*pb.Term) + p.pretty_term(field1241) p.newline() - field1232 := unwrapped_fields1229[2].(*pb.Term) - p.pretty_term(field1232) + field1242 := unwrapped_fields1239[2].(*pb.Term) + p.pretty_term(field1242) p.dedent() p.write(")") } @@ -2745,30 +2776,30 @@ func (p *PrettyPrinter) pretty_add(msg *pb.Primitive) interface{} { } func (p *PrettyPrinter) pretty_minus(msg *pb.Primitive) interface{} { - flat1239 := p.tryFlat(msg, func() { p.pretty_minus(msg) }) - if flat1239 != nil { - p.write(*flat1239) + flat1249 := p.tryFlat(msg, func() { p.pretty_minus(msg) }) + if flat1249 != nil { + p.write(*flat1249) return nil } else { _dollar_dollar := msg - var _t1798 []interface{} + var _t1809 []interface{} if _dollar_dollar.GetName() == "rel_primitive_subtract_monotype" { - _t1798 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} + _t1809 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} } - fields1234 := _t1798 - unwrapped_fields1235 := fields1234 + fields1244 := _t1809 + unwrapped_fields1245 := fields1244 p.write("(") p.write("-") p.indentSexp() p.newline() - field1236 := unwrapped_fields1235[0].(*pb.Term) - p.pretty_term(field1236) + field1246 := unwrapped_fields1245[0].(*pb.Term) + p.pretty_term(field1246) p.newline() - field1237 := unwrapped_fields1235[1].(*pb.Term) - p.pretty_term(field1237) + field1247 := unwrapped_fields1245[1].(*pb.Term) + p.pretty_term(field1247) p.newline() - field1238 := unwrapped_fields1235[2].(*pb.Term) - p.pretty_term(field1238) + field1248 := unwrapped_fields1245[2].(*pb.Term) + p.pretty_term(field1248) p.dedent() p.write(")") } @@ -2776,30 +2807,30 @@ func (p *PrettyPrinter) pretty_minus(msg *pb.Primitive) interface{} { } func (p *PrettyPrinter) pretty_multiply(msg *pb.Primitive) interface{} { - flat1245 := p.tryFlat(msg, func() { p.pretty_multiply(msg) }) - if flat1245 != nil { - p.write(*flat1245) + flat1255 := p.tryFlat(msg, func() { p.pretty_multiply(msg) }) + if flat1255 != nil { + p.write(*flat1255) return nil } else { _dollar_dollar := msg - var _t1799 []interface{} + var _t1810 []interface{} if _dollar_dollar.GetName() == "rel_primitive_multiply_monotype" { - _t1799 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} + _t1810 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} } - fields1240 := _t1799 - unwrapped_fields1241 := fields1240 + fields1250 := _t1810 + unwrapped_fields1251 := fields1250 p.write("(") p.write("*") p.indentSexp() p.newline() - field1242 := unwrapped_fields1241[0].(*pb.Term) - p.pretty_term(field1242) + field1252 := unwrapped_fields1251[0].(*pb.Term) + p.pretty_term(field1252) p.newline() - field1243 := unwrapped_fields1241[1].(*pb.Term) - p.pretty_term(field1243) + field1253 := unwrapped_fields1251[1].(*pb.Term) + p.pretty_term(field1253) p.newline() - field1244 := unwrapped_fields1241[2].(*pb.Term) - p.pretty_term(field1244) + field1254 := unwrapped_fields1251[2].(*pb.Term) + p.pretty_term(field1254) p.dedent() p.write(")") } @@ -2807,30 +2838,30 @@ func (p *PrettyPrinter) pretty_multiply(msg *pb.Primitive) interface{} { } func (p *PrettyPrinter) pretty_divide(msg *pb.Primitive) interface{} { - flat1251 := p.tryFlat(msg, func() { p.pretty_divide(msg) }) - if flat1251 != nil { - p.write(*flat1251) + flat1261 := p.tryFlat(msg, func() { p.pretty_divide(msg) }) + if flat1261 != nil { + p.write(*flat1261) return nil } else { _dollar_dollar := msg - var _t1800 []interface{} + var _t1811 []interface{} if _dollar_dollar.GetName() == "rel_primitive_divide_monotype" { - _t1800 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} + _t1811 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} } - fields1246 := _t1800 - unwrapped_fields1247 := fields1246 + fields1256 := _t1811 + unwrapped_fields1257 := fields1256 p.write("(") p.write("/") p.indentSexp() p.newline() - field1248 := unwrapped_fields1247[0].(*pb.Term) - p.pretty_term(field1248) + field1258 := unwrapped_fields1257[0].(*pb.Term) + p.pretty_term(field1258) p.newline() - field1249 := unwrapped_fields1247[1].(*pb.Term) - p.pretty_term(field1249) + field1259 := unwrapped_fields1257[1].(*pb.Term) + p.pretty_term(field1259) p.newline() - field1250 := unwrapped_fields1247[2].(*pb.Term) - p.pretty_term(field1250) + field1260 := unwrapped_fields1257[2].(*pb.Term) + p.pretty_term(field1260) p.dedent() p.write(")") } @@ -2838,30 +2869,30 @@ func (p *PrettyPrinter) pretty_divide(msg *pb.Primitive) interface{} { } func (p *PrettyPrinter) pretty_rel_term(msg *pb.RelTerm) interface{} { - flat1256 := p.tryFlat(msg, func() { p.pretty_rel_term(msg) }) - if flat1256 != nil { - p.write(*flat1256) + flat1266 := p.tryFlat(msg, func() { p.pretty_rel_term(msg) }) + if flat1266 != nil { + p.write(*flat1266) return nil } else { _dollar_dollar := msg - var _t1801 *pb.Value + var _t1812 *pb.Value if hasProtoField(_dollar_dollar, "specialized_value") { - _t1801 = _dollar_dollar.GetSpecializedValue() + _t1812 = _dollar_dollar.GetSpecializedValue() } - deconstruct_result1254 := _t1801 - if deconstruct_result1254 != nil { - unwrapped1255 := deconstruct_result1254 - p.pretty_specialized_value(unwrapped1255) + deconstruct_result1264 := _t1812 + if deconstruct_result1264 != nil { + unwrapped1265 := deconstruct_result1264 + p.pretty_specialized_value(unwrapped1265) } else { _dollar_dollar := msg - var _t1802 *pb.Term + var _t1813 *pb.Term if hasProtoField(_dollar_dollar, "term") { - _t1802 = _dollar_dollar.GetTerm() + _t1813 = _dollar_dollar.GetTerm() } - deconstruct_result1252 := _t1802 - if deconstruct_result1252 != nil { - unwrapped1253 := deconstruct_result1252 - p.pretty_term(unwrapped1253) + deconstruct_result1262 := _t1813 + if deconstruct_result1262 != nil { + unwrapped1263 := deconstruct_result1262 + p.pretty_term(unwrapped1263) } else { panic(ParseError{msg: "No matching rule for rel_term"}) } @@ -2871,41 +2902,41 @@ func (p *PrettyPrinter) pretty_rel_term(msg *pb.RelTerm) interface{} { } func (p *PrettyPrinter) pretty_specialized_value(msg *pb.Value) interface{} { - flat1258 := p.tryFlat(msg, func() { p.pretty_specialized_value(msg) }) - if flat1258 != nil { - p.write(*flat1258) + flat1268 := p.tryFlat(msg, func() { p.pretty_specialized_value(msg) }) + if flat1268 != nil { + p.write(*flat1268) return nil } else { - fields1257 := msg + fields1267 := msg p.write("#") - p.pretty_raw_value(fields1257) + p.pretty_raw_value(fields1267) } return nil } func (p *PrettyPrinter) pretty_rel_atom(msg *pb.RelAtom) interface{} { - flat1265 := p.tryFlat(msg, func() { p.pretty_rel_atom(msg) }) - if flat1265 != nil { - p.write(*flat1265) + flat1275 := p.tryFlat(msg, func() { p.pretty_rel_atom(msg) }) + if flat1275 != nil { + p.write(*flat1275) return nil } else { _dollar_dollar := msg - fields1259 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetTerms()} - unwrapped_fields1260 := fields1259 + fields1269 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetTerms()} + unwrapped_fields1270 := fields1269 p.write("(") p.write("relatom") p.indentSexp() p.newline() - field1261 := unwrapped_fields1260[0].(string) - p.pretty_name(field1261) - field1262 := unwrapped_fields1260[1].([]*pb.RelTerm) - if !(len(field1262) == 0) { + field1271 := unwrapped_fields1270[0].(string) + p.pretty_name(field1271) + field1272 := unwrapped_fields1270[1].([]*pb.RelTerm) + if !(len(field1272) == 0) { p.newline() - for i1264, elem1263 := range field1262 { - if (i1264 > 0) { + for i1274, elem1273 := range field1272 { + if (i1274 > 0) { p.newline() } - p.pretty_rel_term(elem1263) + p.pretty_rel_term(elem1273) } } p.dedent() @@ -2915,23 +2946,23 @@ func (p *PrettyPrinter) pretty_rel_atom(msg *pb.RelAtom) interface{} { } func (p *PrettyPrinter) pretty_cast(msg *pb.Cast) interface{} { - flat1270 := p.tryFlat(msg, func() { p.pretty_cast(msg) }) - if flat1270 != nil { - p.write(*flat1270) + flat1280 := p.tryFlat(msg, func() { p.pretty_cast(msg) }) + if flat1280 != nil { + p.write(*flat1280) return nil } else { _dollar_dollar := msg - fields1266 := []interface{}{_dollar_dollar.GetInput(), _dollar_dollar.GetResult()} - unwrapped_fields1267 := fields1266 + fields1276 := []interface{}{_dollar_dollar.GetInput(), _dollar_dollar.GetResult()} + unwrapped_fields1277 := fields1276 p.write("(") p.write("cast") p.indentSexp() p.newline() - field1268 := unwrapped_fields1267[0].(*pb.Term) - p.pretty_term(field1268) + field1278 := unwrapped_fields1277[0].(*pb.Term) + p.pretty_term(field1278) p.newline() - field1269 := unwrapped_fields1267[1].(*pb.Term) - p.pretty_term(field1269) + field1279 := unwrapped_fields1277[1].(*pb.Term) + p.pretty_term(field1279) p.dedent() p.write(")") } @@ -2939,22 +2970,22 @@ func (p *PrettyPrinter) pretty_cast(msg *pb.Cast) interface{} { } func (p *PrettyPrinter) pretty_attrs(msg []*pb.Attribute) interface{} { - flat1274 := p.tryFlat(msg, func() { p.pretty_attrs(msg) }) - if flat1274 != nil { - p.write(*flat1274) + flat1284 := p.tryFlat(msg, func() { p.pretty_attrs(msg) }) + if flat1284 != nil { + p.write(*flat1284) return nil } else { - fields1271 := msg + fields1281 := msg p.write("(") p.write("attrs") p.indentSexp() - if !(len(fields1271) == 0) { + if !(len(fields1281) == 0) { p.newline() - for i1273, elem1272 := range fields1271 { - if (i1273 > 0) { + for i1283, elem1282 := range fields1281 { + if (i1283 > 0) { p.newline() } - p.pretty_attribute(elem1272) + p.pretty_attribute(elem1282) } } p.dedent() @@ -2964,28 +2995,28 @@ func (p *PrettyPrinter) pretty_attrs(msg []*pb.Attribute) interface{} { } func (p *PrettyPrinter) pretty_attribute(msg *pb.Attribute) interface{} { - flat1281 := p.tryFlat(msg, func() { p.pretty_attribute(msg) }) - if flat1281 != nil { - p.write(*flat1281) + flat1291 := p.tryFlat(msg, func() { p.pretty_attribute(msg) }) + if flat1291 != nil { + p.write(*flat1291) return nil } else { _dollar_dollar := msg - fields1275 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetArgs()} - unwrapped_fields1276 := fields1275 + fields1285 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetArgs()} + unwrapped_fields1286 := fields1285 p.write("(") p.write("attribute") p.indentSexp() p.newline() - field1277 := unwrapped_fields1276[0].(string) - p.pretty_name(field1277) - field1278 := unwrapped_fields1276[1].([]*pb.Value) - if !(len(field1278) == 0) { + field1287 := unwrapped_fields1286[0].(string) + p.pretty_name(field1287) + field1288 := unwrapped_fields1286[1].([]*pb.Value) + if !(len(field1288) == 0) { p.newline() - for i1280, elem1279 := range field1278 { - if (i1280 > 0) { + for i1290, elem1289 := range field1288 { + if (i1290 > 0) { p.newline() } - p.pretty_raw_value(elem1279) + p.pretty_raw_value(elem1289) } } p.dedent() @@ -2995,39 +3026,39 @@ func (p *PrettyPrinter) pretty_attribute(msg *pb.Attribute) interface{} { } func (p *PrettyPrinter) pretty_algorithm(msg *pb.Algorithm) interface{} { - flat1290 := p.tryFlat(msg, func() { p.pretty_algorithm(msg) }) - if flat1290 != nil { - p.write(*flat1290) + flat1300 := p.tryFlat(msg, func() { p.pretty_algorithm(msg) }) + if flat1300 != nil { + p.write(*flat1300) return nil } else { _dollar_dollar := msg - var _t1803 []*pb.Attribute + var _t1814 []*pb.Attribute if !(len(_dollar_dollar.GetAttrs()) == 0) { - _t1803 = _dollar_dollar.GetAttrs() + _t1814 = _dollar_dollar.GetAttrs() } - fields1282 := []interface{}{_dollar_dollar.GetGlobal(), _dollar_dollar.GetBody(), _t1803} - unwrapped_fields1283 := fields1282 + fields1292 := []interface{}{_dollar_dollar.GetGlobal(), _dollar_dollar.GetBody(), _t1814} + unwrapped_fields1293 := fields1292 p.write("(") p.write("algorithm") p.indentSexp() - field1284 := unwrapped_fields1283[0].([]*pb.RelationId) - if !(len(field1284) == 0) { + field1294 := unwrapped_fields1293[0].([]*pb.RelationId) + if !(len(field1294) == 0) { p.newline() - for i1286, elem1285 := range field1284 { - if (i1286 > 0) { + for i1296, elem1295 := range field1294 { + if (i1296 > 0) { p.newline() } - p.pretty_relation_id(elem1285) + p.pretty_relation_id(elem1295) } } p.newline() - field1287 := unwrapped_fields1283[1].(*pb.Script) - p.pretty_script(field1287) - field1288 := unwrapped_fields1283[2].([]*pb.Attribute) - if field1288 != nil { + field1297 := unwrapped_fields1293[1].(*pb.Script) + p.pretty_script(field1297) + field1298 := unwrapped_fields1293[2].([]*pb.Attribute) + if field1298 != nil { p.newline() - opt_val1289 := field1288 - p.pretty_attrs(opt_val1289) + opt_val1299 := field1298 + p.pretty_attrs(opt_val1299) } p.dedent() p.write(")") @@ -3036,24 +3067,24 @@ func (p *PrettyPrinter) pretty_algorithm(msg *pb.Algorithm) interface{} { } func (p *PrettyPrinter) pretty_script(msg *pb.Script) interface{} { - flat1295 := p.tryFlat(msg, func() { p.pretty_script(msg) }) - if flat1295 != nil { - p.write(*flat1295) + flat1305 := p.tryFlat(msg, func() { p.pretty_script(msg) }) + if flat1305 != nil { + p.write(*flat1305) return nil } else { _dollar_dollar := msg - fields1291 := _dollar_dollar.GetConstructs() - unwrapped_fields1292 := fields1291 + fields1301 := _dollar_dollar.GetConstructs() + unwrapped_fields1302 := fields1301 p.write("(") p.write("script") p.indentSexp() - if !(len(unwrapped_fields1292) == 0) { + if !(len(unwrapped_fields1302) == 0) { p.newline() - for i1294, elem1293 := range unwrapped_fields1292 { - if (i1294 > 0) { + for i1304, elem1303 := range unwrapped_fields1302 { + if (i1304 > 0) { p.newline() } - p.pretty_construct(elem1293) + p.pretty_construct(elem1303) } } p.dedent() @@ -3063,30 +3094,30 @@ func (p *PrettyPrinter) pretty_script(msg *pb.Script) interface{} { } func (p *PrettyPrinter) pretty_construct(msg *pb.Construct) interface{} { - flat1300 := p.tryFlat(msg, func() { p.pretty_construct(msg) }) - if flat1300 != nil { - p.write(*flat1300) + flat1310 := p.tryFlat(msg, func() { p.pretty_construct(msg) }) + if flat1310 != nil { + p.write(*flat1310) return nil } else { _dollar_dollar := msg - var _t1804 *pb.Loop + var _t1815 *pb.Loop if hasProtoField(_dollar_dollar, "loop") { - _t1804 = _dollar_dollar.GetLoop() + _t1815 = _dollar_dollar.GetLoop() } - deconstruct_result1298 := _t1804 - if deconstruct_result1298 != nil { - unwrapped1299 := deconstruct_result1298 - p.pretty_loop(unwrapped1299) + deconstruct_result1308 := _t1815 + if deconstruct_result1308 != nil { + unwrapped1309 := deconstruct_result1308 + p.pretty_loop(unwrapped1309) } else { _dollar_dollar := msg - var _t1805 *pb.Instruction + var _t1816 *pb.Instruction if hasProtoField(_dollar_dollar, "instruction") { - _t1805 = _dollar_dollar.GetInstruction() + _t1816 = _dollar_dollar.GetInstruction() } - deconstruct_result1296 := _t1805 - if deconstruct_result1296 != nil { - unwrapped1297 := deconstruct_result1296 - p.pretty_instruction(unwrapped1297) + deconstruct_result1306 := _t1816 + if deconstruct_result1306 != nil { + unwrapped1307 := deconstruct_result1306 + p.pretty_instruction(unwrapped1307) } else { panic(ParseError{msg: "No matching rule for construct"}) } @@ -3096,32 +3127,32 @@ func (p *PrettyPrinter) pretty_construct(msg *pb.Construct) interface{} { } func (p *PrettyPrinter) pretty_loop(msg *pb.Loop) interface{} { - flat1307 := p.tryFlat(msg, func() { p.pretty_loop(msg) }) - if flat1307 != nil { - p.write(*flat1307) + flat1317 := p.tryFlat(msg, func() { p.pretty_loop(msg) }) + if flat1317 != nil { + p.write(*flat1317) return nil } else { _dollar_dollar := msg - var _t1806 []*pb.Attribute + var _t1817 []*pb.Attribute if !(len(_dollar_dollar.GetAttrs()) == 0) { - _t1806 = _dollar_dollar.GetAttrs() + _t1817 = _dollar_dollar.GetAttrs() } - fields1301 := []interface{}{_dollar_dollar.GetInit(), _dollar_dollar.GetBody(), _t1806} - unwrapped_fields1302 := fields1301 + fields1311 := []interface{}{_dollar_dollar.GetInit(), _dollar_dollar.GetBody(), _t1817} + unwrapped_fields1312 := fields1311 p.write("(") p.write("loop") p.indentSexp() p.newline() - field1303 := unwrapped_fields1302[0].([]*pb.Instruction) - p.pretty_init(field1303) + field1313 := unwrapped_fields1312[0].([]*pb.Instruction) + p.pretty_init(field1313) p.newline() - field1304 := unwrapped_fields1302[1].(*pb.Script) - p.pretty_script(field1304) - field1305 := unwrapped_fields1302[2].([]*pb.Attribute) - if field1305 != nil { + field1314 := unwrapped_fields1312[1].(*pb.Script) + p.pretty_script(field1314) + field1315 := unwrapped_fields1312[2].([]*pb.Attribute) + if field1315 != nil { p.newline() - opt_val1306 := field1305 - p.pretty_attrs(opt_val1306) + opt_val1316 := field1315 + p.pretty_attrs(opt_val1316) } p.dedent() p.write(")") @@ -3130,22 +3161,22 @@ func (p *PrettyPrinter) pretty_loop(msg *pb.Loop) interface{} { } func (p *PrettyPrinter) pretty_init(msg []*pb.Instruction) interface{} { - flat1311 := p.tryFlat(msg, func() { p.pretty_init(msg) }) - if flat1311 != nil { - p.write(*flat1311) + flat1321 := p.tryFlat(msg, func() { p.pretty_init(msg) }) + if flat1321 != nil { + p.write(*flat1321) return nil } else { - fields1308 := msg + fields1318 := msg p.write("(") p.write("init") p.indentSexp() - if !(len(fields1308) == 0) { + if !(len(fields1318) == 0) { p.newline() - for i1310, elem1309 := range fields1308 { - if (i1310 > 0) { + for i1320, elem1319 := range fields1318 { + if (i1320 > 0) { p.newline() } - p.pretty_instruction(elem1309) + p.pretty_instruction(elem1319) } } p.dedent() @@ -3155,60 +3186,60 @@ func (p *PrettyPrinter) pretty_init(msg []*pb.Instruction) interface{} { } func (p *PrettyPrinter) pretty_instruction(msg *pb.Instruction) interface{} { - flat1322 := p.tryFlat(msg, func() { p.pretty_instruction(msg) }) - if flat1322 != nil { - p.write(*flat1322) + flat1332 := p.tryFlat(msg, func() { p.pretty_instruction(msg) }) + if flat1332 != nil { + p.write(*flat1332) return nil } else { _dollar_dollar := msg - var _t1807 *pb.Assign + var _t1818 *pb.Assign if hasProtoField(_dollar_dollar, "assign") { - _t1807 = _dollar_dollar.GetAssign() + _t1818 = _dollar_dollar.GetAssign() } - deconstruct_result1320 := _t1807 - if deconstruct_result1320 != nil { - unwrapped1321 := deconstruct_result1320 - p.pretty_assign(unwrapped1321) + deconstruct_result1330 := _t1818 + if deconstruct_result1330 != nil { + unwrapped1331 := deconstruct_result1330 + p.pretty_assign(unwrapped1331) } else { _dollar_dollar := msg - var _t1808 *pb.Upsert + var _t1819 *pb.Upsert if hasProtoField(_dollar_dollar, "upsert") { - _t1808 = _dollar_dollar.GetUpsert() + _t1819 = _dollar_dollar.GetUpsert() } - deconstruct_result1318 := _t1808 - if deconstruct_result1318 != nil { - unwrapped1319 := deconstruct_result1318 - p.pretty_upsert(unwrapped1319) + deconstruct_result1328 := _t1819 + if deconstruct_result1328 != nil { + unwrapped1329 := deconstruct_result1328 + p.pretty_upsert(unwrapped1329) } else { _dollar_dollar := msg - var _t1809 *pb.Break + var _t1820 *pb.Break if hasProtoField(_dollar_dollar, "break") { - _t1809 = _dollar_dollar.GetBreak() + _t1820 = _dollar_dollar.GetBreak() } - deconstruct_result1316 := _t1809 - if deconstruct_result1316 != nil { - unwrapped1317 := deconstruct_result1316 - p.pretty_break(unwrapped1317) + deconstruct_result1326 := _t1820 + if deconstruct_result1326 != nil { + unwrapped1327 := deconstruct_result1326 + p.pretty_break(unwrapped1327) } else { _dollar_dollar := msg - var _t1810 *pb.MonoidDef + var _t1821 *pb.MonoidDef if hasProtoField(_dollar_dollar, "monoid_def") { - _t1810 = _dollar_dollar.GetMonoidDef() + _t1821 = _dollar_dollar.GetMonoidDef() } - deconstruct_result1314 := _t1810 - if deconstruct_result1314 != nil { - unwrapped1315 := deconstruct_result1314 - p.pretty_monoid_def(unwrapped1315) + deconstruct_result1324 := _t1821 + if deconstruct_result1324 != nil { + unwrapped1325 := deconstruct_result1324 + p.pretty_monoid_def(unwrapped1325) } else { _dollar_dollar := msg - var _t1811 *pb.MonusDef + var _t1822 *pb.MonusDef if hasProtoField(_dollar_dollar, "monus_def") { - _t1811 = _dollar_dollar.GetMonusDef() + _t1822 = _dollar_dollar.GetMonusDef() } - deconstruct_result1312 := _t1811 - if deconstruct_result1312 != nil { - unwrapped1313 := deconstruct_result1312 - p.pretty_monus_def(unwrapped1313) + deconstruct_result1322 := _t1822 + if deconstruct_result1322 != nil { + unwrapped1323 := deconstruct_result1322 + p.pretty_monus_def(unwrapped1323) } else { panic(ParseError{msg: "No matching rule for instruction"}) } @@ -3221,32 +3252,32 @@ func (p *PrettyPrinter) pretty_instruction(msg *pb.Instruction) interface{} { } func (p *PrettyPrinter) pretty_assign(msg *pb.Assign) interface{} { - flat1329 := p.tryFlat(msg, func() { p.pretty_assign(msg) }) - if flat1329 != nil { - p.write(*flat1329) + flat1339 := p.tryFlat(msg, func() { p.pretty_assign(msg) }) + if flat1339 != nil { + p.write(*flat1339) return nil } else { _dollar_dollar := msg - var _t1812 []*pb.Attribute + var _t1823 []*pb.Attribute if !(len(_dollar_dollar.GetAttrs()) == 0) { - _t1812 = _dollar_dollar.GetAttrs() + _t1823 = _dollar_dollar.GetAttrs() } - fields1323 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetBody(), _t1812} - unwrapped_fields1324 := fields1323 + fields1333 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetBody(), _t1823} + unwrapped_fields1334 := fields1333 p.write("(") p.write("assign") p.indentSexp() p.newline() - field1325 := unwrapped_fields1324[0].(*pb.RelationId) - p.pretty_relation_id(field1325) + field1335 := unwrapped_fields1334[0].(*pb.RelationId) + p.pretty_relation_id(field1335) p.newline() - field1326 := unwrapped_fields1324[1].(*pb.Abstraction) - p.pretty_abstraction(field1326) - field1327 := unwrapped_fields1324[2].([]*pb.Attribute) - if field1327 != nil { + field1336 := unwrapped_fields1334[1].(*pb.Abstraction) + p.pretty_abstraction(field1336) + field1337 := unwrapped_fields1334[2].([]*pb.Attribute) + if field1337 != nil { p.newline() - opt_val1328 := field1327 - p.pretty_attrs(opt_val1328) + opt_val1338 := field1337 + p.pretty_attrs(opt_val1338) } p.dedent() p.write(")") @@ -3255,32 +3286,32 @@ func (p *PrettyPrinter) pretty_assign(msg *pb.Assign) interface{} { } func (p *PrettyPrinter) pretty_upsert(msg *pb.Upsert) interface{} { - flat1336 := p.tryFlat(msg, func() { p.pretty_upsert(msg) }) - if flat1336 != nil { - p.write(*flat1336) + flat1346 := p.tryFlat(msg, func() { p.pretty_upsert(msg) }) + if flat1346 != nil { + p.write(*flat1346) return nil } else { _dollar_dollar := msg - var _t1813 []*pb.Attribute + var _t1824 []*pb.Attribute if !(len(_dollar_dollar.GetAttrs()) == 0) { - _t1813 = _dollar_dollar.GetAttrs() + _t1824 = _dollar_dollar.GetAttrs() } - fields1330 := []interface{}{_dollar_dollar.GetName(), []interface{}{_dollar_dollar.GetBody(), _dollar_dollar.GetValueArity()}, _t1813} - unwrapped_fields1331 := fields1330 + fields1340 := []interface{}{_dollar_dollar.GetName(), []interface{}{_dollar_dollar.GetBody(), _dollar_dollar.GetValueArity()}, _t1824} + unwrapped_fields1341 := fields1340 p.write("(") p.write("upsert") p.indentSexp() p.newline() - field1332 := unwrapped_fields1331[0].(*pb.RelationId) - p.pretty_relation_id(field1332) + field1342 := unwrapped_fields1341[0].(*pb.RelationId) + p.pretty_relation_id(field1342) p.newline() - field1333 := unwrapped_fields1331[1].([]interface{}) - p.pretty_abstraction_with_arity(field1333) - field1334 := unwrapped_fields1331[2].([]*pb.Attribute) - if field1334 != nil { + field1343 := unwrapped_fields1341[1].([]interface{}) + p.pretty_abstraction_with_arity(field1343) + field1344 := unwrapped_fields1341[2].([]*pb.Attribute) + if field1344 != nil { p.newline() - opt_val1335 := field1334 - p.pretty_attrs(opt_val1335) + opt_val1345 := field1344 + p.pretty_attrs(opt_val1345) } p.dedent() p.write(")") @@ -3289,22 +3320,22 @@ func (p *PrettyPrinter) pretty_upsert(msg *pb.Upsert) interface{} { } func (p *PrettyPrinter) pretty_abstraction_with_arity(msg []interface{}) interface{} { - flat1341 := p.tryFlat(msg, func() { p.pretty_abstraction_with_arity(msg) }) - if flat1341 != nil { - p.write(*flat1341) + flat1351 := p.tryFlat(msg, func() { p.pretty_abstraction_with_arity(msg) }) + if flat1351 != nil { + p.write(*flat1351) return nil } else { _dollar_dollar := msg - _t1814 := p.deconstruct_bindings_with_arity(_dollar_dollar[0].(*pb.Abstraction), _dollar_dollar[1].(int64)) - fields1337 := []interface{}{_t1814, _dollar_dollar[0].(*pb.Abstraction).GetValue()} - unwrapped_fields1338 := fields1337 + _t1825 := p.deconstruct_bindings_with_arity(_dollar_dollar[0].(*pb.Abstraction), _dollar_dollar[1].(int64)) + fields1347 := []interface{}{_t1825, _dollar_dollar[0].(*pb.Abstraction).GetValue()} + unwrapped_fields1348 := fields1347 p.write("(") p.indent() - field1339 := unwrapped_fields1338[0].([]interface{}) - p.pretty_bindings(field1339) + field1349 := unwrapped_fields1348[0].([]interface{}) + p.pretty_bindings(field1349) p.newline() - field1340 := unwrapped_fields1338[1].(*pb.Formula) - p.pretty_formula(field1340) + field1350 := unwrapped_fields1348[1].(*pb.Formula) + p.pretty_formula(field1350) p.dedent() p.write(")") } @@ -3312,32 +3343,32 @@ func (p *PrettyPrinter) pretty_abstraction_with_arity(msg []interface{}) interfa } func (p *PrettyPrinter) pretty_break(msg *pb.Break) interface{} { - flat1348 := p.tryFlat(msg, func() { p.pretty_break(msg) }) - if flat1348 != nil { - p.write(*flat1348) + flat1358 := p.tryFlat(msg, func() { p.pretty_break(msg) }) + if flat1358 != nil { + p.write(*flat1358) return nil } else { _dollar_dollar := msg - var _t1815 []*pb.Attribute + var _t1826 []*pb.Attribute if !(len(_dollar_dollar.GetAttrs()) == 0) { - _t1815 = _dollar_dollar.GetAttrs() + _t1826 = _dollar_dollar.GetAttrs() } - fields1342 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetBody(), _t1815} - unwrapped_fields1343 := fields1342 + fields1352 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetBody(), _t1826} + unwrapped_fields1353 := fields1352 p.write("(") p.write("break") p.indentSexp() p.newline() - field1344 := unwrapped_fields1343[0].(*pb.RelationId) - p.pretty_relation_id(field1344) + field1354 := unwrapped_fields1353[0].(*pb.RelationId) + p.pretty_relation_id(field1354) p.newline() - field1345 := unwrapped_fields1343[1].(*pb.Abstraction) - p.pretty_abstraction(field1345) - field1346 := unwrapped_fields1343[2].([]*pb.Attribute) - if field1346 != nil { + field1355 := unwrapped_fields1353[1].(*pb.Abstraction) + p.pretty_abstraction(field1355) + field1356 := unwrapped_fields1353[2].([]*pb.Attribute) + if field1356 != nil { p.newline() - opt_val1347 := field1346 - p.pretty_attrs(opt_val1347) + opt_val1357 := field1356 + p.pretty_attrs(opt_val1357) } p.dedent() p.write(")") @@ -3346,35 +3377,35 @@ func (p *PrettyPrinter) pretty_break(msg *pb.Break) interface{} { } func (p *PrettyPrinter) pretty_monoid_def(msg *pb.MonoidDef) interface{} { - flat1356 := p.tryFlat(msg, func() { p.pretty_monoid_def(msg) }) - if flat1356 != nil { - p.write(*flat1356) + flat1366 := p.tryFlat(msg, func() { p.pretty_monoid_def(msg) }) + if flat1366 != nil { + p.write(*flat1366) return nil } else { _dollar_dollar := msg - var _t1816 []*pb.Attribute + var _t1827 []*pb.Attribute if !(len(_dollar_dollar.GetAttrs()) == 0) { - _t1816 = _dollar_dollar.GetAttrs() + _t1827 = _dollar_dollar.GetAttrs() } - fields1349 := []interface{}{_dollar_dollar.GetMonoid(), _dollar_dollar.GetName(), []interface{}{_dollar_dollar.GetBody(), _dollar_dollar.GetValueArity()}, _t1816} - unwrapped_fields1350 := fields1349 + fields1359 := []interface{}{_dollar_dollar.GetMonoid(), _dollar_dollar.GetName(), []interface{}{_dollar_dollar.GetBody(), _dollar_dollar.GetValueArity()}, _t1827} + unwrapped_fields1360 := fields1359 p.write("(") p.write("monoid") p.indentSexp() p.newline() - field1351 := unwrapped_fields1350[0].(*pb.Monoid) - p.pretty_monoid(field1351) + field1361 := unwrapped_fields1360[0].(*pb.Monoid) + p.pretty_monoid(field1361) p.newline() - field1352 := unwrapped_fields1350[1].(*pb.RelationId) - p.pretty_relation_id(field1352) + field1362 := unwrapped_fields1360[1].(*pb.RelationId) + p.pretty_relation_id(field1362) p.newline() - field1353 := unwrapped_fields1350[2].([]interface{}) - p.pretty_abstraction_with_arity(field1353) - field1354 := unwrapped_fields1350[3].([]*pb.Attribute) - if field1354 != nil { + field1363 := unwrapped_fields1360[2].([]interface{}) + p.pretty_abstraction_with_arity(field1363) + field1364 := unwrapped_fields1360[3].([]*pb.Attribute) + if field1364 != nil { p.newline() - opt_val1355 := field1354 - p.pretty_attrs(opt_val1355) + opt_val1365 := field1364 + p.pretty_attrs(opt_val1365) } p.dedent() p.write(")") @@ -3383,50 +3414,50 @@ func (p *PrettyPrinter) pretty_monoid_def(msg *pb.MonoidDef) interface{} { } func (p *PrettyPrinter) pretty_monoid(msg *pb.Monoid) interface{} { - flat1365 := p.tryFlat(msg, func() { p.pretty_monoid(msg) }) - if flat1365 != nil { - p.write(*flat1365) + flat1375 := p.tryFlat(msg, func() { p.pretty_monoid(msg) }) + if flat1375 != nil { + p.write(*flat1375) return nil } else { _dollar_dollar := msg - var _t1817 *pb.OrMonoid + var _t1828 *pb.OrMonoid if hasProtoField(_dollar_dollar, "or_monoid") { - _t1817 = _dollar_dollar.GetOrMonoid() + _t1828 = _dollar_dollar.GetOrMonoid() } - deconstruct_result1363 := _t1817 - if deconstruct_result1363 != nil { - unwrapped1364 := deconstruct_result1363 - p.pretty_or_monoid(unwrapped1364) + deconstruct_result1373 := _t1828 + if deconstruct_result1373 != nil { + unwrapped1374 := deconstruct_result1373 + p.pretty_or_monoid(unwrapped1374) } else { _dollar_dollar := msg - var _t1818 *pb.MinMonoid + var _t1829 *pb.MinMonoid if hasProtoField(_dollar_dollar, "min_monoid") { - _t1818 = _dollar_dollar.GetMinMonoid() + _t1829 = _dollar_dollar.GetMinMonoid() } - deconstruct_result1361 := _t1818 - if deconstruct_result1361 != nil { - unwrapped1362 := deconstruct_result1361 - p.pretty_min_monoid(unwrapped1362) + deconstruct_result1371 := _t1829 + if deconstruct_result1371 != nil { + unwrapped1372 := deconstruct_result1371 + p.pretty_min_monoid(unwrapped1372) } else { _dollar_dollar := msg - var _t1819 *pb.MaxMonoid + var _t1830 *pb.MaxMonoid if hasProtoField(_dollar_dollar, "max_monoid") { - _t1819 = _dollar_dollar.GetMaxMonoid() + _t1830 = _dollar_dollar.GetMaxMonoid() } - deconstruct_result1359 := _t1819 - if deconstruct_result1359 != nil { - unwrapped1360 := deconstruct_result1359 - p.pretty_max_monoid(unwrapped1360) + deconstruct_result1369 := _t1830 + if deconstruct_result1369 != nil { + unwrapped1370 := deconstruct_result1369 + p.pretty_max_monoid(unwrapped1370) } else { _dollar_dollar := msg - var _t1820 *pb.SumMonoid + var _t1831 *pb.SumMonoid if hasProtoField(_dollar_dollar, "sum_monoid") { - _t1820 = _dollar_dollar.GetSumMonoid() + _t1831 = _dollar_dollar.GetSumMonoid() } - deconstruct_result1357 := _t1820 - if deconstruct_result1357 != nil { - unwrapped1358 := deconstruct_result1357 - p.pretty_sum_monoid(unwrapped1358) + deconstruct_result1367 := _t1831 + if deconstruct_result1367 != nil { + unwrapped1368 := deconstruct_result1367 + p.pretty_sum_monoid(unwrapped1368) } else { panic(ParseError{msg: "No matching rule for monoid"}) } @@ -3438,8 +3469,8 @@ func (p *PrettyPrinter) pretty_monoid(msg *pb.Monoid) interface{} { } func (p *PrettyPrinter) pretty_or_monoid(msg *pb.OrMonoid) interface{} { - fields1366 := msg - _ = fields1366 + fields1376 := msg + _ = fields1376 p.write("(") p.write("or") p.write(")") @@ -3447,19 +3478,19 @@ func (p *PrettyPrinter) pretty_or_monoid(msg *pb.OrMonoid) interface{} { } func (p *PrettyPrinter) pretty_min_monoid(msg *pb.MinMonoid) interface{} { - flat1369 := p.tryFlat(msg, func() { p.pretty_min_monoid(msg) }) - if flat1369 != nil { - p.write(*flat1369) + flat1379 := p.tryFlat(msg, func() { p.pretty_min_monoid(msg) }) + if flat1379 != nil { + p.write(*flat1379) return nil } else { _dollar_dollar := msg - fields1367 := _dollar_dollar.GetType() - unwrapped_fields1368 := fields1367 + fields1377 := _dollar_dollar.GetType() + unwrapped_fields1378 := fields1377 p.write("(") p.write("min") p.indentSexp() p.newline() - p.pretty_type(unwrapped_fields1368) + p.pretty_type(unwrapped_fields1378) p.dedent() p.write(")") } @@ -3467,19 +3498,19 @@ func (p *PrettyPrinter) pretty_min_monoid(msg *pb.MinMonoid) interface{} { } func (p *PrettyPrinter) pretty_max_monoid(msg *pb.MaxMonoid) interface{} { - flat1372 := p.tryFlat(msg, func() { p.pretty_max_monoid(msg) }) - if flat1372 != nil { - p.write(*flat1372) + flat1382 := p.tryFlat(msg, func() { p.pretty_max_monoid(msg) }) + if flat1382 != nil { + p.write(*flat1382) return nil } else { _dollar_dollar := msg - fields1370 := _dollar_dollar.GetType() - unwrapped_fields1371 := fields1370 + fields1380 := _dollar_dollar.GetType() + unwrapped_fields1381 := fields1380 p.write("(") p.write("max") p.indentSexp() p.newline() - p.pretty_type(unwrapped_fields1371) + p.pretty_type(unwrapped_fields1381) p.dedent() p.write(")") } @@ -3487,19 +3518,19 @@ func (p *PrettyPrinter) pretty_max_monoid(msg *pb.MaxMonoid) interface{} { } func (p *PrettyPrinter) pretty_sum_monoid(msg *pb.SumMonoid) interface{} { - flat1375 := p.tryFlat(msg, func() { p.pretty_sum_monoid(msg) }) - if flat1375 != nil { - p.write(*flat1375) + flat1385 := p.tryFlat(msg, func() { p.pretty_sum_monoid(msg) }) + if flat1385 != nil { + p.write(*flat1385) return nil } else { _dollar_dollar := msg - fields1373 := _dollar_dollar.GetType() - unwrapped_fields1374 := fields1373 + fields1383 := _dollar_dollar.GetType() + unwrapped_fields1384 := fields1383 p.write("(") p.write("sum") p.indentSexp() p.newline() - p.pretty_type(unwrapped_fields1374) + p.pretty_type(unwrapped_fields1384) p.dedent() p.write(")") } @@ -3507,35 +3538,35 @@ func (p *PrettyPrinter) pretty_sum_monoid(msg *pb.SumMonoid) interface{} { } func (p *PrettyPrinter) pretty_monus_def(msg *pb.MonusDef) interface{} { - flat1383 := p.tryFlat(msg, func() { p.pretty_monus_def(msg) }) - if flat1383 != nil { - p.write(*flat1383) + flat1393 := p.tryFlat(msg, func() { p.pretty_monus_def(msg) }) + if flat1393 != nil { + p.write(*flat1393) return nil } else { _dollar_dollar := msg - var _t1821 []*pb.Attribute + var _t1832 []*pb.Attribute if !(len(_dollar_dollar.GetAttrs()) == 0) { - _t1821 = _dollar_dollar.GetAttrs() + _t1832 = _dollar_dollar.GetAttrs() } - fields1376 := []interface{}{_dollar_dollar.GetMonoid(), _dollar_dollar.GetName(), []interface{}{_dollar_dollar.GetBody(), _dollar_dollar.GetValueArity()}, _t1821} - unwrapped_fields1377 := fields1376 + fields1386 := []interface{}{_dollar_dollar.GetMonoid(), _dollar_dollar.GetName(), []interface{}{_dollar_dollar.GetBody(), _dollar_dollar.GetValueArity()}, _t1832} + unwrapped_fields1387 := fields1386 p.write("(") p.write("monus") p.indentSexp() p.newline() - field1378 := unwrapped_fields1377[0].(*pb.Monoid) - p.pretty_monoid(field1378) + field1388 := unwrapped_fields1387[0].(*pb.Monoid) + p.pretty_monoid(field1388) p.newline() - field1379 := unwrapped_fields1377[1].(*pb.RelationId) - p.pretty_relation_id(field1379) + field1389 := unwrapped_fields1387[1].(*pb.RelationId) + p.pretty_relation_id(field1389) p.newline() - field1380 := unwrapped_fields1377[2].([]interface{}) - p.pretty_abstraction_with_arity(field1380) - field1381 := unwrapped_fields1377[3].([]*pb.Attribute) - if field1381 != nil { + field1390 := unwrapped_fields1387[2].([]interface{}) + p.pretty_abstraction_with_arity(field1390) + field1391 := unwrapped_fields1387[3].([]*pb.Attribute) + if field1391 != nil { p.newline() - opt_val1382 := field1381 - p.pretty_attrs(opt_val1382) + opt_val1392 := field1391 + p.pretty_attrs(opt_val1392) } p.dedent() p.write(")") @@ -3544,29 +3575,29 @@ func (p *PrettyPrinter) pretty_monus_def(msg *pb.MonusDef) interface{} { } func (p *PrettyPrinter) pretty_constraint(msg *pb.Constraint) interface{} { - flat1390 := p.tryFlat(msg, func() { p.pretty_constraint(msg) }) - if flat1390 != nil { - p.write(*flat1390) + flat1400 := p.tryFlat(msg, func() { p.pretty_constraint(msg) }) + if flat1400 != nil { + p.write(*flat1400) return nil } else { _dollar_dollar := msg - fields1384 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetFunctionalDependency().GetGuard(), _dollar_dollar.GetFunctionalDependency().GetKeys(), _dollar_dollar.GetFunctionalDependency().GetValues()} - unwrapped_fields1385 := fields1384 + fields1394 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetFunctionalDependency().GetGuard(), _dollar_dollar.GetFunctionalDependency().GetKeys(), _dollar_dollar.GetFunctionalDependency().GetValues()} + unwrapped_fields1395 := fields1394 p.write("(") p.write("functional_dependency") p.indentSexp() p.newline() - field1386 := unwrapped_fields1385[0].(*pb.RelationId) - p.pretty_relation_id(field1386) + field1396 := unwrapped_fields1395[0].(*pb.RelationId) + p.pretty_relation_id(field1396) p.newline() - field1387 := unwrapped_fields1385[1].(*pb.Abstraction) - p.pretty_abstraction(field1387) + field1397 := unwrapped_fields1395[1].(*pb.Abstraction) + p.pretty_abstraction(field1397) p.newline() - field1388 := unwrapped_fields1385[2].([]*pb.Var) - p.pretty_functional_dependency_keys(field1388) + field1398 := unwrapped_fields1395[2].([]*pb.Var) + p.pretty_functional_dependency_keys(field1398) p.newline() - field1389 := unwrapped_fields1385[3].([]*pb.Var) - p.pretty_functional_dependency_values(field1389) + field1399 := unwrapped_fields1395[3].([]*pb.Var) + p.pretty_functional_dependency_values(field1399) p.dedent() p.write(")") } @@ -3574,22 +3605,22 @@ func (p *PrettyPrinter) pretty_constraint(msg *pb.Constraint) interface{} { } func (p *PrettyPrinter) pretty_functional_dependency_keys(msg []*pb.Var) interface{} { - flat1394 := p.tryFlat(msg, func() { p.pretty_functional_dependency_keys(msg) }) - if flat1394 != nil { - p.write(*flat1394) + flat1404 := p.tryFlat(msg, func() { p.pretty_functional_dependency_keys(msg) }) + if flat1404 != nil { + p.write(*flat1404) return nil } else { - fields1391 := msg + fields1401 := msg p.write("(") p.write("keys") p.indentSexp() - if !(len(fields1391) == 0) { + if !(len(fields1401) == 0) { p.newline() - for i1393, elem1392 := range fields1391 { - if (i1393 > 0) { + for i1403, elem1402 := range fields1401 { + if (i1403 > 0) { p.newline() } - p.pretty_var(elem1392) + p.pretty_var(elem1402) } } p.dedent() @@ -3599,22 +3630,22 @@ func (p *PrettyPrinter) pretty_functional_dependency_keys(msg []*pb.Var) interfa } func (p *PrettyPrinter) pretty_functional_dependency_values(msg []*pb.Var) interface{} { - flat1398 := p.tryFlat(msg, func() { p.pretty_functional_dependency_values(msg) }) - if flat1398 != nil { - p.write(*flat1398) + flat1408 := p.tryFlat(msg, func() { p.pretty_functional_dependency_values(msg) }) + if flat1408 != nil { + p.write(*flat1408) return nil } else { - fields1395 := msg + fields1405 := msg p.write("(") p.write("values") p.indentSexp() - if !(len(fields1395) == 0) { + if !(len(fields1405) == 0) { p.newline() - for i1397, elem1396 := range fields1395 { - if (i1397 > 0) { + for i1407, elem1406 := range fields1405 { + if (i1407 > 0) { p.newline() } - p.pretty_var(elem1396) + p.pretty_var(elem1406) } } p.dedent() @@ -3624,50 +3655,50 @@ func (p *PrettyPrinter) pretty_functional_dependency_values(msg []*pb.Var) inter } func (p *PrettyPrinter) pretty_data(msg *pb.Data) interface{} { - flat1407 := p.tryFlat(msg, func() { p.pretty_data(msg) }) - if flat1407 != nil { - p.write(*flat1407) + flat1417 := p.tryFlat(msg, func() { p.pretty_data(msg) }) + if flat1417 != nil { + p.write(*flat1417) return nil } else { _dollar_dollar := msg - var _t1822 *pb.EDB + var _t1833 *pb.EDB if hasProtoField(_dollar_dollar, "edb") { - _t1822 = _dollar_dollar.GetEdb() + _t1833 = _dollar_dollar.GetEdb() } - deconstruct_result1405 := _t1822 - if deconstruct_result1405 != nil { - unwrapped1406 := deconstruct_result1405 - p.pretty_edb(unwrapped1406) + deconstruct_result1415 := _t1833 + if deconstruct_result1415 != nil { + unwrapped1416 := deconstruct_result1415 + p.pretty_edb(unwrapped1416) } else { _dollar_dollar := msg - var _t1823 *pb.BeTreeRelation + var _t1834 *pb.BeTreeRelation if hasProtoField(_dollar_dollar, "betree_relation") { - _t1823 = _dollar_dollar.GetBetreeRelation() + _t1834 = _dollar_dollar.GetBetreeRelation() } - deconstruct_result1403 := _t1823 - if deconstruct_result1403 != nil { - unwrapped1404 := deconstruct_result1403 - p.pretty_betree_relation(unwrapped1404) + deconstruct_result1413 := _t1834 + if deconstruct_result1413 != nil { + unwrapped1414 := deconstruct_result1413 + p.pretty_betree_relation(unwrapped1414) } else { _dollar_dollar := msg - var _t1824 *pb.CSVData + var _t1835 *pb.CSVData if hasProtoField(_dollar_dollar, "csv_data") { - _t1824 = _dollar_dollar.GetCsvData() + _t1835 = _dollar_dollar.GetCsvData() } - deconstruct_result1401 := _t1824 - if deconstruct_result1401 != nil { - unwrapped1402 := deconstruct_result1401 - p.pretty_csv_data(unwrapped1402) + deconstruct_result1411 := _t1835 + if deconstruct_result1411 != nil { + unwrapped1412 := deconstruct_result1411 + p.pretty_csv_data(unwrapped1412) } else { _dollar_dollar := msg - var _t1825 *pb.IcebergData + var _t1836 *pb.IcebergData if hasProtoField(_dollar_dollar, "iceberg_data") { - _t1825 = _dollar_dollar.GetIcebergData() + _t1836 = _dollar_dollar.GetIcebergData() } - deconstruct_result1399 := _t1825 - if deconstruct_result1399 != nil { - unwrapped1400 := deconstruct_result1399 - p.pretty_iceberg_data(unwrapped1400) + deconstruct_result1409 := _t1836 + if deconstruct_result1409 != nil { + unwrapped1410 := deconstruct_result1409 + p.pretty_iceberg_data(unwrapped1410) } else { panic(ParseError{msg: "No matching rule for data"}) } @@ -3679,26 +3710,26 @@ func (p *PrettyPrinter) pretty_data(msg *pb.Data) interface{} { } func (p *PrettyPrinter) pretty_edb(msg *pb.EDB) interface{} { - flat1413 := p.tryFlat(msg, func() { p.pretty_edb(msg) }) - if flat1413 != nil { - p.write(*flat1413) + flat1423 := p.tryFlat(msg, func() { p.pretty_edb(msg) }) + if flat1423 != nil { + p.write(*flat1423) return nil } else { _dollar_dollar := msg - fields1408 := []interface{}{_dollar_dollar.GetTargetId(), _dollar_dollar.GetPath(), _dollar_dollar.GetTypes()} - unwrapped_fields1409 := fields1408 + fields1418 := []interface{}{_dollar_dollar.GetTargetId(), _dollar_dollar.GetPath(), _dollar_dollar.GetTypes()} + unwrapped_fields1419 := fields1418 p.write("(") p.write("edb") p.indentSexp() p.newline() - field1410 := unwrapped_fields1409[0].(*pb.RelationId) - p.pretty_relation_id(field1410) + field1420 := unwrapped_fields1419[0].(*pb.RelationId) + p.pretty_relation_id(field1420) p.newline() - field1411 := unwrapped_fields1409[1].([]string) - p.pretty_edb_path(field1411) + field1421 := unwrapped_fields1419[1].([]string) + p.pretty_edb_path(field1421) p.newline() - field1412 := unwrapped_fields1409[2].([]*pb.Type) - p.pretty_edb_types(field1412) + field1422 := unwrapped_fields1419[2].([]*pb.Type) + p.pretty_edb_types(field1422) p.dedent() p.write(")") } @@ -3706,19 +3737,19 @@ func (p *PrettyPrinter) pretty_edb(msg *pb.EDB) interface{} { } func (p *PrettyPrinter) pretty_edb_path(msg []string) interface{} { - flat1417 := p.tryFlat(msg, func() { p.pretty_edb_path(msg) }) - if flat1417 != nil { - p.write(*flat1417) + flat1427 := p.tryFlat(msg, func() { p.pretty_edb_path(msg) }) + if flat1427 != nil { + p.write(*flat1427) return nil } else { - fields1414 := msg + fields1424 := msg p.write("[") p.indent() - for i1416, elem1415 := range fields1414 { - if (i1416 > 0) { + for i1426, elem1425 := range fields1424 { + if (i1426 > 0) { p.newline() } - p.write(p.formatStringValue(elem1415)) + p.write(p.formatStringValue(elem1425)) } p.dedent() p.write("]") @@ -3727,19 +3758,19 @@ func (p *PrettyPrinter) pretty_edb_path(msg []string) interface{} { } func (p *PrettyPrinter) pretty_edb_types(msg []*pb.Type) interface{} { - flat1421 := p.tryFlat(msg, func() { p.pretty_edb_types(msg) }) - if flat1421 != nil { - p.write(*flat1421) + flat1431 := p.tryFlat(msg, func() { p.pretty_edb_types(msg) }) + if flat1431 != nil { + p.write(*flat1431) return nil } else { - fields1418 := msg + fields1428 := msg p.write("[") p.indent() - for i1420, elem1419 := range fields1418 { - if (i1420 > 0) { + for i1430, elem1429 := range fields1428 { + if (i1430 > 0) { p.newline() } - p.pretty_type(elem1419) + p.pretty_type(elem1429) } p.dedent() p.write("]") @@ -3748,23 +3779,23 @@ func (p *PrettyPrinter) pretty_edb_types(msg []*pb.Type) interface{} { } func (p *PrettyPrinter) pretty_betree_relation(msg *pb.BeTreeRelation) interface{} { - flat1426 := p.tryFlat(msg, func() { p.pretty_betree_relation(msg) }) - if flat1426 != nil { - p.write(*flat1426) + flat1436 := p.tryFlat(msg, func() { p.pretty_betree_relation(msg) }) + if flat1436 != nil { + p.write(*flat1436) return nil } else { _dollar_dollar := msg - fields1422 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetRelationInfo()} - unwrapped_fields1423 := fields1422 + fields1432 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetRelationInfo()} + unwrapped_fields1433 := fields1432 p.write("(") p.write("betree_relation") p.indentSexp() p.newline() - field1424 := unwrapped_fields1423[0].(*pb.RelationId) - p.pretty_relation_id(field1424) + field1434 := unwrapped_fields1433[0].(*pb.RelationId) + p.pretty_relation_id(field1434) p.newline() - field1425 := unwrapped_fields1423[1].(*pb.BeTreeInfo) - p.pretty_betree_info(field1425) + field1435 := unwrapped_fields1433[1].(*pb.BeTreeInfo) + p.pretty_betree_info(field1435) p.dedent() p.write(")") } @@ -3772,27 +3803,27 @@ func (p *PrettyPrinter) pretty_betree_relation(msg *pb.BeTreeRelation) interface } func (p *PrettyPrinter) pretty_betree_info(msg *pb.BeTreeInfo) interface{} { - flat1432 := p.tryFlat(msg, func() { p.pretty_betree_info(msg) }) - if flat1432 != nil { - p.write(*flat1432) + flat1442 := p.tryFlat(msg, func() { p.pretty_betree_info(msg) }) + if flat1442 != nil { + p.write(*flat1442) return nil } else { _dollar_dollar := msg - _t1826 := p.deconstruct_betree_info_config(_dollar_dollar) - fields1427 := []interface{}{_dollar_dollar.GetKeyTypes(), _dollar_dollar.GetValueTypes(), _t1826} - unwrapped_fields1428 := fields1427 + _t1837 := p.deconstruct_betree_info_config(_dollar_dollar) + fields1437 := []interface{}{_dollar_dollar.GetKeyTypes(), _dollar_dollar.GetValueTypes(), _t1837} + unwrapped_fields1438 := fields1437 p.write("(") p.write("betree_info") p.indentSexp() p.newline() - field1429 := unwrapped_fields1428[0].([]*pb.Type) - p.pretty_betree_info_key_types(field1429) + field1439 := unwrapped_fields1438[0].([]*pb.Type) + p.pretty_betree_info_key_types(field1439) p.newline() - field1430 := unwrapped_fields1428[1].([]*pb.Type) - p.pretty_betree_info_value_types(field1430) + field1440 := unwrapped_fields1438[1].([]*pb.Type) + p.pretty_betree_info_value_types(field1440) p.newline() - field1431 := unwrapped_fields1428[2].([][]interface{}) - p.pretty_config_dict(field1431) + field1441 := unwrapped_fields1438[2].([][]interface{}) + p.pretty_config_dict(field1441) p.dedent() p.write(")") } @@ -3800,22 +3831,22 @@ func (p *PrettyPrinter) pretty_betree_info(msg *pb.BeTreeInfo) interface{} { } func (p *PrettyPrinter) pretty_betree_info_key_types(msg []*pb.Type) interface{} { - flat1436 := p.tryFlat(msg, func() { p.pretty_betree_info_key_types(msg) }) - if flat1436 != nil { - p.write(*flat1436) + flat1446 := p.tryFlat(msg, func() { p.pretty_betree_info_key_types(msg) }) + if flat1446 != nil { + p.write(*flat1446) return nil } else { - fields1433 := msg + fields1443 := msg p.write("(") p.write("key_types") p.indentSexp() - if !(len(fields1433) == 0) { + if !(len(fields1443) == 0) { p.newline() - for i1435, elem1434 := range fields1433 { - if (i1435 > 0) { + for i1445, elem1444 := range fields1443 { + if (i1445 > 0) { p.newline() } - p.pretty_type(elem1434) + p.pretty_type(elem1444) } } p.dedent() @@ -3825,22 +3856,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{} { - flat1440 := p.tryFlat(msg, func() { p.pretty_betree_info_value_types(msg) }) - if flat1440 != nil { - p.write(*flat1440) + flat1450 := p.tryFlat(msg, func() { p.pretty_betree_info_value_types(msg) }) + if flat1450 != nil { + p.write(*flat1450) return nil } else { - fields1437 := msg + fields1447 := msg p.write("(") p.write("value_types") p.indentSexp() - if !(len(fields1437) == 0) { + if !(len(fields1447) == 0) { p.newline() - for i1439, elem1438 := range fields1437 { - if (i1439 > 0) { + for i1449, elem1448 := range fields1447 { + if (i1449 > 0) { p.newline() } - p.pretty_type(elem1438) + p.pretty_type(elem1448) } } p.dedent() @@ -3850,40 +3881,40 @@ func (p *PrettyPrinter) pretty_betree_info_value_types(msg []*pb.Type) interface } func (p *PrettyPrinter) pretty_csv_data(msg *pb.CSVData) interface{} { - flat1450 := p.tryFlat(msg, func() { p.pretty_csv_data(msg) }) - if flat1450 != nil { - p.write(*flat1450) + flat1460 := p.tryFlat(msg, func() { p.pretty_csv_data(msg) }) + if flat1460 != nil { + p.write(*flat1460) return nil } else { _dollar_dollar := msg - _t1827 := p.deconstruct_csv_data_columns_optional(_dollar_dollar) - _t1828 := p.deconstruct_csv_data_relations_optional(_dollar_dollar) - fields1441 := []interface{}{_dollar_dollar.GetLocator(), _dollar_dollar.GetConfig(), _t1827, _t1828, _dollar_dollar.GetAsof()} - unwrapped_fields1442 := fields1441 + _t1838 := p.deconstruct_csv_data_columns_optional(_dollar_dollar) + _t1839 := p.deconstruct_csv_data_relations_optional(_dollar_dollar) + fields1451 := []interface{}{_dollar_dollar.GetLocator(), _dollar_dollar.GetConfig(), _t1838, _t1839, _dollar_dollar.GetAsof()} + unwrapped_fields1452 := fields1451 p.write("(") p.write("csv_data") p.indentSexp() p.newline() - field1443 := unwrapped_fields1442[0].(*pb.CSVLocator) - p.pretty_csvlocator(field1443) + field1453 := unwrapped_fields1452[0].(*pb.CSVLocator) + p.pretty_csvlocator(field1453) p.newline() - field1444 := unwrapped_fields1442[1].(*pb.CSVConfig) - p.pretty_csv_config(field1444) - field1445 := unwrapped_fields1442[2].([]*pb.GNFColumn) - if field1445 != nil { + field1454 := unwrapped_fields1452[1].(*pb.CSVConfig) + p.pretty_csv_config(field1454) + field1455 := unwrapped_fields1452[2].([]*pb.GNFColumn) + if field1455 != nil { p.newline() - opt_val1446 := field1445 - p.pretty_gnf_columns(opt_val1446) + opt_val1456 := field1455 + p.pretty_gnf_columns(opt_val1456) } - field1447 := unwrapped_fields1442[3].(*pb.TargetRelations) - if field1447 != nil { + field1457 := unwrapped_fields1452[3].(*pb.TargetRelations) + if field1457 != nil { p.newline() - opt_val1448 := field1447 - p.pretty_target_relations(opt_val1448) + opt_val1458 := field1457 + p.pretty_target_relations(opt_val1458) } p.newline() - field1449 := unwrapped_fields1442[4].(string) - p.pretty_csv_asof(field1449) + field1459 := unwrapped_fields1452[4].(string) + p.pretty_csv_asof(field1459) p.dedent() p.write(")") } @@ -3891,36 +3922,36 @@ func (p *PrettyPrinter) pretty_csv_data(msg *pb.CSVData) interface{} { } func (p *PrettyPrinter) pretty_csvlocator(msg *pb.CSVLocator) interface{} { - flat1457 := p.tryFlat(msg, func() { p.pretty_csvlocator(msg) }) - if flat1457 != nil { - p.write(*flat1457) + flat1467 := p.tryFlat(msg, func() { p.pretty_csvlocator(msg) }) + if flat1467 != nil { + p.write(*flat1467) return nil } else { _dollar_dollar := msg - var _t1829 []string + var _t1840 []string if !(len(_dollar_dollar.GetPaths()) == 0) { - _t1829 = _dollar_dollar.GetPaths() + _t1840 = _dollar_dollar.GetPaths() } - var _t1830 *string + var _t1841 *string if string(_dollar_dollar.GetInlineData()) != "" { - _t1830 = ptr(string(_dollar_dollar.GetInlineData())) + _t1841 = ptr(string(_dollar_dollar.GetInlineData())) } - fields1451 := []interface{}{_t1829, _t1830} - unwrapped_fields1452 := fields1451 + fields1461 := []interface{}{_t1840, _t1841} + unwrapped_fields1462 := fields1461 p.write("(") p.write("csv_locator") p.indentSexp() - field1453 := unwrapped_fields1452[0].([]string) - if field1453 != nil { + field1463 := unwrapped_fields1462[0].([]string) + if field1463 != nil { p.newline() - opt_val1454 := field1453 - p.pretty_csv_locator_paths(opt_val1454) + opt_val1464 := field1463 + p.pretty_csv_locator_paths(opt_val1464) } - field1455 := unwrapped_fields1452[1].(*string) - if field1455 != nil { + field1465 := unwrapped_fields1462[1].(*string) + if field1465 != nil { p.newline() - opt_val1456 := *field1455 - p.pretty_csv_locator_inline_data(opt_val1456) + opt_val1466 := *field1465 + p.pretty_csv_locator_inline_data(opt_val1466) } p.dedent() p.write(")") @@ -3929,22 +3960,22 @@ func (p *PrettyPrinter) pretty_csvlocator(msg *pb.CSVLocator) interface{} { } func (p *PrettyPrinter) pretty_csv_locator_paths(msg []string) interface{} { - flat1461 := p.tryFlat(msg, func() { p.pretty_csv_locator_paths(msg) }) - if flat1461 != nil { - p.write(*flat1461) + flat1471 := p.tryFlat(msg, func() { p.pretty_csv_locator_paths(msg) }) + if flat1471 != nil { + p.write(*flat1471) return nil } else { - fields1458 := msg + fields1468 := msg p.write("(") p.write("paths") p.indentSexp() - if !(len(fields1458) == 0) { + if !(len(fields1468) == 0) { p.newline() - for i1460, elem1459 := range fields1458 { - if (i1460 > 0) { + for i1470, elem1469 := range fields1468 { + if (i1470 > 0) { p.newline() } - p.write(p.formatStringValue(elem1459)) + p.write(p.formatStringValue(elem1469)) } } p.dedent() @@ -3954,17 +3985,17 @@ func (p *PrettyPrinter) pretty_csv_locator_paths(msg []string) interface{} { } func (p *PrettyPrinter) pretty_csv_locator_inline_data(msg string) interface{} { - flat1463 := p.tryFlat(msg, func() { p.pretty_csv_locator_inline_data(msg) }) - if flat1463 != nil { - p.write(*flat1463) + flat1473 := p.tryFlat(msg, func() { p.pretty_csv_locator_inline_data(msg) }) + if flat1473 != nil { + p.write(*flat1473) return nil } else { - fields1462 := msg + fields1472 := msg p.write("(") p.write("inline_data") p.indentSexp() p.newline() - p.write(p.formatStringValue(fields1462)) + p.write(p.formatStringValue(fields1472)) p.dedent() p.write(")") } @@ -3972,27 +4003,27 @@ func (p *PrettyPrinter) pretty_csv_locator_inline_data(msg string) interface{} { } func (p *PrettyPrinter) pretty_csv_config(msg *pb.CSVConfig) interface{} { - flat1469 := p.tryFlat(msg, func() { p.pretty_csv_config(msg) }) - if flat1469 != nil { - p.write(*flat1469) + flat1479 := p.tryFlat(msg, func() { p.pretty_csv_config(msg) }) + if flat1479 != nil { + p.write(*flat1479) return nil } else { _dollar_dollar := msg - _t1831 := p.deconstruct_csv_config(_dollar_dollar) - _t1832 := p.deconstruct_csv_storage_integration_optional(_dollar_dollar) - fields1464 := []interface{}{_t1831, _t1832} - unwrapped_fields1465 := fields1464 + _t1842 := p.deconstruct_csv_config(_dollar_dollar) + _t1843 := p.deconstruct_csv_storage_integration_optional(_dollar_dollar) + fields1474 := []interface{}{_t1842, _t1843} + unwrapped_fields1475 := fields1474 p.write("(") p.write("csv_config") p.indentSexp() p.newline() - field1466 := unwrapped_fields1465[0].([][]interface{}) - p.pretty_config_dict(field1466) - field1467 := unwrapped_fields1465[1].([][]interface{}) - if field1467 != nil { + field1476 := unwrapped_fields1475[0].([][]interface{}) + p.pretty_config_dict(field1476) + field1477 := unwrapped_fields1475[1].([][]interface{}) + if field1477 != nil { p.newline() - opt_val1468 := field1467 - p.pretty__storage_integration(opt_val1468) + opt_val1478 := field1477 + p.pretty__storage_integration(opt_val1478) } p.dedent() p.write(")") @@ -4001,17 +4032,17 @@ func (p *PrettyPrinter) pretty_csv_config(msg *pb.CSVConfig) interface{} { } func (p *PrettyPrinter) pretty__storage_integration(msg [][]interface{}) interface{} { - flat1471 := p.tryFlat(msg, func() { p.pretty__storage_integration(msg) }) - if flat1471 != nil { - p.write(*flat1471) + flat1481 := p.tryFlat(msg, func() { p.pretty__storage_integration(msg) }) + if flat1481 != nil { + p.write(*flat1481) return nil } else { - fields1470 := msg + fields1480 := msg p.write("(") p.write("storage_integration") p.indentSexp() p.newline() - p.pretty_config_dict(fields1470) + p.pretty_config_dict(fields1480) p.dedent() p.write(")") } @@ -4019,22 +4050,22 @@ func (p *PrettyPrinter) pretty__storage_integration(msg [][]interface{}) interfa } func (p *PrettyPrinter) pretty_gnf_columns(msg []*pb.GNFColumn) interface{} { - flat1475 := p.tryFlat(msg, func() { p.pretty_gnf_columns(msg) }) - if flat1475 != nil { - p.write(*flat1475) + flat1485 := p.tryFlat(msg, func() { p.pretty_gnf_columns(msg) }) + if flat1485 != nil { + p.write(*flat1485) return nil } else { - fields1472 := msg + fields1482 := msg p.write("(") p.write("columns") p.indentSexp() - if !(len(fields1472) == 0) { + if !(len(fields1482) == 0) { p.newline() - for i1474, elem1473 := range fields1472 { - if (i1474 > 0) { + for i1484, elem1483 := range fields1482 { + if (i1484 > 0) { p.newline() } - p.pretty_gnf_column(elem1473) + p.pretty_gnf_column(elem1483) } } p.dedent() @@ -4044,38 +4075,38 @@ func (p *PrettyPrinter) pretty_gnf_columns(msg []*pb.GNFColumn) interface{} { } func (p *PrettyPrinter) pretty_gnf_column(msg *pb.GNFColumn) interface{} { - flat1484 := p.tryFlat(msg, func() { p.pretty_gnf_column(msg) }) - if flat1484 != nil { - p.write(*flat1484) + flat1494 := p.tryFlat(msg, func() { p.pretty_gnf_column(msg) }) + if flat1494 != nil { + p.write(*flat1494) return nil } else { _dollar_dollar := msg - var _t1833 *pb.RelationId + var _t1844 *pb.RelationId if hasProtoField(_dollar_dollar, "target_id") { - _t1833 = _dollar_dollar.GetTargetId() + _t1844 = _dollar_dollar.GetTargetId() } - fields1476 := []interface{}{_dollar_dollar.GetColumnPath(), _t1833, _dollar_dollar.GetTypes()} - unwrapped_fields1477 := fields1476 + fields1486 := []interface{}{_dollar_dollar.GetColumnPath(), _t1844, _dollar_dollar.GetTypes()} + unwrapped_fields1487 := fields1486 p.write("(") p.write("column") p.indentSexp() p.newline() - field1478 := unwrapped_fields1477[0].([]string) - p.pretty_gnf_column_path(field1478) - field1479 := unwrapped_fields1477[1].(*pb.RelationId) - if field1479 != nil { + field1488 := unwrapped_fields1487[0].([]string) + p.pretty_gnf_column_path(field1488) + field1489 := unwrapped_fields1487[1].(*pb.RelationId) + if field1489 != nil { p.newline() - opt_val1480 := field1479 - p.pretty_relation_id(opt_val1480) + opt_val1490 := field1489 + p.pretty_relation_id(opt_val1490) } p.newline() p.write("[") - field1481 := unwrapped_fields1477[2].([]*pb.Type) - for i1483, elem1482 := range field1481 { - if (i1483 > 0) { + field1491 := unwrapped_fields1487[2].([]*pb.Type) + for i1493, elem1492 := range field1491 { + if (i1493 > 0) { p.newline() } - p.pretty_type(elem1482) + p.pretty_type(elem1492) } p.write("]") p.dedent() @@ -4085,36 +4116,36 @@ func (p *PrettyPrinter) pretty_gnf_column(msg *pb.GNFColumn) interface{} { } func (p *PrettyPrinter) pretty_gnf_column_path(msg []string) interface{} { - flat1491 := p.tryFlat(msg, func() { p.pretty_gnf_column_path(msg) }) - if flat1491 != nil { - p.write(*flat1491) + flat1501 := p.tryFlat(msg, func() { p.pretty_gnf_column_path(msg) }) + if flat1501 != nil { + p.write(*flat1501) return nil } else { _dollar_dollar := msg - var _t1834 *string + var _t1845 *string if int64(len(_dollar_dollar)) == 1 { - _t1834 = ptr(_dollar_dollar[0]) + _t1845 = ptr(_dollar_dollar[0]) } - deconstruct_result1489 := _t1834 - if deconstruct_result1489 != nil { - unwrapped1490 := *deconstruct_result1489 - p.write(p.formatStringValue(unwrapped1490)) + deconstruct_result1499 := _t1845 + if deconstruct_result1499 != nil { + unwrapped1500 := *deconstruct_result1499 + p.write(p.formatStringValue(unwrapped1500)) } else { _dollar_dollar := msg - var _t1835 []string + var _t1846 []string if int64(len(_dollar_dollar)) != 1 { - _t1835 = _dollar_dollar + _t1846 = _dollar_dollar } - deconstruct_result1485 := _t1835 - if deconstruct_result1485 != nil { - unwrapped1486 := deconstruct_result1485 + deconstruct_result1495 := _t1846 + if deconstruct_result1495 != nil { + unwrapped1496 := deconstruct_result1495 p.write("[") p.indent() - for i1488, elem1487 := range unwrapped1486 { - if (i1488 > 0) { + for i1498, elem1497 := range unwrapped1496 { + if (i1498 > 0) { p.newline() } - p.write(p.formatStringValue(elem1487)) + p.write(p.formatStringValue(elem1497)) } p.dedent() p.write("]") @@ -4127,30 +4158,30 @@ func (p *PrettyPrinter) pretty_gnf_column_path(msg []string) interface{} { } func (p *PrettyPrinter) pretty_target_relations(msg *pb.TargetRelations) interface{} { - flat1498 := p.tryFlat(msg, func() { p.pretty_target_relations(msg) }) - if flat1498 != nil { - p.write(*flat1498) + flat1508 := p.tryFlat(msg, func() { p.pretty_target_relations(msg) }) + if flat1508 != nil { + p.write(*flat1508) return nil } else { _dollar_dollar := msg - _t1836 := p.deconstruct_relation_keys(_dollar_dollar) - _t1837 := p.deconstruct_load_errors_optional(_dollar_dollar) - fields1492 := []interface{}{_t1836, _dollar_dollar, _t1837} - unwrapped_fields1493 := fields1492 + _t1847 := p.deconstruct_relation_keys(_dollar_dollar) + _t1848 := p.deconstruct_load_errors_optional(_dollar_dollar) + fields1502 := []interface{}{_t1847, _dollar_dollar, _t1848} + unwrapped_fields1503 := fields1502 p.write("(") p.write("relations") p.indentSexp() p.newline() - field1494 := unwrapped_fields1493[0].([]interface{}) - p.pretty_relation_keys(field1494) + field1504 := unwrapped_fields1503[0].([]interface{}) + p.pretty_relation_keys(field1504) p.newline() - field1495 := unwrapped_fields1493[1].(*pb.TargetRelations) - p.pretty_relation_body(field1495) - field1496 := unwrapped_fields1493[2].(*pb.RelationId) - if field1496 != nil { + field1505 := unwrapped_fields1503[1].(*pb.TargetRelations) + p.pretty_relation_body(field1505) + field1506 := unwrapped_fields1503[2].(*pb.RelationId) + if field1506 != nil { p.newline() - opt_val1497 := field1496 - p.pretty_load_errors(opt_val1497) + opt_val1507 := field1506 + p.pretty_load_errors(opt_val1507) } p.dedent() p.write(")") @@ -4159,43 +4190,43 @@ func (p *PrettyPrinter) pretty_target_relations(msg *pb.TargetRelations) interfa } func (p *PrettyPrinter) pretty_relation_keys(msg []interface{}) interface{} { - flat1505 := p.tryFlat(msg, func() { p.pretty_relation_keys(msg) }) - if flat1505 != nil { - p.write(*flat1505) + flat1515 := p.tryFlat(msg, func() { p.pretty_relation_keys(msg) }) + if flat1515 != nil { + p.write(*flat1515) return nil } else { _dollar_dollar := msg - var _t1838 []*pb.NamedColumn + var _t1849 []*pb.NamedColumn if !(_dollar_dollar[1].(bool)) { - _t1838 = _dollar_dollar[0].([]*pb.NamedColumn) + _t1849 = _dollar_dollar[0].([]*pb.NamedColumn) } - deconstruct_result1501 := _t1838 - if deconstruct_result1501 != nil { - unwrapped1502 := deconstruct_result1501 + deconstruct_result1511 := _t1849 + if deconstruct_result1511 != nil { + unwrapped1512 := deconstruct_result1511 p.write("(") p.write("keys") p.indentSexp() - if !(len(unwrapped1502) == 0) { + if !(len(unwrapped1512) == 0) { p.newline() - for i1504, elem1503 := range unwrapped1502 { - if (i1504 > 0) { + for i1514, elem1513 := range unwrapped1512 { + if (i1514 > 0) { p.newline() } - p.pretty_named_column(elem1503) + p.pretty_named_column(elem1513) } } p.dedent() p.write(")") } else { _dollar_dollar := msg - var _t1839 []interface{} + var _t1850 []interface{} if _dollar_dollar[1].(bool) { - _t1839 = []interface{}{} + _t1850 = []interface{}{} } - deconstruct_result1499 := _t1839 - if deconstruct_result1499 != nil { - unwrapped1500 := deconstruct_result1499 - _ = unwrapped1500 + deconstruct_result1509 := _t1850 + if deconstruct_result1509 != nil { + unwrapped1510 := deconstruct_result1509 + _ = unwrapped1510 p.write("(") p.write("keys") p.newline() @@ -4210,23 +4241,23 @@ func (p *PrettyPrinter) pretty_relation_keys(msg []interface{}) interface{} { } func (p *PrettyPrinter) pretty_named_column(msg *pb.NamedColumn) interface{} { - flat1510 := p.tryFlat(msg, func() { p.pretty_named_column(msg) }) - if flat1510 != nil { - p.write(*flat1510) + flat1520 := p.tryFlat(msg, func() { p.pretty_named_column(msg) }) + if flat1520 != nil { + p.write(*flat1520) return nil } else { _dollar_dollar := msg - fields1506 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetType()} - unwrapped_fields1507 := fields1506 + fields1516 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetType()} + unwrapped_fields1517 := fields1516 p.write("(") p.write("column") p.indentSexp() p.newline() - field1508 := unwrapped_fields1507[0].(string) - p.write(p.formatStringValue(field1508)) + field1518 := unwrapped_fields1517[0].(string) + p.write(p.formatStringValue(field1518)) p.newline() - field1509 := unwrapped_fields1507[1].(*pb.Type) - p.pretty_type(field1509) + field1519 := unwrapped_fields1517[1].(*pb.Type) + p.pretty_type(field1519) p.dedent() p.write(")") } @@ -4234,34 +4265,34 @@ func (p *PrettyPrinter) pretty_named_column(msg *pb.NamedColumn) interface{} { } func (p *PrettyPrinter) pretty_relation_body(msg *pb.TargetRelations) interface{} { - flat1517 := p.tryFlat(msg, func() { p.pretty_relation_body(msg) }) - if flat1517 != nil { - p.write(*flat1517) + flat1527 := p.tryFlat(msg, func() { p.pretty_relation_body(msg) }) + if flat1527 != nil { + p.write(*flat1527) return nil } else { _dollar_dollar := msg - var _t1840 []*pb.TargetRelation + var _t1851 []*pb.TargetRelation if hasProtoField(_dollar_dollar, "plain") { - _t1840 = _dollar_dollar.GetPlain().GetTargets() + _t1851 = _dollar_dollar.GetPlain().GetTargets() } - deconstruct_result1515 := _t1840 - if deconstruct_result1515 != nil { - unwrapped1516 := deconstruct_result1515 - p.pretty_non_cdc_relations(unwrapped1516) + deconstruct_result1525 := _t1851 + if deconstruct_result1525 != nil { + unwrapped1526 := deconstruct_result1525 + p.pretty_non_cdc_relations(unwrapped1526) } else { _dollar_dollar := msg - var _t1841 []interface{} + var _t1852 []interface{} if hasProtoField(_dollar_dollar, "cdc") { - _t1841 = []interface{}{_dollar_dollar.GetCdc().GetInserts(), _dollar_dollar.GetCdc().GetDeletes()} + _t1852 = []interface{}{_dollar_dollar.GetCdc().GetInserts(), _dollar_dollar.GetCdc().GetDeletes()} } - deconstruct_result1511 := _t1841 - if deconstruct_result1511 != nil { - unwrapped1512 := deconstruct_result1511 - field1513 := unwrapped1512[0].([]*pb.TargetRelation) - p.pretty_cdc_inserts(field1513) + deconstruct_result1521 := _t1852 + if deconstruct_result1521 != nil { + unwrapped1522 := deconstruct_result1521 + field1523 := unwrapped1522[0].([]*pb.TargetRelation) + p.pretty_cdc_inserts(field1523) p.write(" ") - field1514 := unwrapped1512[1].([]*pb.TargetRelation) - p.pretty_cdc_deletes(field1514) + field1524 := unwrapped1522[1].([]*pb.TargetRelation) + p.pretty_cdc_deletes(field1524) } else { panic(ParseError{msg: "No matching rule for relation_body"}) } @@ -4271,45 +4302,45 @@ func (p *PrettyPrinter) pretty_relation_body(msg *pb.TargetRelations) interface{ } func (p *PrettyPrinter) pretty_non_cdc_relations(msg []*pb.TargetRelation) interface{} { - flat1521 := p.tryFlat(msg, func() { p.pretty_non_cdc_relations(msg) }) - if flat1521 != nil { - p.write(*flat1521) + flat1531 := p.tryFlat(msg, func() { p.pretty_non_cdc_relations(msg) }) + if flat1531 != nil { + p.write(*flat1531) return nil } else { - fields1518 := msg - for i1520, elem1519 := range fields1518 { - if (i1520 > 0) { + fields1528 := msg + for i1530, elem1529 := range fields1528 { + if (i1530 > 0) { p.newline() } - p.pretty_target_relation(elem1519) + p.pretty_target_relation(elem1529) } } return nil } func (p *PrettyPrinter) pretty_target_relation(msg *pb.TargetRelation) interface{} { - flat1528 := p.tryFlat(msg, func() { p.pretty_target_relation(msg) }) - if flat1528 != nil { - p.write(*flat1528) + flat1538 := p.tryFlat(msg, func() { p.pretty_target_relation(msg) }) + if flat1538 != nil { + p.write(*flat1538) return nil } else { _dollar_dollar := msg - fields1522 := []interface{}{_dollar_dollar.GetTargetId(), _dollar_dollar.GetValues()} - unwrapped_fields1523 := fields1522 + fields1532 := []interface{}{_dollar_dollar.GetTargetId(), _dollar_dollar.GetValues()} + unwrapped_fields1533 := fields1532 p.write("(") p.write("relation") p.indentSexp() p.newline() - field1524 := unwrapped_fields1523[0].(*pb.RelationId) - p.pretty_relation_id(field1524) - field1525 := unwrapped_fields1523[1].([]*pb.NamedColumn) - if !(len(field1525) == 0) { + field1534 := unwrapped_fields1533[0].(*pb.RelationId) + p.pretty_relation_id(field1534) + field1535 := unwrapped_fields1533[1].([]*pb.NamedColumn) + if !(len(field1535) == 0) { p.newline() - for i1527, elem1526 := range field1525 { - if (i1527 > 0) { + for i1537, elem1536 := range field1535 { + if (i1537 > 0) { p.newline() } - p.pretty_named_column(elem1526) + p.pretty_named_column(elem1536) } } p.dedent() @@ -4319,22 +4350,22 @@ func (p *PrettyPrinter) pretty_target_relation(msg *pb.TargetRelation) interface } func (p *PrettyPrinter) pretty_cdc_inserts(msg []*pb.TargetRelation) interface{} { - flat1532 := p.tryFlat(msg, func() { p.pretty_cdc_inserts(msg) }) - if flat1532 != nil { - p.write(*flat1532) + flat1542 := p.tryFlat(msg, func() { p.pretty_cdc_inserts(msg) }) + if flat1542 != nil { + p.write(*flat1542) return nil } else { - fields1529 := msg + fields1539 := msg p.write("(") p.write("inserts") p.indentSexp() - if !(len(fields1529) == 0) { + if !(len(fields1539) == 0) { p.newline() - for i1531, elem1530 := range fields1529 { - if (i1531 > 0) { + for i1541, elem1540 := range fields1539 { + if (i1541 > 0) { p.newline() } - p.pretty_target_relation(elem1530) + p.pretty_target_relation(elem1540) } } p.dedent() @@ -4344,22 +4375,22 @@ func (p *PrettyPrinter) pretty_cdc_inserts(msg []*pb.TargetRelation) interface{} } func (p *PrettyPrinter) pretty_cdc_deletes(msg []*pb.TargetRelation) interface{} { - flat1536 := p.tryFlat(msg, func() { p.pretty_cdc_deletes(msg) }) - if flat1536 != nil { - p.write(*flat1536) + flat1546 := p.tryFlat(msg, func() { p.pretty_cdc_deletes(msg) }) + if flat1546 != nil { + p.write(*flat1546) return nil } else { - fields1533 := msg + fields1543 := msg p.write("(") p.write("deletes") p.indentSexp() - if !(len(fields1533) == 0) { + if !(len(fields1543) == 0) { p.newline() - for i1535, elem1534 := range fields1533 { - if (i1535 > 0) { + for i1545, elem1544 := range fields1543 { + if (i1545 > 0) { p.newline() } - p.pretty_target_relation(elem1534) + p.pretty_target_relation(elem1544) } } p.dedent() @@ -4369,17 +4400,17 @@ func (p *PrettyPrinter) pretty_cdc_deletes(msg []*pb.TargetRelation) interface{} } func (p *PrettyPrinter) pretty_load_errors(msg *pb.RelationId) interface{} { - flat1538 := p.tryFlat(msg, func() { p.pretty_load_errors(msg) }) - if flat1538 != nil { - p.write(*flat1538) + flat1548 := p.tryFlat(msg, func() { p.pretty_load_errors(msg) }) + if flat1548 != nil { + p.write(*flat1548) return nil } else { - fields1537 := msg + fields1547 := msg p.write("(") p.write("load_errors") p.indentSexp() p.newline() - p.pretty_relation_id(fields1537) + p.pretty_relation_id(fields1547) p.dedent() p.write(")") } @@ -4387,17 +4418,17 @@ func (p *PrettyPrinter) pretty_load_errors(msg *pb.RelationId) interface{} { } func (p *PrettyPrinter) pretty_csv_asof(msg string) interface{} { - flat1540 := p.tryFlat(msg, func() { p.pretty_csv_asof(msg) }) - if flat1540 != nil { - p.write(*flat1540) + flat1550 := p.tryFlat(msg, func() { p.pretty_csv_asof(msg) }) + if flat1550 != nil { + p.write(*flat1550) return nil } else { - fields1539 := msg + fields1549 := msg p.write("(") p.write("asof") p.indentSexp() p.newline() - p.write(p.formatStringValue(fields1539)) + p.write(p.formatStringValue(fields1549)) p.dedent() p.write(")") } @@ -4405,43 +4436,43 @@ func (p *PrettyPrinter) pretty_csv_asof(msg string) interface{} { } func (p *PrettyPrinter) pretty_iceberg_data(msg *pb.IcebergData) interface{} { - flat1551 := p.tryFlat(msg, func() { p.pretty_iceberg_data(msg) }) - if flat1551 != nil { - p.write(*flat1551) + flat1561 := p.tryFlat(msg, func() { p.pretty_iceberg_data(msg) }) + if flat1561 != nil { + p.write(*flat1561) return nil } else { _dollar_dollar := msg - _t1842 := p.deconstruct_iceberg_data_from_snapshot_optional(_dollar_dollar) - _t1843 := p.deconstruct_iceberg_data_to_snapshot_optional(_dollar_dollar) - fields1541 := []interface{}{_dollar_dollar.GetLocator(), _dollar_dollar.GetConfig(), _dollar_dollar.GetColumns(), _t1842, _t1843, _dollar_dollar.GetReturnsDelta()} - unwrapped_fields1542 := fields1541 + _t1853 := p.deconstruct_iceberg_data_from_snapshot_optional(_dollar_dollar) + _t1854 := p.deconstruct_iceberg_data_to_snapshot_optional(_dollar_dollar) + fields1551 := []interface{}{_dollar_dollar.GetLocator(), _dollar_dollar.GetConfig(), _dollar_dollar.GetColumns(), _t1853, _t1854, _dollar_dollar.GetReturnsDelta()} + unwrapped_fields1552 := fields1551 p.write("(") p.write("iceberg_data") p.indentSexp() p.newline() - field1543 := unwrapped_fields1542[0].(*pb.IcebergLocator) - p.pretty_iceberg_locator(field1543) + field1553 := unwrapped_fields1552[0].(*pb.IcebergLocator) + p.pretty_iceberg_locator(field1553) p.newline() - field1544 := unwrapped_fields1542[1].(*pb.IcebergCatalogConfig) - p.pretty_iceberg_catalog_config(field1544) + field1554 := unwrapped_fields1552[1].(*pb.IcebergCatalogConfig) + p.pretty_iceberg_catalog_config(field1554) p.newline() - field1545 := unwrapped_fields1542[2].([]*pb.GNFColumn) - p.pretty_gnf_columns(field1545) - field1546 := unwrapped_fields1542[3].(*string) - if field1546 != nil { + field1555 := unwrapped_fields1552[2].([]*pb.GNFColumn) + p.pretty_gnf_columns(field1555) + field1556 := unwrapped_fields1552[3].(*string) + if field1556 != nil { p.newline() - opt_val1547 := *field1546 - p.pretty_iceberg_from_snapshot(opt_val1547) + opt_val1557 := *field1556 + p.pretty_iceberg_from_snapshot(opt_val1557) } - field1548 := unwrapped_fields1542[4].(*string) - if field1548 != nil { + field1558 := unwrapped_fields1552[4].(*string) + if field1558 != nil { p.newline() - opt_val1549 := *field1548 - p.pretty_iceberg_to_snapshot(opt_val1549) + opt_val1559 := *field1558 + p.pretty_iceberg_to_snapshot(opt_val1559) } p.newline() - field1550 := unwrapped_fields1542[5].(bool) - p.pretty_boolean_value(field1550) + field1560 := unwrapped_fields1552[5].(bool) + p.pretty_boolean_value(field1560) p.dedent() p.write(")") } @@ -4449,26 +4480,26 @@ func (p *PrettyPrinter) pretty_iceberg_data(msg *pb.IcebergData) interface{} { } func (p *PrettyPrinter) pretty_iceberg_locator(msg *pb.IcebergLocator) interface{} { - flat1557 := p.tryFlat(msg, func() { p.pretty_iceberg_locator(msg) }) - if flat1557 != nil { - p.write(*flat1557) + flat1567 := p.tryFlat(msg, func() { p.pretty_iceberg_locator(msg) }) + if flat1567 != nil { + p.write(*flat1567) return nil } else { _dollar_dollar := msg - fields1552 := []interface{}{_dollar_dollar.GetTableName(), _dollar_dollar.GetNamespace(), _dollar_dollar.GetWarehouse()} - unwrapped_fields1553 := fields1552 + fields1562 := []interface{}{_dollar_dollar.GetTableName(), _dollar_dollar.GetNamespace(), _dollar_dollar.GetWarehouse()} + unwrapped_fields1563 := fields1562 p.write("(") p.write("iceberg_locator") p.indentSexp() p.newline() - field1554 := unwrapped_fields1553[0].(string) - p.pretty_iceberg_locator_table_name(field1554) + field1564 := unwrapped_fields1563[0].(string) + p.pretty_iceberg_locator_table_name(field1564) p.newline() - field1555 := unwrapped_fields1553[1].([]string) - p.pretty_iceberg_locator_namespace(field1555) + field1565 := unwrapped_fields1563[1].([]string) + p.pretty_iceberg_locator_namespace(field1565) p.newline() - field1556 := unwrapped_fields1553[2].(string) - p.pretty_iceberg_locator_warehouse(field1556) + field1566 := unwrapped_fields1563[2].(string) + p.pretty_iceberg_locator_warehouse(field1566) p.dedent() p.write(")") } @@ -4476,17 +4507,17 @@ func (p *PrettyPrinter) pretty_iceberg_locator(msg *pb.IcebergLocator) interface } func (p *PrettyPrinter) pretty_iceberg_locator_table_name(msg string) interface{} { - flat1559 := p.tryFlat(msg, func() { p.pretty_iceberg_locator_table_name(msg) }) - if flat1559 != nil { - p.write(*flat1559) + flat1569 := p.tryFlat(msg, func() { p.pretty_iceberg_locator_table_name(msg) }) + if flat1569 != nil { + p.write(*flat1569) return nil } else { - fields1558 := msg + fields1568 := msg p.write("(") p.write("table_name") p.indentSexp() p.newline() - p.write(p.formatStringValue(fields1558)) + p.write(p.formatStringValue(fields1568)) p.dedent() p.write(")") } @@ -4494,22 +4525,22 @@ func (p *PrettyPrinter) pretty_iceberg_locator_table_name(msg string) interface{ } func (p *PrettyPrinter) pretty_iceberg_locator_namespace(msg []string) interface{} { - flat1563 := p.tryFlat(msg, func() { p.pretty_iceberg_locator_namespace(msg) }) - if flat1563 != nil { - p.write(*flat1563) + flat1573 := p.tryFlat(msg, func() { p.pretty_iceberg_locator_namespace(msg) }) + if flat1573 != nil { + p.write(*flat1573) return nil } else { - fields1560 := msg + fields1570 := msg p.write("(") p.write("namespace") p.indentSexp() - if !(len(fields1560) == 0) { + if !(len(fields1570) == 0) { p.newline() - for i1562, elem1561 := range fields1560 { - if (i1562 > 0) { + for i1572, elem1571 := range fields1570 { + if (i1572 > 0) { p.newline() } - p.write(p.formatStringValue(elem1561)) + p.write(p.formatStringValue(elem1571)) } } p.dedent() @@ -4519,17 +4550,17 @@ func (p *PrettyPrinter) pretty_iceberg_locator_namespace(msg []string) interface } func (p *PrettyPrinter) pretty_iceberg_locator_warehouse(msg string) interface{} { - flat1565 := p.tryFlat(msg, func() { p.pretty_iceberg_locator_warehouse(msg) }) - if flat1565 != nil { - p.write(*flat1565) + flat1575 := p.tryFlat(msg, func() { p.pretty_iceberg_locator_warehouse(msg) }) + if flat1575 != nil { + p.write(*flat1575) return nil } else { - fields1564 := msg + fields1574 := msg p.write("(") p.write("warehouse") p.indentSexp() p.newline() - p.write(p.formatStringValue(fields1564)) + p.write(p.formatStringValue(fields1574)) p.dedent() p.write(")") } @@ -4537,33 +4568,33 @@ func (p *PrettyPrinter) pretty_iceberg_locator_warehouse(msg string) interface{} } func (p *PrettyPrinter) pretty_iceberg_catalog_config(msg *pb.IcebergCatalogConfig) interface{} { - flat1573 := p.tryFlat(msg, func() { p.pretty_iceberg_catalog_config(msg) }) - if flat1573 != nil { - p.write(*flat1573) + flat1583 := p.tryFlat(msg, func() { p.pretty_iceberg_catalog_config(msg) }) + if flat1583 != nil { + p.write(*flat1583) return nil } else { _dollar_dollar := msg - _t1844 := p.deconstruct_iceberg_catalog_config_scope_optional(_dollar_dollar) - fields1566 := []interface{}{_dollar_dollar.GetCatalogUri(), _t1844, dictToPairs(_dollar_dollar.GetProperties()), dictToPairs(_dollar_dollar.GetAuthProperties())} - unwrapped_fields1567 := fields1566 + _t1855 := p.deconstruct_iceberg_catalog_config_scope_optional(_dollar_dollar) + fields1576 := []interface{}{_dollar_dollar.GetCatalogUri(), _t1855, dictToPairs(_dollar_dollar.GetProperties()), dictToPairs(_dollar_dollar.GetAuthProperties())} + unwrapped_fields1577 := fields1576 p.write("(") p.write("iceberg_catalog_config") p.indentSexp() p.newline() - field1568 := unwrapped_fields1567[0].(string) - p.pretty_iceberg_catalog_uri(field1568) - field1569 := unwrapped_fields1567[1].(*string) - if field1569 != nil { + field1578 := unwrapped_fields1577[0].(string) + p.pretty_iceberg_catalog_uri(field1578) + field1579 := unwrapped_fields1577[1].(*string) + if field1579 != nil { p.newline() - opt_val1570 := *field1569 - p.pretty_iceberg_catalog_config_scope(opt_val1570) + opt_val1580 := *field1579 + p.pretty_iceberg_catalog_config_scope(opt_val1580) } p.newline() - field1571 := unwrapped_fields1567[2].([][]interface{}) - p.pretty_iceberg_properties(field1571) + field1581 := unwrapped_fields1577[2].([][]interface{}) + p.pretty_iceberg_properties(field1581) p.newline() - field1572 := unwrapped_fields1567[3].([][]interface{}) - p.pretty_iceberg_auth_properties(field1572) + field1582 := unwrapped_fields1577[3].([][]interface{}) + p.pretty_iceberg_auth_properties(field1582) p.dedent() p.write(")") } @@ -4571,17 +4602,17 @@ func (p *PrettyPrinter) pretty_iceberg_catalog_config(msg *pb.IcebergCatalogConf } func (p *PrettyPrinter) pretty_iceberg_catalog_uri(msg string) interface{} { - flat1575 := p.tryFlat(msg, func() { p.pretty_iceberg_catalog_uri(msg) }) - if flat1575 != nil { - p.write(*flat1575) + flat1585 := p.tryFlat(msg, func() { p.pretty_iceberg_catalog_uri(msg) }) + if flat1585 != nil { + p.write(*flat1585) return nil } else { - fields1574 := msg + fields1584 := msg p.write("(") p.write("catalog_uri") p.indentSexp() p.newline() - p.write(p.formatStringValue(fields1574)) + p.write(p.formatStringValue(fields1584)) p.dedent() p.write(")") } @@ -4589,17 +4620,17 @@ func (p *PrettyPrinter) pretty_iceberg_catalog_uri(msg string) interface{} { } func (p *PrettyPrinter) pretty_iceberg_catalog_config_scope(msg string) interface{} { - flat1577 := p.tryFlat(msg, func() { p.pretty_iceberg_catalog_config_scope(msg) }) - if flat1577 != nil { - p.write(*flat1577) + flat1587 := p.tryFlat(msg, func() { p.pretty_iceberg_catalog_config_scope(msg) }) + if flat1587 != nil { + p.write(*flat1587) return nil } else { - fields1576 := msg + fields1586 := msg p.write("(") p.write("scope") p.indentSexp() p.newline() - p.write(p.formatStringValue(fields1576)) + p.write(p.formatStringValue(fields1586)) p.dedent() p.write(")") } @@ -4607,22 +4638,22 @@ func (p *PrettyPrinter) pretty_iceberg_catalog_config_scope(msg string) interfac } func (p *PrettyPrinter) pretty_iceberg_properties(msg [][]interface{}) interface{} { - flat1581 := p.tryFlat(msg, func() { p.pretty_iceberg_properties(msg) }) - if flat1581 != nil { - p.write(*flat1581) + flat1591 := p.tryFlat(msg, func() { p.pretty_iceberg_properties(msg) }) + if flat1591 != nil { + p.write(*flat1591) return nil } else { - fields1578 := msg + fields1588 := msg p.write("(") p.write("properties") p.indentSexp() - if !(len(fields1578) == 0) { + if !(len(fields1588) == 0) { p.newline() - for i1580, elem1579 := range fields1578 { - if (i1580 > 0) { + for i1590, elem1589 := range fields1588 { + if (i1590 > 0) { p.newline() } - p.pretty_iceberg_property_entry(elem1579) + p.pretty_iceberg_property_entry(elem1589) } } p.dedent() @@ -4632,23 +4663,23 @@ func (p *PrettyPrinter) pretty_iceberg_properties(msg [][]interface{}) interface } func (p *PrettyPrinter) pretty_iceberg_property_entry(msg []interface{}) interface{} { - flat1586 := p.tryFlat(msg, func() { p.pretty_iceberg_property_entry(msg) }) - if flat1586 != nil { - p.write(*flat1586) + flat1596 := p.tryFlat(msg, func() { p.pretty_iceberg_property_entry(msg) }) + if flat1596 != nil { + p.write(*flat1596) return nil } else { _dollar_dollar := msg - fields1582 := []interface{}{_dollar_dollar[0].(string), _dollar_dollar[1].(string)} - unwrapped_fields1583 := fields1582 + fields1592 := []interface{}{_dollar_dollar[0].(string), _dollar_dollar[1].(string)} + unwrapped_fields1593 := fields1592 p.write("(") p.write("prop") p.indentSexp() p.newline() - field1584 := unwrapped_fields1583[0].(string) - p.write(p.formatStringValue(field1584)) + field1594 := unwrapped_fields1593[0].(string) + p.write(p.formatStringValue(field1594)) p.newline() - field1585 := unwrapped_fields1583[1].(string) - p.write(p.formatStringValue(field1585)) + field1595 := unwrapped_fields1593[1].(string) + p.write(p.formatStringValue(field1595)) p.dedent() p.write(")") } @@ -4656,22 +4687,22 @@ func (p *PrettyPrinter) pretty_iceberg_property_entry(msg []interface{}) interfa } func (p *PrettyPrinter) pretty_iceberg_auth_properties(msg [][]interface{}) interface{} { - flat1590 := p.tryFlat(msg, func() { p.pretty_iceberg_auth_properties(msg) }) - if flat1590 != nil { - p.write(*flat1590) + flat1600 := p.tryFlat(msg, func() { p.pretty_iceberg_auth_properties(msg) }) + if flat1600 != nil { + p.write(*flat1600) return nil } else { - fields1587 := msg + fields1597 := msg p.write("(") p.write("auth_properties") p.indentSexp() - if !(len(fields1587) == 0) { + if !(len(fields1597) == 0) { p.newline() - for i1589, elem1588 := range fields1587 { - if (i1589 > 0) { + for i1599, elem1598 := range fields1597 { + if (i1599 > 0) { p.newline() } - p.pretty_iceberg_masked_property_entry(elem1588) + p.pretty_iceberg_masked_property_entry(elem1598) } } p.dedent() @@ -4681,24 +4712,24 @@ func (p *PrettyPrinter) pretty_iceberg_auth_properties(msg [][]interface{}) inte } func (p *PrettyPrinter) pretty_iceberg_masked_property_entry(msg []interface{}) interface{} { - flat1595 := p.tryFlat(msg, func() { p.pretty_iceberg_masked_property_entry(msg) }) - if flat1595 != nil { - p.write(*flat1595) + flat1605 := p.tryFlat(msg, func() { p.pretty_iceberg_masked_property_entry(msg) }) + if flat1605 != nil { + p.write(*flat1605) return nil } else { _dollar_dollar := msg - _t1845 := p.mask_secret_value(_dollar_dollar) - fields1591 := []interface{}{_dollar_dollar[0].(string), _t1845} - unwrapped_fields1592 := fields1591 + _t1856 := p.mask_secret_value(_dollar_dollar) + fields1601 := []interface{}{_dollar_dollar[0].(string), _t1856} + unwrapped_fields1602 := fields1601 p.write("(") p.write("prop") p.indentSexp() p.newline() - field1593 := unwrapped_fields1592[0].(string) - p.write(p.formatStringValue(field1593)) + field1603 := unwrapped_fields1602[0].(string) + p.write(p.formatStringValue(field1603)) p.newline() - field1594 := unwrapped_fields1592[1].(string) - p.write(p.formatStringValue(field1594)) + field1604 := unwrapped_fields1602[1].(string) + p.write(p.formatStringValue(field1604)) p.dedent() p.write(")") } @@ -4706,17 +4737,17 @@ func (p *PrettyPrinter) pretty_iceberg_masked_property_entry(msg []interface{}) } func (p *PrettyPrinter) pretty_iceberg_from_snapshot(msg string) interface{} { - flat1597 := p.tryFlat(msg, func() { p.pretty_iceberg_from_snapshot(msg) }) - if flat1597 != nil { - p.write(*flat1597) + flat1607 := p.tryFlat(msg, func() { p.pretty_iceberg_from_snapshot(msg) }) + if flat1607 != nil { + p.write(*flat1607) return nil } else { - fields1596 := msg + fields1606 := msg p.write("(") p.write("from_snapshot") p.indentSexp() p.newline() - p.write(p.formatStringValue(fields1596)) + p.write(p.formatStringValue(fields1606)) p.dedent() p.write(")") } @@ -4724,17 +4755,17 @@ func (p *PrettyPrinter) pretty_iceberg_from_snapshot(msg string) interface{} { } func (p *PrettyPrinter) pretty_iceberg_to_snapshot(msg string) interface{} { - flat1599 := p.tryFlat(msg, func() { p.pretty_iceberg_to_snapshot(msg) }) - if flat1599 != nil { - p.write(*flat1599) + flat1609 := p.tryFlat(msg, func() { p.pretty_iceberg_to_snapshot(msg) }) + if flat1609 != nil { + p.write(*flat1609) return nil } else { - fields1598 := msg + fields1608 := msg p.write("(") p.write("to_snapshot") p.indentSexp() p.newline() - p.write(p.formatStringValue(fields1598)) + p.write(p.formatStringValue(fields1608)) p.dedent() p.write(")") } @@ -4742,19 +4773,19 @@ func (p *PrettyPrinter) pretty_iceberg_to_snapshot(msg string) interface{} { } func (p *PrettyPrinter) pretty_undefine(msg *pb.Undefine) interface{} { - flat1602 := p.tryFlat(msg, func() { p.pretty_undefine(msg) }) - if flat1602 != nil { - p.write(*flat1602) + flat1612 := p.tryFlat(msg, func() { p.pretty_undefine(msg) }) + if flat1612 != nil { + p.write(*flat1612) return nil } else { _dollar_dollar := msg - fields1600 := _dollar_dollar.GetFragmentId() - unwrapped_fields1601 := fields1600 + fields1610 := _dollar_dollar.GetFragmentId() + unwrapped_fields1611 := fields1610 p.write("(") p.write("undefine") p.indentSexp() p.newline() - p.pretty_fragment_id(unwrapped_fields1601) + p.pretty_fragment_id(unwrapped_fields1611) p.dedent() p.write(")") } @@ -4762,24 +4793,24 @@ func (p *PrettyPrinter) pretty_undefine(msg *pb.Undefine) interface{} { } func (p *PrettyPrinter) pretty_context(msg *pb.Context) interface{} { - flat1607 := p.tryFlat(msg, func() { p.pretty_context(msg) }) - if flat1607 != nil { - p.write(*flat1607) + flat1617 := p.tryFlat(msg, func() { p.pretty_context(msg) }) + if flat1617 != nil { + p.write(*flat1617) return nil } else { _dollar_dollar := msg - fields1603 := _dollar_dollar.GetRelations() - unwrapped_fields1604 := fields1603 + fields1613 := _dollar_dollar.GetRelations() + unwrapped_fields1614 := fields1613 p.write("(") p.write("context") p.indentSexp() - if !(len(unwrapped_fields1604) == 0) { + if !(len(unwrapped_fields1614) == 0) { p.newline() - for i1606, elem1605 := range unwrapped_fields1604 { - if (i1606 > 0) { + for i1616, elem1615 := range unwrapped_fields1614 { + if (i1616 > 0) { p.newline() } - p.pretty_relation_id(elem1605) + p.pretty_relation_id(elem1615) } } p.dedent() @@ -4789,28 +4820,28 @@ func (p *PrettyPrinter) pretty_context(msg *pb.Context) interface{} { } func (p *PrettyPrinter) pretty_snapshot(msg *pb.Snapshot) interface{} { - flat1614 := p.tryFlat(msg, func() { p.pretty_snapshot(msg) }) - if flat1614 != nil { - p.write(*flat1614) + flat1624 := p.tryFlat(msg, func() { p.pretty_snapshot(msg) }) + if flat1624 != nil { + p.write(*flat1624) return nil } else { _dollar_dollar := msg - fields1608 := []interface{}{_dollar_dollar.GetPrefix(), _dollar_dollar.GetMappings()} - unwrapped_fields1609 := fields1608 + fields1618 := []interface{}{_dollar_dollar.GetPrefix(), _dollar_dollar.GetMappings()} + unwrapped_fields1619 := fields1618 p.write("(") p.write("snapshot") p.indentSexp() p.newline() - field1610 := unwrapped_fields1609[0].([]string) - p.pretty_edb_path(field1610) - field1611 := unwrapped_fields1609[1].([]*pb.SnapshotMapping) - if !(len(field1611) == 0) { + field1620 := unwrapped_fields1619[0].([]string) + p.pretty_edb_path(field1620) + field1621 := unwrapped_fields1619[1].([]*pb.SnapshotMapping) + if !(len(field1621) == 0) { p.newline() - for i1613, elem1612 := range field1611 { - if (i1613 > 0) { + for i1623, elem1622 := range field1621 { + if (i1623 > 0) { p.newline() } - p.pretty_snapshot_mapping(elem1612) + p.pretty_snapshot_mapping(elem1622) } } p.dedent() @@ -4820,40 +4851,40 @@ func (p *PrettyPrinter) pretty_snapshot(msg *pb.Snapshot) interface{} { } func (p *PrettyPrinter) pretty_snapshot_mapping(msg *pb.SnapshotMapping) interface{} { - flat1619 := p.tryFlat(msg, func() { p.pretty_snapshot_mapping(msg) }) - if flat1619 != nil { - p.write(*flat1619) + flat1629 := p.tryFlat(msg, func() { p.pretty_snapshot_mapping(msg) }) + if flat1629 != nil { + p.write(*flat1629) return nil } else { _dollar_dollar := msg - fields1615 := []interface{}{_dollar_dollar.GetDestinationPath(), _dollar_dollar.GetSourceRelation()} - unwrapped_fields1616 := fields1615 - field1617 := unwrapped_fields1616[0].([]string) - p.pretty_edb_path(field1617) + fields1625 := []interface{}{_dollar_dollar.GetDestinationPath(), _dollar_dollar.GetSourceRelation()} + unwrapped_fields1626 := fields1625 + field1627 := unwrapped_fields1626[0].([]string) + p.pretty_edb_path(field1627) p.write(" ") - field1618 := unwrapped_fields1616[1].(*pb.RelationId) - p.pretty_relation_id(field1618) + field1628 := unwrapped_fields1626[1].(*pb.RelationId) + p.pretty_relation_id(field1628) } return nil } func (p *PrettyPrinter) pretty_epoch_reads(msg []*pb.Read) interface{} { - flat1623 := p.tryFlat(msg, func() { p.pretty_epoch_reads(msg) }) - if flat1623 != nil { - p.write(*flat1623) + flat1633 := p.tryFlat(msg, func() { p.pretty_epoch_reads(msg) }) + if flat1633 != nil { + p.write(*flat1633) return nil } else { - fields1620 := msg + fields1630 := msg p.write("(") p.write("reads") p.indentSexp() - if !(len(fields1620) == 0) { + if !(len(fields1630) == 0) { p.newline() - for i1622, elem1621 := range fields1620 { - if (i1622 > 0) { + for i1632, elem1631 := range fields1630 { + if (i1632 > 0) { p.newline() } - p.pretty_read(elem1621) + p.pretty_read(elem1631) } } p.dedent() @@ -4863,60 +4894,60 @@ func (p *PrettyPrinter) pretty_epoch_reads(msg []*pb.Read) interface{} { } func (p *PrettyPrinter) pretty_read(msg *pb.Read) interface{} { - flat1634 := p.tryFlat(msg, func() { p.pretty_read(msg) }) - if flat1634 != nil { - p.write(*flat1634) + flat1644 := p.tryFlat(msg, func() { p.pretty_read(msg) }) + if flat1644 != nil { + p.write(*flat1644) return nil } else { _dollar_dollar := msg - var _t1846 *pb.Demand + var _t1857 *pb.Demand if hasProtoField(_dollar_dollar, "demand") { - _t1846 = _dollar_dollar.GetDemand() + _t1857 = _dollar_dollar.GetDemand() } - deconstruct_result1632 := _t1846 - if deconstruct_result1632 != nil { - unwrapped1633 := deconstruct_result1632 - p.pretty_demand(unwrapped1633) + deconstruct_result1642 := _t1857 + if deconstruct_result1642 != nil { + unwrapped1643 := deconstruct_result1642 + p.pretty_demand(unwrapped1643) } else { _dollar_dollar := msg - var _t1847 *pb.Output + var _t1858 *pb.Output if hasProtoField(_dollar_dollar, "output") { - _t1847 = _dollar_dollar.GetOutput() + _t1858 = _dollar_dollar.GetOutput() } - deconstruct_result1630 := _t1847 - if deconstruct_result1630 != nil { - unwrapped1631 := deconstruct_result1630 - p.pretty_output(unwrapped1631) + deconstruct_result1640 := _t1858 + if deconstruct_result1640 != nil { + unwrapped1641 := deconstruct_result1640 + p.pretty_output(unwrapped1641) } else { _dollar_dollar := msg - var _t1848 *pb.WhatIf + var _t1859 *pb.WhatIf if hasProtoField(_dollar_dollar, "what_if") { - _t1848 = _dollar_dollar.GetWhatIf() + _t1859 = _dollar_dollar.GetWhatIf() } - deconstruct_result1628 := _t1848 - if deconstruct_result1628 != nil { - unwrapped1629 := deconstruct_result1628 - p.pretty_what_if(unwrapped1629) + deconstruct_result1638 := _t1859 + if deconstruct_result1638 != nil { + unwrapped1639 := deconstruct_result1638 + p.pretty_what_if(unwrapped1639) } else { _dollar_dollar := msg - var _t1849 *pb.Abort + var _t1860 *pb.Abort if hasProtoField(_dollar_dollar, "abort") { - _t1849 = _dollar_dollar.GetAbort() + _t1860 = _dollar_dollar.GetAbort() } - deconstruct_result1626 := _t1849 - if deconstruct_result1626 != nil { - unwrapped1627 := deconstruct_result1626 - p.pretty_abort(unwrapped1627) + deconstruct_result1636 := _t1860 + if deconstruct_result1636 != nil { + unwrapped1637 := deconstruct_result1636 + p.pretty_abort(unwrapped1637) } else { _dollar_dollar := msg - var _t1850 *pb.Export + var _t1861 *pb.Export if hasProtoField(_dollar_dollar, "export") { - _t1850 = _dollar_dollar.GetExport() + _t1861 = _dollar_dollar.GetExport() } - deconstruct_result1624 := _t1850 - if deconstruct_result1624 != nil { - unwrapped1625 := deconstruct_result1624 - p.pretty_export(unwrapped1625) + deconstruct_result1634 := _t1861 + if deconstruct_result1634 != nil { + unwrapped1635 := deconstruct_result1634 + p.pretty_export(unwrapped1635) } else { panic(ParseError{msg: "No matching rule for read"}) } @@ -4929,19 +4960,19 @@ func (p *PrettyPrinter) pretty_read(msg *pb.Read) interface{} { } func (p *PrettyPrinter) pretty_demand(msg *pb.Demand) interface{} { - flat1637 := p.tryFlat(msg, func() { p.pretty_demand(msg) }) - if flat1637 != nil { - p.write(*flat1637) + flat1647 := p.tryFlat(msg, func() { p.pretty_demand(msg) }) + if flat1647 != nil { + p.write(*flat1647) return nil } else { _dollar_dollar := msg - fields1635 := _dollar_dollar.GetRelationId() - unwrapped_fields1636 := fields1635 + fields1645 := _dollar_dollar.GetRelationId() + unwrapped_fields1646 := fields1645 p.write("(") p.write("demand") p.indentSexp() p.newline() - p.pretty_relation_id(unwrapped_fields1636) + p.pretty_relation_id(unwrapped_fields1646) p.dedent() p.write(")") } @@ -4949,23 +4980,23 @@ func (p *PrettyPrinter) pretty_demand(msg *pb.Demand) interface{} { } func (p *PrettyPrinter) pretty_output(msg *pb.Output) interface{} { - flat1642 := p.tryFlat(msg, func() { p.pretty_output(msg) }) - if flat1642 != nil { - p.write(*flat1642) + flat1652 := p.tryFlat(msg, func() { p.pretty_output(msg) }) + if flat1652 != nil { + p.write(*flat1652) return nil } else { _dollar_dollar := msg - fields1638 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetRelationId()} - unwrapped_fields1639 := fields1638 + fields1648 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetRelationId()} + unwrapped_fields1649 := fields1648 p.write("(") p.write("output") p.indentSexp() p.newline() - field1640 := unwrapped_fields1639[0].(string) - p.pretty_name(field1640) + field1650 := unwrapped_fields1649[0].(string) + p.pretty_name(field1650) p.newline() - field1641 := unwrapped_fields1639[1].(*pb.RelationId) - p.pretty_relation_id(field1641) + field1651 := unwrapped_fields1649[1].(*pb.RelationId) + p.pretty_relation_id(field1651) p.dedent() p.write(")") } @@ -4973,23 +5004,23 @@ func (p *PrettyPrinter) pretty_output(msg *pb.Output) interface{} { } func (p *PrettyPrinter) pretty_what_if(msg *pb.WhatIf) interface{} { - flat1647 := p.tryFlat(msg, func() { p.pretty_what_if(msg) }) - if flat1647 != nil { - p.write(*flat1647) + flat1657 := p.tryFlat(msg, func() { p.pretty_what_if(msg) }) + if flat1657 != nil { + p.write(*flat1657) return nil } else { _dollar_dollar := msg - fields1643 := []interface{}{_dollar_dollar.GetBranch(), _dollar_dollar.GetEpoch()} - unwrapped_fields1644 := fields1643 + fields1653 := []interface{}{_dollar_dollar.GetBranch(), _dollar_dollar.GetEpoch()} + unwrapped_fields1654 := fields1653 p.write("(") p.write("what_if") p.indentSexp() p.newline() - field1645 := unwrapped_fields1644[0].(string) - p.pretty_name(field1645) + field1655 := unwrapped_fields1654[0].(string) + p.pretty_name(field1655) p.newline() - field1646 := unwrapped_fields1644[1].(*pb.Epoch) - p.pretty_epoch(field1646) + field1656 := unwrapped_fields1654[1].(*pb.Epoch) + p.pretty_epoch(field1656) p.dedent() p.write(")") } @@ -4997,30 +5028,30 @@ func (p *PrettyPrinter) pretty_what_if(msg *pb.WhatIf) interface{} { } func (p *PrettyPrinter) pretty_abort(msg *pb.Abort) interface{} { - flat1653 := p.tryFlat(msg, func() { p.pretty_abort(msg) }) - if flat1653 != nil { - p.write(*flat1653) + flat1663 := p.tryFlat(msg, func() { p.pretty_abort(msg) }) + if flat1663 != nil { + p.write(*flat1663) return nil } else { _dollar_dollar := msg - var _t1851 *string + var _t1862 *string if _dollar_dollar.GetName() != "abort" { - _t1851 = ptr(_dollar_dollar.GetName()) + _t1862 = ptr(_dollar_dollar.GetName()) } - fields1648 := []interface{}{_t1851, _dollar_dollar.GetRelationId()} - unwrapped_fields1649 := fields1648 + fields1658 := []interface{}{_t1862, _dollar_dollar.GetRelationId()} + unwrapped_fields1659 := fields1658 p.write("(") p.write("abort") p.indentSexp() - field1650 := unwrapped_fields1649[0].(*string) - if field1650 != nil { + field1660 := unwrapped_fields1659[0].(*string) + if field1660 != nil { p.newline() - opt_val1651 := *field1650 - p.pretty_name(opt_val1651) + opt_val1661 := *field1660 + p.pretty_name(opt_val1661) } p.newline() - field1652 := unwrapped_fields1649[1].(*pb.RelationId) - p.pretty_relation_id(field1652) + field1662 := unwrapped_fields1659[1].(*pb.RelationId) + p.pretty_relation_id(field1662) p.dedent() p.write(")") } @@ -5028,40 +5059,40 @@ func (p *PrettyPrinter) pretty_abort(msg *pb.Abort) interface{} { } func (p *PrettyPrinter) pretty_export(msg *pb.Export) interface{} { - flat1658 := p.tryFlat(msg, func() { p.pretty_export(msg) }) - if flat1658 != nil { - p.write(*flat1658) + flat1668 := p.tryFlat(msg, func() { p.pretty_export(msg) }) + if flat1668 != nil { + p.write(*flat1668) return nil } else { _dollar_dollar := msg - var _t1852 *pb.ExportCSVConfig + var _t1863 *pb.ExportCSVConfig if hasProtoField(_dollar_dollar, "csv_config") { - _t1852 = _dollar_dollar.GetCsvConfig() + _t1863 = _dollar_dollar.GetCsvConfig() } - deconstruct_result1656 := _t1852 - if deconstruct_result1656 != nil { - unwrapped1657 := deconstruct_result1656 + deconstruct_result1666 := _t1863 + if deconstruct_result1666 != nil { + unwrapped1667 := deconstruct_result1666 p.write("(") p.write("export") p.indentSexp() p.newline() - p.pretty_export_csv_config(unwrapped1657) + p.pretty_export_csv_config(unwrapped1667) p.dedent() p.write(")") } else { _dollar_dollar := msg - var _t1853 *pb.ExportIcebergConfig + var _t1864 *pb.ExportIcebergConfig if hasProtoField(_dollar_dollar, "iceberg_config") { - _t1853 = _dollar_dollar.GetIcebergConfig() + _t1864 = _dollar_dollar.GetIcebergConfig() } - deconstruct_result1654 := _t1853 - if deconstruct_result1654 != nil { - unwrapped1655 := deconstruct_result1654 + deconstruct_result1664 := _t1864 + if deconstruct_result1664 != nil { + unwrapped1665 := deconstruct_result1664 p.write("(") p.write("export_iceberg") p.indentSexp() p.newline() - p.pretty_export_iceberg_config(unwrapped1655) + p.pretty_export_iceberg_config(unwrapped1665) p.dedent() p.write(")") } else { @@ -5073,56 +5104,56 @@ func (p *PrettyPrinter) pretty_export(msg *pb.Export) interface{} { } func (p *PrettyPrinter) pretty_export_csv_config(msg *pb.ExportCSVConfig) interface{} { - flat1669 := p.tryFlat(msg, func() { p.pretty_export_csv_config(msg) }) - if flat1669 != nil { - p.write(*flat1669) + flat1679 := p.tryFlat(msg, func() { p.pretty_export_csv_config(msg) }) + if flat1679 != nil { + p.write(*flat1679) return nil } else { _dollar_dollar := msg - var _t1854 []interface{} + var _t1865 []interface{} if int64(len(_dollar_dollar.GetDataColumns())) == 0 { - _t1855 := p.deconstruct_export_csv_output_location(_dollar_dollar) - _t1854 = []interface{}{_t1855, _dollar_dollar.GetCsvSource(), _dollar_dollar.GetCsvConfig()} + _t1866 := p.deconstruct_export_csv_output_location(_dollar_dollar) + _t1865 = []interface{}{_t1866, _dollar_dollar.GetCsvSource(), _dollar_dollar.GetCsvConfig()} } - deconstruct_result1664 := _t1854 - if deconstruct_result1664 != nil { - unwrapped1665 := deconstruct_result1664 + deconstruct_result1674 := _t1865 + if deconstruct_result1674 != nil { + unwrapped1675 := deconstruct_result1674 p.write("(") p.write("export_csv_config_v2") p.indentSexp() p.newline() - field1666 := unwrapped1665[0].([]interface{}) - p.pretty_export_csv_output_location(field1666) + field1676 := unwrapped1675[0].([]interface{}) + p.pretty_export_csv_output_location(field1676) p.newline() - field1667 := unwrapped1665[1].(*pb.ExportCSVSource) - p.pretty_export_csv_source(field1667) + field1677 := unwrapped1675[1].(*pb.ExportCSVSource) + p.pretty_export_csv_source(field1677) p.newline() - field1668 := unwrapped1665[2].(*pb.CSVConfig) - p.pretty_csv_config(field1668) + field1678 := unwrapped1675[2].(*pb.CSVConfig) + p.pretty_csv_config(field1678) p.dedent() p.write(")") } else { _dollar_dollar := msg - var _t1856 []interface{} + var _t1867 []interface{} if int64(len(_dollar_dollar.GetDataColumns())) != 0 { - _t1857 := p.deconstruct_export_csv_config(_dollar_dollar) - _t1856 = []interface{}{_dollar_dollar.GetPath(), _dollar_dollar.GetDataColumns(), _t1857} + _t1868 := p.deconstruct_export_csv_config(_dollar_dollar) + _t1867 = []interface{}{_dollar_dollar.GetPath(), _dollar_dollar.GetDataColumns(), _t1868} } - deconstruct_result1659 := _t1856 - if deconstruct_result1659 != nil { - unwrapped1660 := deconstruct_result1659 + deconstruct_result1669 := _t1867 + if deconstruct_result1669 != nil { + unwrapped1670 := deconstruct_result1669 p.write("(") p.write("export_csv_config") p.indentSexp() p.newline() - field1661 := unwrapped1660[0].(string) - p.pretty_export_csv_path(field1661) + field1671 := unwrapped1670[0].(string) + p.pretty_export_csv_path(field1671) p.newline() - field1662 := unwrapped1660[1].([]*pb.ExportCSVColumn) - p.pretty_export_csv_columns_list(field1662) + field1672 := unwrapped1670[1].([]*pb.ExportCSVColumn) + p.pretty_export_csv_columns_list(field1672) p.newline() - field1663 := unwrapped1660[2].([][]interface{}) - p.pretty_config_dict(field1663) + field1673 := unwrapped1670[2].([][]interface{}) + p.pretty_config_dict(field1673) p.dedent() p.write(")") } else { @@ -5134,40 +5165,40 @@ func (p *PrettyPrinter) pretty_export_csv_config(msg *pb.ExportCSVConfig) interf } func (p *PrettyPrinter) pretty_export_csv_output_location(msg []interface{}) interface{} { - flat1674 := p.tryFlat(msg, func() { p.pretty_export_csv_output_location(msg) }) - if flat1674 != nil { - p.write(*flat1674) + flat1684 := p.tryFlat(msg, func() { p.pretty_export_csv_output_location(msg) }) + if flat1684 != nil { + p.write(*flat1684) return nil } else { _dollar_dollar := msg - var _t1858 *string + var _t1869 *string if _dollar_dollar[0].(string) != "" { - _t1858 = ptr(_dollar_dollar[0].(string)) + _t1869 = ptr(_dollar_dollar[0].(string)) } - deconstruct_result1672 := _t1858 - if deconstruct_result1672 != nil { - unwrapped1673 := *deconstruct_result1672 + deconstruct_result1682 := _t1869 + if deconstruct_result1682 != nil { + unwrapped1683 := *deconstruct_result1682 p.write("(") p.write("path") p.indentSexp() p.newline() - p.write(p.formatStringValue(unwrapped1673)) + p.write(p.formatStringValue(unwrapped1683)) p.dedent() p.write(")") } else { _dollar_dollar := msg - var _t1859 *string + var _t1870 *string if _dollar_dollar[1].(string) != "" { - _t1859 = ptr(_dollar_dollar[1].(string)) + _t1870 = ptr(_dollar_dollar[1].(string)) } - deconstruct_result1670 := _t1859 - if deconstruct_result1670 != nil { - unwrapped1671 := *deconstruct_result1670 + deconstruct_result1680 := _t1870 + if deconstruct_result1680 != nil { + unwrapped1681 := *deconstruct_result1680 p.write("(") p.write("transaction_output_name") p.indentSexp() p.newline() - p.pretty_name(unwrapped1671) + p.pretty_name(unwrapped1681) p.dedent() p.write(")") } else { @@ -5179,47 +5210,47 @@ func (p *PrettyPrinter) pretty_export_csv_output_location(msg []interface{}) int } func (p *PrettyPrinter) pretty_export_csv_source(msg *pb.ExportCSVSource) interface{} { - flat1681 := p.tryFlat(msg, func() { p.pretty_export_csv_source(msg) }) - if flat1681 != nil { - p.write(*flat1681) + flat1691 := p.tryFlat(msg, func() { p.pretty_export_csv_source(msg) }) + if flat1691 != nil { + p.write(*flat1691) return nil } else { _dollar_dollar := msg - var _t1860 []*pb.ExportCSVColumn + var _t1871 []*pb.ExportCSVColumn if hasProtoField(_dollar_dollar, "gnf_columns") { - _t1860 = _dollar_dollar.GetGnfColumns().GetColumns() + _t1871 = _dollar_dollar.GetGnfColumns().GetColumns() } - deconstruct_result1677 := _t1860 - if deconstruct_result1677 != nil { - unwrapped1678 := deconstruct_result1677 + deconstruct_result1687 := _t1871 + if deconstruct_result1687 != nil { + unwrapped1688 := deconstruct_result1687 p.write("(") p.write("gnf_columns") p.indentSexp() - if !(len(unwrapped1678) == 0) { + if !(len(unwrapped1688) == 0) { p.newline() - for i1680, elem1679 := range unwrapped1678 { - if (i1680 > 0) { + for i1690, elem1689 := range unwrapped1688 { + if (i1690 > 0) { p.newline() } - p.pretty_export_csv_column(elem1679) + p.pretty_export_csv_column(elem1689) } } p.dedent() p.write(")") } else { _dollar_dollar := msg - var _t1861 *pb.RelationId + var _t1872 *pb.RelationId if hasProtoField(_dollar_dollar, "table_def") { - _t1861 = _dollar_dollar.GetTableDef() + _t1872 = _dollar_dollar.GetTableDef() } - deconstruct_result1675 := _t1861 - if deconstruct_result1675 != nil { - unwrapped1676 := deconstruct_result1675 + deconstruct_result1685 := _t1872 + if deconstruct_result1685 != nil { + unwrapped1686 := deconstruct_result1685 p.write("(") p.write("table_def") p.indentSexp() p.newline() - p.pretty_relation_id(unwrapped1676) + p.pretty_relation_id(unwrapped1686) p.dedent() p.write(")") } else { @@ -5231,23 +5262,23 @@ func (p *PrettyPrinter) pretty_export_csv_source(msg *pb.ExportCSVSource) interf } func (p *PrettyPrinter) pretty_export_csv_column(msg *pb.ExportCSVColumn) interface{} { - flat1686 := p.tryFlat(msg, func() { p.pretty_export_csv_column(msg) }) - if flat1686 != nil { - p.write(*flat1686) + flat1696 := p.tryFlat(msg, func() { p.pretty_export_csv_column(msg) }) + if flat1696 != nil { + p.write(*flat1696) return nil } else { _dollar_dollar := msg - fields1682 := []interface{}{_dollar_dollar.GetColumnName(), _dollar_dollar.GetColumnData()} - unwrapped_fields1683 := fields1682 + fields1692 := []interface{}{_dollar_dollar.GetColumnName(), _dollar_dollar.GetColumnData()} + unwrapped_fields1693 := fields1692 p.write("(") p.write("column") p.indentSexp() p.newline() - field1684 := unwrapped_fields1683[0].(string) - p.write(p.formatStringValue(field1684)) + field1694 := unwrapped_fields1693[0].(string) + p.write(p.formatStringValue(field1694)) p.newline() - field1685 := unwrapped_fields1683[1].(*pb.RelationId) - p.pretty_relation_id(field1685) + field1695 := unwrapped_fields1693[1].(*pb.RelationId) + p.pretty_relation_id(field1695) p.dedent() p.write(")") } @@ -5255,17 +5286,17 @@ func (p *PrettyPrinter) pretty_export_csv_column(msg *pb.ExportCSVColumn) interf } func (p *PrettyPrinter) pretty_export_csv_path(msg string) interface{} { - flat1688 := p.tryFlat(msg, func() { p.pretty_export_csv_path(msg) }) - if flat1688 != nil { - p.write(*flat1688) + flat1698 := p.tryFlat(msg, func() { p.pretty_export_csv_path(msg) }) + if flat1698 != nil { + p.write(*flat1698) return nil } else { - fields1687 := msg + fields1697 := msg p.write("(") p.write("path") p.indentSexp() p.newline() - p.write(p.formatStringValue(fields1687)) + p.write(p.formatStringValue(fields1697)) p.dedent() p.write(")") } @@ -5273,22 +5304,22 @@ func (p *PrettyPrinter) pretty_export_csv_path(msg string) interface{} { } func (p *PrettyPrinter) pretty_export_csv_columns_list(msg []*pb.ExportCSVColumn) interface{} { - flat1692 := p.tryFlat(msg, func() { p.pretty_export_csv_columns_list(msg) }) - if flat1692 != nil { - p.write(*flat1692) + flat1702 := p.tryFlat(msg, func() { p.pretty_export_csv_columns_list(msg) }) + if flat1702 != nil { + p.write(*flat1702) return nil } else { - fields1689 := msg + fields1699 := msg p.write("(") p.write("columns") p.indentSexp() - if !(len(fields1689) == 0) { + if !(len(fields1699) == 0) { p.newline() - for i1691, elem1690 := range fields1689 { - if (i1691 > 0) { + for i1701, elem1700 := range fields1699 { + if (i1701 > 0) { p.newline() } - p.pretty_export_csv_column(elem1690) + p.pretty_export_csv_column(elem1700) } } p.dedent() @@ -5298,35 +5329,35 @@ func (p *PrettyPrinter) pretty_export_csv_columns_list(msg []*pb.ExportCSVColumn } func (p *PrettyPrinter) pretty_export_iceberg_config(msg *pb.ExportIcebergConfig) interface{} { - flat1701 := p.tryFlat(msg, func() { p.pretty_export_iceberg_config(msg) }) - if flat1701 != nil { - p.write(*flat1701) + flat1711 := p.tryFlat(msg, func() { p.pretty_export_iceberg_config(msg) }) + if flat1711 != nil { + p.write(*flat1711) return nil } else { _dollar_dollar := msg - _t1862 := p.deconstruct_export_iceberg_config_optional(_dollar_dollar) - fields1693 := []interface{}{_dollar_dollar.GetLocator(), _dollar_dollar.GetConfig(), _dollar_dollar.GetTableDef(), dictToPairs(_dollar_dollar.GetTableProperties()), _t1862} - unwrapped_fields1694 := fields1693 + _t1873 := p.deconstruct_export_iceberg_config_optional(_dollar_dollar) + fields1703 := []interface{}{_dollar_dollar.GetLocator(), _dollar_dollar.GetConfig(), _dollar_dollar.GetTableDef(), dictToPairs(_dollar_dollar.GetTableProperties()), _t1873} + unwrapped_fields1704 := fields1703 p.write("(") p.write("export_iceberg_config") p.indentSexp() p.newline() - field1695 := unwrapped_fields1694[0].(*pb.IcebergLocator) - p.pretty_iceberg_locator(field1695) + field1705 := unwrapped_fields1704[0].(*pb.IcebergLocator) + p.pretty_iceberg_locator(field1705) p.newline() - field1696 := unwrapped_fields1694[1].(*pb.IcebergCatalogConfig) - p.pretty_iceberg_catalog_config(field1696) + field1706 := unwrapped_fields1704[1].(*pb.IcebergCatalogConfig) + p.pretty_iceberg_catalog_config(field1706) p.newline() - field1697 := unwrapped_fields1694[2].(*pb.RelationId) - p.pretty_export_iceberg_table_def(field1697) + field1707 := unwrapped_fields1704[2].(*pb.RelationId) + p.pretty_export_iceberg_table_def(field1707) p.newline() - field1698 := unwrapped_fields1694[3].([][]interface{}) - p.pretty_iceberg_table_properties(field1698) - field1699 := unwrapped_fields1694[4].([][]interface{}) - if field1699 != nil { + field1708 := unwrapped_fields1704[3].([][]interface{}) + p.pretty_iceberg_table_properties(field1708) + field1709 := unwrapped_fields1704[4].([][]interface{}) + if field1709 != nil { p.newline() - opt_val1700 := field1699 - p.pretty_config_dict(opt_val1700) + opt_val1710 := field1709 + p.pretty_config_dict(opt_val1710) } p.dedent() p.write(")") @@ -5335,17 +5366,17 @@ func (p *PrettyPrinter) pretty_export_iceberg_config(msg *pb.ExportIcebergConfig } func (p *PrettyPrinter) pretty_export_iceberg_table_def(msg *pb.RelationId) interface{} { - flat1703 := p.tryFlat(msg, func() { p.pretty_export_iceberg_table_def(msg) }) - if flat1703 != nil { - p.write(*flat1703) + flat1713 := p.tryFlat(msg, func() { p.pretty_export_iceberg_table_def(msg) }) + if flat1713 != nil { + p.write(*flat1713) return nil } else { - fields1702 := msg + fields1712 := msg p.write("(") p.write("table_def") p.indentSexp() p.newline() - p.pretty_relation_id(fields1702) + p.pretty_relation_id(fields1712) p.dedent() p.write(")") } @@ -5353,22 +5384,22 @@ func (p *PrettyPrinter) pretty_export_iceberg_table_def(msg *pb.RelationId) inte } func (p *PrettyPrinter) pretty_iceberg_table_properties(msg [][]interface{}) interface{} { - flat1707 := p.tryFlat(msg, func() { p.pretty_iceberg_table_properties(msg) }) - if flat1707 != nil { - p.write(*flat1707) + flat1717 := p.tryFlat(msg, func() { p.pretty_iceberg_table_properties(msg) }) + if flat1717 != nil { + p.write(*flat1717) return nil } else { - fields1704 := msg + fields1714 := msg p.write("(") p.write("table_properties") p.indentSexp() - if !(len(fields1704) == 0) { + if !(len(fields1714) == 0) { p.newline() - for i1706, elem1705 := range fields1704 { - if (i1706 > 0) { + for i1716, elem1715 := range fields1714 { + if (i1716 > 0) { p.newline() } - p.pretty_iceberg_property_entry(elem1705) + p.pretty_iceberg_property_entry(elem1715) } } p.dedent() @@ -5386,8 +5417,8 @@ func (p *PrettyPrinter) pretty_debug_info(msg *pb.DebugInfo) interface{} { for _idx, _rid := range msg.GetIds() { p.newline() p.write("(") - _t1917 := &pb.UInt128Value{Low: _rid.GetIdLow(), High: _rid.GetIdHigh()} - p.pprintDispatch(_t1917) + _t1928 := &pb.UInt128Value{Low: _rid.GetIdLow(), High: _rid.GetIdHigh()} + p.pprintDispatch(_t1928) p.write(" ") p.write(p.formatStringValue(msg.GetOrigNames()[_idx])) p.write(")") @@ -5687,6 +5718,8 @@ func (p *PrettyPrinter) pprintDispatch(msg interface{}) { p.pretty_float32_type(m) case *pb.UInt32Type: p.pretty_uint32_type(m) + case *pb.FixedType: + p.pretty_fixed_type(m) case []*pb.Binding: p.pretty_value_bindings(m) case *pb.Formula: diff --git a/sdks/julia/LogicalQueryProtocol.jl/src/LogicalQueryProtocol.jl b/sdks/julia/LogicalQueryProtocol.jl/src/LogicalQueryProtocol.jl index 7218a1cb..d12e5aba 100644 --- a/sdks/julia/LogicalQueryProtocol.jl/src/LogicalQueryProtocol.jl +++ b/sdks/julia/LogicalQueryProtocol.jl/src/LogicalQueryProtocol.jl @@ -16,7 +16,7 @@ const LQPInstruction = Union{Assign,Break,Upsert,MonoidDef,MonusDef} const LQPSyntax = Union{ DateTimeType,RelationId,Var,FloatType,UInt128Type,OrMonoid,Int128Type, - DecimalType,UnspecifiedType,DateType,UInt128Value,MissingType,MissingValue, + DecimalType,FixedType,UnspecifiedType,DateType,UInt128Value,MissingType,MissingValue, IntType,BooleanType,Int128Value,StringType,var"#Type",Value,MinMonoid,SumMonoid, MaxMonoid,Binding,Attribute,Term,Monoid,Cast,Pragma,Atom,RelTerm,Primitive, RelAtom,Abstraction,Algorithm,Assign,Break,Conjunction,Def,Disjunction, diff --git a/sdks/julia/LogicalQueryProtocol.jl/src/equality.jl b/sdks/julia/LogicalQueryProtocol.jl/src/equality.jl index 63855e2a..6cb5a17f 100644 --- a/sdks/julia/LogicalQueryProtocol.jl/src/equality.jl +++ b/sdks/julia/LogicalQueryProtocol.jl/src/equality.jl @@ -73,6 +73,11 @@ Base.:(==)(a::DecimalType, b::DecimalType) = a.precision == b.precision && a.sca Base.hash(a::DecimalType, h::UInt) = hash(a.scale, hash(a.precision, h)) Base.isequal(a::DecimalType, b::DecimalType) = isequal(a.precision, b.precision) && isequal(a.scale, b.scale) +# FixedType +Base.:(==)(a::FixedType, b::FixedType) = a.length == b.length +Base.hash(a::FixedType, h::UInt) = hash(a.length, hash(:FixedType, h)) +Base.isequal(a::FixedType, b::FixedType) = isequal(a.length, b.length) + # Int128Value Base.:(==)(a::Int128Value, b::Int128Value) = a.low == b.low && a.high == b.high Base.hash(a::Int128Value, h::UInt) = hash(a.high, hash(a.low, h)) diff --git a/sdks/julia/LogicalQueryProtocol.jl/src/gen/relationalai/lqp/v1/logic_pb.jl b/sdks/julia/LogicalQueryProtocol.jl/src/gen/relationalai/lqp/v1/logic_pb.jl index 3c092dea..d9c7d0ce 100644 --- a/sdks/julia/LogicalQueryProtocol.jl/src/gen/relationalai/lqp/v1/logic_pb.jl +++ b/sdks/julia/LogicalQueryProtocol.jl/src/gen/relationalai/lqp/v1/logic_pb.jl @@ -9,12 +9,12 @@ export DateTimeType, RelationId, Var, FloatType, IcebergCatalogConfig, UInt128Ty export Int32Type, Float32Type, BeTreeConfig, DateTimeValue, IcebergLocator, DateValue export OrMonoid, CSVLocator, Int128Type, DecimalType, UnspecifiedType, DateType export MissingType, MissingValue, IntType, StringType, Int128Value, UInt128Value -export StorageIntegration, BooleanType, UInt32Type, DecimalValue, BeTreeLocator, CSVConfig -export var"#Type", Value, NamedColumn, GNFColumn, MinMonoid, SumMonoid, MaxMonoid -export BeTreeInfo, Binding, EDB, Attribute, Term, TargetRelation, IcebergData, Monoid -export BeTreeRelation, Cast, Pragma, Atom, RelTerm, CDCTargets, PlainTargets, Primitive -export RelAtom, TargetRelations, CSVData, Data, Abstraction, Algorithm, Assign, Break -export Conjunction, Constraint, Def, Disjunction, Exists, FFI, FunctionalDependency +export StorageIntegration, BooleanType, FixedType, UInt32Type, DecimalValue, BeTreeLocator +export CSVConfig, var"#Type", Value, NamedColumn, GNFColumn, MinMonoid, SumMonoid +export MaxMonoid, BeTreeInfo, Binding, EDB, Attribute, Term, TargetRelation, IcebergData +export Monoid, BeTreeRelation, Cast, Pragma, Atom, RelTerm, CDCTargets, PlainTargets +export Primitive, RelAtom, TargetRelations, CSVData, Data, Abstraction, Algorithm, Assign +export Break, Conjunction, Constraint, Def, Disjunction, Exists, FFI, FunctionalDependency export MonoidDef, MonusDef, Not, Reduce, Script, Upsert, Construct, Loop, Declaration export Instruction, Formula abstract type var"##Abstract#Abstraction" end @@ -829,6 +829,37 @@ function PB._encoded_size(x::BooleanType) return encoded_size end +struct FixedType + length::Int32 +end +FixedType(;length = zero(Int32)) = FixedType(length) +PB.default_values(::Type{FixedType}) = (;length = zero(Int32)) +PB.field_numbers(::Type{FixedType}) = (;length = 1) + +function PB.decode(d::PB.AbstractProtoDecoder, ::Type{<:FixedType}, _endpos::Int=0, _group::Bool=false) + length = zero(Int32) + while !PB.message_done(d, _endpos, _group) + field_number, wire_type = PB.decode_tag(d) + if field_number == 1 + length = PB.decode(d, Int32) + else + Base.skip(d, wire_type) + end + end + return FixedType(length) +end + +function PB.encode(e::PB.AbstractProtoEncoder, x::FixedType) + initpos = position(e.io) + x.length != zero(Int32) && PB.encode(e, 1, x.length) + return position(e.io) - initpos +end +function PB._encoded_size(x::FixedType) + encoded_size = 0 + x.length != zero(Int32) && (encoded_size += PB._encoded_size(x.length, 1)) + return encoded_size +end + struct UInt32Type end function PB.decode(d::PB.AbstractProtoDecoder, ::Type{<:UInt32Type}, _endpos::Int=0, _group::Bool=false) @@ -1053,14 +1084,14 @@ function PB._encoded_size(x::CSVConfig) end struct var"#Type" - var"#type"::Union{Nothing,OneOf{<:Union{UnspecifiedType,StringType,IntType,FloatType,UInt128Type,Int128Type,DateType,DateTimeType,MissingType,DecimalType,BooleanType,Int32Type,Float32Type,UInt32Type}}} + var"#type"::Union{Nothing,OneOf{<:Union{UnspecifiedType,StringType,IntType,FloatType,UInt128Type,Int128Type,DateType,DateTimeType,MissingType,DecimalType,BooleanType,Int32Type,Float32Type,UInt32Type,FixedType}}} end var"#Type"(;var"#type" = nothing) = var"#Type"(var"#type") PB.oneof_field_types(::Type{var"#Type"}) = (; - var"#type" = (;unspecified_type=UnspecifiedType, string_type=StringType, int_type=IntType, float_type=FloatType, uint128_type=UInt128Type, int128_type=Int128Type, date_type=DateType, datetime_type=DateTimeType, missing_type=MissingType, decimal_type=DecimalType, boolean_type=BooleanType, int32_type=Int32Type, float32_type=Float32Type, uint32_type=UInt32Type), + var"#type" = (;unspecified_type=UnspecifiedType, string_type=StringType, int_type=IntType, float_type=FloatType, uint128_type=UInt128Type, int128_type=Int128Type, date_type=DateType, datetime_type=DateTimeType, missing_type=MissingType, decimal_type=DecimalType, boolean_type=BooleanType, int32_type=Int32Type, float32_type=Float32Type, uint32_type=UInt32Type, fixed_type=FixedType), ) -PB.default_values(::Type{var"#Type"}) = (;unspecified_type = nothing, string_type = nothing, int_type = nothing, float_type = nothing, uint128_type = nothing, int128_type = nothing, date_type = nothing, datetime_type = nothing, missing_type = nothing, decimal_type = nothing, boolean_type = nothing, int32_type = nothing, float32_type = nothing, uint32_type = nothing) -PB.field_numbers(::Type{var"#Type"}) = (;unspecified_type = 1, string_type = 2, int_type = 3, float_type = 4, uint128_type = 5, int128_type = 6, date_type = 7, datetime_type = 8, missing_type = 9, decimal_type = 10, boolean_type = 11, int32_type = 12, float32_type = 13, uint32_type = 14) +PB.default_values(::Type{var"#Type"}) = (;unspecified_type = nothing, string_type = nothing, int_type = nothing, float_type = nothing, uint128_type = nothing, int128_type = nothing, date_type = nothing, datetime_type = nothing, missing_type = nothing, decimal_type = nothing, boolean_type = nothing, int32_type = nothing, float32_type = nothing, uint32_type = nothing, fixed_type = nothing) +PB.field_numbers(::Type{var"#Type"}) = (;unspecified_type = 1, string_type = 2, int_type = 3, float_type = 4, uint128_type = 5, int128_type = 6, date_type = 7, datetime_type = 8, missing_type = 9, decimal_type = 10, boolean_type = 11, int32_type = 12, float32_type = 13, uint32_type = 14, fixed_type = 15) function PB.decode(d::PB.AbstractProtoDecoder, ::Type{<:var"#Type"}, _endpos::Int=0, _group::Bool=false) var"#type" = nothing @@ -1094,6 +1125,8 @@ function PB.decode(d::PB.AbstractProtoDecoder, ::Type{<:var"#Type"}, _endpos::In var"#type" = OneOf(:float32_type, PB.decode(d, Ref{Float32Type})) elseif field_number == 14 var"#type" = OneOf(:uint32_type, PB.decode(d, Ref{UInt32Type})) + elseif field_number == 15 + var"#type" = OneOf(:fixed_type, PB.decode(d, Ref{FixedType})) else Base.skip(d, wire_type) end @@ -1132,6 +1165,8 @@ function PB.encode(e::PB.AbstractProtoEncoder, x::var"#Type") PB.encode(e, 13, x.var"#type"[]::Float32Type) elseif x.var"#type".name === :uint32_type PB.encode(e, 14, x.var"#type"[]::UInt32Type) + elseif x.var"#type".name === :fixed_type + PB.encode(e, 15, x.var"#type"[]::FixedType) end return position(e.io) - initpos end @@ -1166,6 +1201,8 @@ function PB._encoded_size(x::var"#Type") encoded_size += PB._encoded_size(x.var"#type"[]::Float32Type, 13) elseif x.var"#type".name === :uint32_type encoded_size += PB._encoded_size(x.var"#type"[]::UInt32Type, 14) + elseif x.var"#type".name === :fixed_type + encoded_size += PB._encoded_size(x.var"#type"[]::FixedType, 15) end return encoded_size end diff --git a/sdks/julia/LogicalQueryProtocol.jl/src/parser.jl b/sdks/julia/LogicalQueryProtocol.jl/src/parser.jl index 31e7c602..4d9d0987 100644 --- a/sdks/julia/LogicalQueryProtocol.jl/src/parser.jl +++ b/sdks/julia/LogicalQueryProtocol.jl/src/parser.jl @@ -372,12 +372,12 @@ function _extract_value_int32(parser::ParserState, value::Union{Nothing, Proto.V if isnothing(value) return Int32(default) else - _t2219 = nothing + _t2233 = nothing end if _has_proto_field(value, Symbol("int32_value")) return _get_oneof_field(value, :int32_value) else - _t2220 = nothing + _t2234 = nothing end throw(ParseError("expected an int32 value (e.g. `1i32`) for this config field")) end @@ -386,7 +386,7 @@ function _extract_value_int64(parser::ParserState, value::Union{Nothing, Proto.V if (!isnothing(value) && _has_proto_field(value, Symbol("int_value"))) return _get_oneof_field(value, :int_value) else - _t2221 = nothing + _t2235 = nothing end return default end @@ -395,7 +395,7 @@ function _extract_value_string(parser::ParserState, value::Union{Nothing, Proto. if (!isnothing(value) && _has_proto_field(value, Symbol("string_value"))) return _get_oneof_field(value, :string_value) else - _t2222 = nothing + _t2236 = nothing end return default end @@ -404,7 +404,7 @@ function _extract_value_boolean(parser::ParserState, value::Union{Nothing, Proto if (!isnothing(value) && _has_proto_field(value, Symbol("boolean_value"))) return _get_oneof_field(value, :boolean_value) else - _t2223 = nothing + _t2237 = nothing end return default end @@ -413,7 +413,7 @@ function _extract_value_string_list(parser::ParserState, value::Union{Nothing, P if (!isnothing(value) && _has_proto_field(value, Symbol("string_value"))) return String[_get_oneof_field(value, :string_value)] else - _t2224 = nothing + _t2238 = nothing end return default end @@ -422,7 +422,7 @@ function _try_extract_value_int64(parser::ParserState, value::Union{Nothing, Pro if (!isnothing(value) && _has_proto_field(value, Symbol("int_value"))) return _get_oneof_field(value, :int_value) else - _t2225 = nothing + _t2239 = nothing end return nothing end @@ -431,7 +431,7 @@ function _try_extract_value_float64(parser::ParserState, value::Union{Nothing, P if (!isnothing(value) && _has_proto_field(value, Symbol("float_value"))) return _get_oneof_field(value, :float_value) else - _t2226 = nothing + _t2240 = nothing end return nothing end @@ -440,7 +440,7 @@ function _try_extract_value_bytes(parser::ParserState, value::Union{Nothing, Pro if (!isnothing(value) && _has_proto_field(value, Symbol("string_value"))) return Vector{UInt8}(_get_oneof_field(value, :string_value)) else - _t2227 = nothing + _t2241 = nothing end return nothing end @@ -449,118 +449,118 @@ function _try_extract_value_uint128(parser::ParserState, value::Union{Nothing, P if (!isnothing(value) && _has_proto_field(value, Symbol("uint128_value"))) return _get_oneof_field(value, :uint128_value) else - _t2228 = nothing + _t2242 = nothing end return nothing end function construct_non_cdc_relations(parser::ParserState, targets::Vector{Proto.TargetRelation})::Proto.TargetRelations - _t2229 = Proto.PlainTargets(targets=targets) - _t2230 = Proto.TargetRelations(body=OneOf(:plain, _t2229), keys=Proto.NamedColumn[]) - return _t2230 + _t2243 = Proto.PlainTargets(targets=targets) + _t2244 = Proto.TargetRelations(body=OneOf(:plain, _t2243), keys=Proto.NamedColumn[]) + return _t2244 end function construct_cdc_relations(parser::ParserState, inserts::Vector{Proto.TargetRelation}, deletes::Vector{Proto.TargetRelation})::Proto.TargetRelations - _t2231 = Proto.CDCTargets(inserts=inserts, deletes=deletes) - _t2232 = Proto.TargetRelations(body=OneOf(:cdc, _t2231), keys=Proto.NamedColumn[]) - return _t2232 + _t2245 = Proto.CDCTargets(inserts=inserts, deletes=deletes) + _t2246 = Proto.TargetRelations(body=OneOf(:cdc, _t2245), keys=Proto.NamedColumn[]) + return _t2246 end function construct_relations(parser::ParserState, keys::Tuple{Vector{Proto.NamedColumn}, Bool}, body::Proto.TargetRelations, load_errors_opt::Union{Nothing, Proto.RelationId})::Proto.TargetRelations if _has_proto_field(body, Symbol("plain")) - _t2234 = Proto.TargetRelations(body=OneOf(:plain, _get_oneof_field(body, :plain)), keys=keys[1], synthetic_key=keys[2], load_errors=load_errors_opt) - return _t2234 + _t2248 = Proto.TargetRelations(body=OneOf(:plain, _get_oneof_field(body, :plain)), keys=keys[1], synthetic_key=keys[2], load_errors=load_errors_opt) + return _t2248 else - _t2233 = nothing + _t2247 = nothing end - _t2235 = Proto.TargetRelations(body=OneOf(:cdc, _get_oneof_field(body, :cdc)), keys=keys[1], synthetic_key=keys[2], load_errors=load_errors_opt) - return _t2235 + _t2249 = Proto.TargetRelations(body=OneOf(:cdc, _get_oneof_field(body, :cdc)), keys=keys[1], synthetic_key=keys[2], load_errors=load_errors_opt) + return _t2249 end function construct_csv_data(parser::ParserState, locator::Proto.CSVLocator, config::Proto.CSVConfig, columns_opt::Union{Nothing, Vector{Proto.GNFColumn}}, relations_opt::Union{Nothing, Proto.TargetRelations}, asof::String)::Proto.CSVData - _t2236 = Proto.CSVData(locator=locator, config=config, columns=(!isnothing(columns_opt) ? columns_opt : Proto.GNFColumn[]), asof=asof, relations=relations_opt) - return _t2236 + _t2250 = Proto.CSVData(locator=locator, config=config, columns=(!isnothing(columns_opt) ? columns_opt : Proto.GNFColumn[]), asof=asof, relations=relations_opt) + return _t2250 end function construct_csv_config(parser::ParserState, config_dict::Vector{Tuple{String, Proto.Value}}, storage_integration_opt::Union{Nothing, Vector{Tuple{String, Proto.Value}}})::Proto.CSVConfig config = Dict(config_dict) - _t2237 = _extract_value_int32(parser, get(config, "csv_header_row", nothing), 1) - header_row = _t2237 - _t2238 = _extract_value_int64(parser, get(config, "csv_skip", nothing), 0) - skip = _t2238 - _t2239 = _extract_value_string(parser, get(config, "csv_new_line", nothing), "") - new_line = _t2239 - _t2240 = _extract_value_string(parser, get(config, "csv_delimiter", nothing), ",") - delimiter = _t2240 - _t2241 = _extract_value_string(parser, get(config, "csv_quotechar", nothing), "\"") - quotechar = _t2241 - _t2242 = _extract_value_string(parser, get(config, "csv_escapechar", nothing), "\"") - escapechar = _t2242 - _t2243 = _extract_value_string(parser, get(config, "csv_comment", nothing), "") - comment = _t2243 - _t2244 = _extract_value_string_list(parser, get(config, "csv_missing_strings", nothing), String[]) - missing_strings = _t2244 - _t2245 = _extract_value_string(parser, get(config, "csv_decimal_separator", nothing), ".") - decimal_separator = _t2245 - _t2246 = _extract_value_string(parser, get(config, "csv_encoding", nothing), "utf-8") - encoding = _t2246 - _t2247 = _extract_value_string(parser, get(config, "csv_compression", nothing), "") - compression = _t2247 - _t2248 = _extract_value_int64(parser, get(config, "csv_partition_size_mb", nothing), 0) - partition_size_mb = _t2248 - _t2249 = construct_csv_storage_integration(parser, storage_integration_opt) - storage_integration = _t2249 - _t2250 = Proto.CSVConfig(header_row=header_row, skip=skip, new_line=new_line, delimiter=delimiter, quotechar=quotechar, escapechar=escapechar, comment=comment, missing_strings=missing_strings, decimal_separator=decimal_separator, encoding=encoding, compression=compression, partition_size_mb=partition_size_mb, storage_integration=storage_integration) - return _t2250 + _t2251 = _extract_value_int32(parser, get(config, "csv_header_row", nothing), 1) + header_row = _t2251 + _t2252 = _extract_value_int64(parser, get(config, "csv_skip", nothing), 0) + skip = _t2252 + _t2253 = _extract_value_string(parser, get(config, "csv_new_line", nothing), "") + new_line = _t2253 + _t2254 = _extract_value_string(parser, get(config, "csv_delimiter", nothing), ",") + delimiter = _t2254 + _t2255 = _extract_value_string(parser, get(config, "csv_quotechar", nothing), "\"") + quotechar = _t2255 + _t2256 = _extract_value_string(parser, get(config, "csv_escapechar", nothing), "\"") + escapechar = _t2256 + _t2257 = _extract_value_string(parser, get(config, "csv_comment", nothing), "") + comment = _t2257 + _t2258 = _extract_value_string_list(parser, get(config, "csv_missing_strings", nothing), String[]) + missing_strings = _t2258 + _t2259 = _extract_value_string(parser, get(config, "csv_decimal_separator", nothing), ".") + decimal_separator = _t2259 + _t2260 = _extract_value_string(parser, get(config, "csv_encoding", nothing), "utf-8") + encoding = _t2260 + _t2261 = _extract_value_string(parser, get(config, "csv_compression", nothing), "") + compression = _t2261 + _t2262 = _extract_value_int64(parser, get(config, "csv_partition_size_mb", nothing), 0) + partition_size_mb = _t2262 + _t2263 = construct_csv_storage_integration(parser, storage_integration_opt) + storage_integration = _t2263 + _t2264 = Proto.CSVConfig(header_row=header_row, skip=skip, new_line=new_line, delimiter=delimiter, quotechar=quotechar, escapechar=escapechar, comment=comment, missing_strings=missing_strings, decimal_separator=decimal_separator, encoding=encoding, compression=compression, partition_size_mb=partition_size_mb, storage_integration=storage_integration) + return _t2264 end function construct_csv_storage_integration(parser::ParserState, storage_integration_opt::Union{Nothing, Vector{Tuple{String, Proto.Value}}})::Union{Nothing, Proto.StorageIntegration} if isnothing(storage_integration_opt) return nothing else - _t2251 = nothing + _t2265 = nothing end config = Dict(storage_integration_opt) - _t2252 = _extract_value_string(parser, get(config, "provider", nothing), "") - _t2253 = _extract_value_string(parser, get(config, "azure_sas_token", nothing), "") - _t2254 = _extract_value_string(parser, get(config, "s3_region", nothing), "") - _t2255 = _extract_value_string(parser, get(config, "s3_access_key_id", nothing), "") - _t2256 = _extract_value_string(parser, get(config, "s3_secret_access_key", nothing), "") - _t2257 = Proto.StorageIntegration(provider=_t2252, azure_sas_token=_t2253, s3_region=_t2254, s3_access_key_id=_t2255, s3_secret_access_key=_t2256) - return _t2257 + _t2266 = _extract_value_string(parser, get(config, "provider", nothing), "") + _t2267 = _extract_value_string(parser, get(config, "azure_sas_token", nothing), "") + _t2268 = _extract_value_string(parser, get(config, "s3_region", nothing), "") + _t2269 = _extract_value_string(parser, get(config, "s3_access_key_id", nothing), "") + _t2270 = _extract_value_string(parser, get(config, "s3_secret_access_key", nothing), "") + _t2271 = Proto.StorageIntegration(provider=_t2266, azure_sas_token=_t2267, s3_region=_t2268, s3_access_key_id=_t2269, s3_secret_access_key=_t2270) + return _t2271 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) - _t2258 = _try_extract_value_float64(parser, get(config, "betree_config_epsilon", nothing)) - epsilon = _t2258 - _t2259 = _try_extract_value_int64(parser, get(config, "betree_config_max_pivots", nothing)) - max_pivots = _t2259 - _t2260 = _try_extract_value_int64(parser, get(config, "betree_config_max_deltas", nothing)) - max_deltas = _t2260 - _t2261 = _try_extract_value_int64(parser, get(config, "betree_config_max_leaf", nothing)) - max_leaf = _t2261 - _t2262 = Proto.BeTreeConfig(epsilon=epsilon, max_pivots=max_pivots, max_deltas=max_deltas, max_leaf=max_leaf) - storage_config = _t2262 - _t2263 = _try_extract_value_uint128(parser, get(config, "betree_locator_root_pageid", nothing)) - root_pageid = _t2263 - _t2264 = _try_extract_value_bytes(parser, get(config, "betree_locator_inline_data", nothing)) - inline_data = _t2264 - _t2265 = _try_extract_value_int64(parser, get(config, "betree_locator_element_count", nothing)) - element_count = _t2265 - _t2266 = _try_extract_value_int64(parser, get(config, "betree_locator_tree_height", nothing)) - tree_height = _t2266 - _t2267 = 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 = _t2267 - _t2268 = Proto.BeTreeInfo(key_types=key_types, value_types=value_types, storage_config=storage_config, relation_locator=relation_locator) - return _t2268 + _t2272 = _try_extract_value_float64(parser, get(config, "betree_config_epsilon", nothing)) + epsilon = _t2272 + _t2273 = _try_extract_value_int64(parser, get(config, "betree_config_max_pivots", nothing)) + max_pivots = _t2273 + _t2274 = _try_extract_value_int64(parser, get(config, "betree_config_max_deltas", nothing)) + max_deltas = _t2274 + _t2275 = _try_extract_value_int64(parser, get(config, "betree_config_max_leaf", nothing)) + max_leaf = _t2275 + _t2276 = Proto.BeTreeConfig(epsilon=epsilon, max_pivots=max_pivots, max_deltas=max_deltas, max_leaf=max_leaf) + storage_config = _t2276 + _t2277 = _try_extract_value_uint128(parser, get(config, "betree_locator_root_pageid", nothing)) + root_pageid = _t2277 + _t2278 = _try_extract_value_bytes(parser, get(config, "betree_locator_inline_data", nothing)) + inline_data = _t2278 + _t2279 = _try_extract_value_int64(parser, get(config, "betree_locator_element_count", nothing)) + element_count = _t2279 + _t2280 = _try_extract_value_int64(parser, get(config, "betree_locator_tree_height", nothing)) + tree_height = _t2280 + _t2281 = 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 = _t2281 + _t2282 = Proto.BeTreeInfo(key_types=key_types, value_types=value_types, storage_config=storage_config, relation_locator=relation_locator) + return _t2282 end function default_configure(parser::ParserState)::Proto.Configure - _t2269 = Proto.IVMConfig(level=Proto.MaintenanceLevel.MAINTENANCE_LEVEL_OFF) - ivm_config = _t2269 - _t2270 = Proto.Configure(semantics_version=0, ivm_config=ivm_config) - return _t2270 + _t2283 = Proto.IVMConfig(level=Proto.MaintenanceLevel.MAINTENANCE_LEVEL_OFF) + ivm_config = _t2283 + _t2284 = Proto.Configure(semantics_version=0, ivm_config=ivm_config) + return _t2284 end function construct_configure(parser::ParserState, config_dict::Vector{Tuple{String, Proto.Value}})::Proto.Configure @@ -582,10 +582,10 @@ function construct_configure(parser::ParserState, config_dict::Vector{Tuple{Stri end end end - _t2271 = Proto.IVMConfig(level=maintenance_level) - ivm_config = _t2271 - _t2272 = _extract_value_int64(parser, get(config, "semantics_version", nothing), 0) - semantics_version = _t2272 + _t2285 = Proto.IVMConfig(level=maintenance_level) + ivm_config = _t2285 + _t2286 = _extract_value_int64(parser, get(config, "semantics_version", nothing), 0) + semantics_version = _t2286 config_values_pairs = Tuple{String, Proto.Value}[] for pair in config_dict if (pair[1] != "semantics_version" && pair[1] != "ivm.maintenance_level") @@ -593,4114 +593,4144 @@ function construct_configure(parser::ParserState, config_dict::Vector{Tuple{Stri end end configuration_values = Dict(config_values_pairs) - _t2273 = Proto.Configure(semantics_version=semantics_version, ivm_config=ivm_config, configuration_values=configuration_values) - return _t2273 + _t2287 = Proto.Configure(semantics_version=semantics_version, ivm_config=ivm_config, configuration_values=configuration_values) + return _t2287 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) - _t2274 = _extract_value_int64(parser, get(config, "partition_size", nothing), 0) - partition_size = _t2274 - _t2275 = _extract_value_string(parser, get(config, "compression", nothing), "") - compression = _t2275 - _t2276 = _extract_value_boolean(parser, get(config, "syntax_header_row", nothing), true) - syntax_header_row = _t2276 - _t2277 = _extract_value_string(parser, get(config, "syntax_missing_string", nothing), "") - syntax_missing_string = _t2277 - _t2278 = _extract_value_string(parser, get(config, "syntax_delim", nothing), ",") - syntax_delim = _t2278 - _t2279 = _extract_value_string(parser, get(config, "syntax_quotechar", nothing), "\"") - syntax_quotechar = _t2279 - _t2280 = _extract_value_string(parser, get(config, "syntax_escapechar", nothing), "\\") - syntax_escapechar = _t2280 - _t2281 = 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 _t2281 + _t2288 = _extract_value_int64(parser, get(config, "partition_size", nothing), 0) + partition_size = _t2288 + _t2289 = _extract_value_string(parser, get(config, "compression", nothing), "") + compression = _t2289 + _t2290 = _extract_value_boolean(parser, get(config, "syntax_header_row", nothing), true) + syntax_header_row = _t2290 + _t2291 = _extract_value_string(parser, get(config, "syntax_missing_string", nothing), "") + syntax_missing_string = _t2291 + _t2292 = _extract_value_string(parser, get(config, "syntax_delim", nothing), ",") + syntax_delim = _t2292 + _t2293 = _extract_value_string(parser, get(config, "syntax_quotechar", nothing), "\"") + syntax_quotechar = _t2293 + _t2294 = _extract_value_string(parser, get(config, "syntax_escapechar", nothing), "\\") + syntax_escapechar = _t2294 + _t2295 = 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 _t2295 end function construct_export_csv_config_with_location(parser::ParserState, location::Tuple{String, String}, csv_source::Proto.ExportCSVSource, csv_config::Proto.CSVConfig)::Proto.ExportCSVConfig - _t2282 = Proto.ExportCSVConfig(path=location[1], transaction_output_name=location[2], csv_source=csv_source, csv_config=csv_config) - return _t2282 + _t2296 = Proto.ExportCSVConfig(path=location[1], transaction_output_name=location[2], csv_source=csv_source, csv_config=csv_config) + return _t2296 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) - _t2283 = Proto.IcebergCatalogConfig(catalog_uri=catalog_uri, scope=(!isnothing(scope_opt) ? scope_opt : ""), properties=props, auth_properties=auth_props) - return _t2283 + _t2297 = Proto.IcebergCatalogConfig(catalog_uri=catalog_uri, scope=(!isnothing(scope_opt) ? scope_opt : ""), properties=props, auth_properties=auth_props) + return _t2297 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 - _t2284 = 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 _t2284 + _t2298 = 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 _t2298 end function construct_export_iceberg_config_full(parser::ParserState, locator::Proto.IcebergLocator, config::Proto.IcebergCatalogConfig, table_def::Proto.RelationId, table_property_pairs::Vector{Tuple{String, String}}, config_dict::Union{Nothing, Vector{Tuple{String, Proto.Value}}})::Proto.ExportIcebergConfig cfg = Dict((!isnothing(config_dict) ? config_dict : Tuple{String, Proto.Value}[])) - _t2285 = _extract_value_string(parser, get(cfg, "prefix", nothing), "") - prefix = _t2285 - _t2286 = _extract_value_int64(parser, get(cfg, "target_file_size_bytes", nothing), 0) - target_file_size_bytes = _t2286 - _t2287 = _extract_value_string(parser, get(cfg, "compression", nothing), "") - compression = _t2287 + _t2299 = _extract_value_string(parser, get(cfg, "prefix", nothing), "") + prefix = _t2299 + _t2300 = _extract_value_int64(parser, get(cfg, "target_file_size_bytes", nothing), 0) + target_file_size_bytes = _t2300 + _t2301 = _extract_value_string(parser, get(cfg, "compression", nothing), "") + compression = _t2301 table_props = Dict(table_property_pairs) - _t2288 = Proto.ExportIcebergConfig(locator=locator, config=config, table_def=table_def, prefix=prefix, target_file_size_bytes=target_file_size_bytes, compression=compression, table_properties=table_props) - return _t2288 + _t2302 = Proto.ExportIcebergConfig(locator=locator, config=config, table_def=table_def, prefix=prefix, target_file_size_bytes=target_file_size_bytes, compression=compression, table_properties=table_props) + return _t2302 end # --- Parse functions --- function parse_transaction(parser::ParserState)::Proto.Transaction - span_start718 = span_start(parser) + span_start722 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "transaction") if (match_lookahead_literal(parser, "(", 0) && match_lookahead_literal(parser, "configure", 1)) - _t1425 = parse_configure(parser) - _t1424 = _t1425 + _t1433 = parse_configure(parser) + _t1432 = _t1433 else - _t1424 = nothing + _t1432 = nothing end - configure712 = _t1424 + configure716 = _t1432 if (match_lookahead_literal(parser, "(", 0) && match_lookahead_literal(parser, "sync", 1)) - _t1427 = parse_sync(parser) - _t1426 = _t1427 + _t1435 = parse_sync(parser) + _t1434 = _t1435 else - _t1426 = nothing - end - sync713 = _t1426 - xs714 = Proto.Epoch[] - cond715 = match_lookahead_literal(parser, "(", 0) - while cond715 - _t1428 = parse_epoch(parser) - item716 = _t1428 - push!(xs714, item716) - cond715 = match_lookahead_literal(parser, "(", 0) - end - epochs717 = xs714 + _t1434 = nothing + end + sync717 = _t1434 + xs718 = Proto.Epoch[] + cond719 = match_lookahead_literal(parser, "(", 0) + while cond719 + _t1436 = parse_epoch(parser) + item720 = _t1436 + push!(xs718, item720) + cond719 = match_lookahead_literal(parser, "(", 0) + end + epochs721 = xs718 consume_literal!(parser, ")") - _t1429 = default_configure(parser) - _t1430 = Proto.Transaction(epochs=epochs717, configure=(!isnothing(configure712) ? configure712 : _t1429), sync=sync713) - result719 = _t1430 - record_span!(parser, span_start718, "Transaction") - return result719 + _t1437 = default_configure(parser) + _t1438 = Proto.Transaction(epochs=epochs721, configure=(!isnothing(configure716) ? configure716 : _t1437), sync=sync717) + result723 = _t1438 + record_span!(parser, span_start722, "Transaction") + return result723 end function parse_configure(parser::ParserState)::Proto.Configure - span_start721 = span_start(parser) + span_start725 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "configure") - _t1431 = parse_config_dict(parser) - config_dict720 = _t1431 + _t1439 = parse_config_dict(parser) + config_dict724 = _t1439 consume_literal!(parser, ")") - _t1432 = construct_configure(parser, config_dict720) - result722 = _t1432 - record_span!(parser, span_start721, "Configure") - return result722 + _t1440 = construct_configure(parser, config_dict724) + result726 = _t1440 + record_span!(parser, span_start725, "Configure") + return result726 end function parse_config_dict(parser::ParserState)::Vector{Tuple{String, Proto.Value}} consume_literal!(parser, "{") - xs723 = Tuple{String, Proto.Value}[] - cond724 = match_lookahead_literal(parser, ":", 0) - while cond724 - _t1433 = parse_config_key_value(parser) - item725 = _t1433 - push!(xs723, item725) - cond724 = match_lookahead_literal(parser, ":", 0) - end - config_key_values726 = xs723 + xs727 = Tuple{String, Proto.Value}[] + cond728 = match_lookahead_literal(parser, ":", 0) + while cond728 + _t1441 = parse_config_key_value(parser) + item729 = _t1441 + push!(xs727, item729) + cond728 = match_lookahead_literal(parser, ":", 0) + end + config_key_values730 = xs727 consume_literal!(parser, "}") - return config_key_values726 + return config_key_values730 end function parse_config_key_value(parser::ParserState)::Tuple{String, Proto.Value} consume_literal!(parser, ":") - symbol727 = consume_terminal!(parser, "SYMBOL") - _t1434 = parse_raw_value(parser) - raw_value728 = _t1434 - return (symbol727, raw_value728,) + symbol731 = consume_terminal!(parser, "SYMBOL") + _t1442 = parse_raw_value(parser) + raw_value732 = _t1442 + return (symbol731, raw_value732,) end function parse_raw_value(parser::ParserState)::Proto.Value - span_start742 = span_start(parser) + span_start746 = span_start(parser) if match_lookahead_literal(parser, "true", 0) - _t1435 = 12 + _t1443 = 12 else if match_lookahead_literal(parser, "missing", 0) - _t1436 = 11 + _t1444 = 11 else if match_lookahead_literal(parser, "false", 0) - _t1437 = 12 + _t1445 = 12 else if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "datetime", 1) - _t1439 = 1 + _t1447 = 1 else if match_lookahead_literal(parser, "date", 1) - _t1440 = 0 + _t1448 = 0 else - _t1440 = -1 + _t1448 = -1 end - _t1439 = _t1440 + _t1447 = _t1448 end - _t1438 = _t1439 + _t1446 = _t1447 else if match_lookahead_terminal(parser, "UINT32", 0) - _t1441 = 7 + _t1449 = 7 else if match_lookahead_terminal(parser, "UINT128", 0) - _t1442 = 8 + _t1450 = 8 else if match_lookahead_terminal(parser, "STRING", 0) - _t1443 = 2 + _t1451 = 2 else if match_lookahead_terminal(parser, "INT32", 0) - _t1444 = 3 + _t1452 = 3 else if match_lookahead_terminal(parser, "INT128", 0) - _t1445 = 9 + _t1453 = 9 else if match_lookahead_terminal(parser, "INT", 0) - _t1446 = 4 + _t1454 = 4 else if match_lookahead_terminal(parser, "FLOAT32", 0) - _t1447 = 5 + _t1455 = 5 else if match_lookahead_terminal(parser, "FLOAT", 0) - _t1448 = 6 + _t1456 = 6 else if match_lookahead_terminal(parser, "DECIMAL", 0) - _t1449 = 10 + _t1457 = 10 else - _t1449 = -1 + _t1457 = -1 end - _t1448 = _t1449 + _t1456 = _t1457 end - _t1447 = _t1448 + _t1455 = _t1456 end - _t1446 = _t1447 + _t1454 = _t1455 end - _t1445 = _t1446 + _t1453 = _t1454 end - _t1444 = _t1445 + _t1452 = _t1453 end - _t1443 = _t1444 + _t1451 = _t1452 end - _t1442 = _t1443 + _t1450 = _t1451 end - _t1441 = _t1442 + _t1449 = _t1450 end - _t1438 = _t1441 + _t1446 = _t1449 end - _t1437 = _t1438 + _t1445 = _t1446 end - _t1436 = _t1437 + _t1444 = _t1445 end - _t1435 = _t1436 - end - prediction729 = _t1435 - if prediction729 == 12 - _t1451 = parse_boolean_value(parser) - boolean_value741 = _t1451 - _t1452 = Proto.Value(value=OneOf(:boolean_value, boolean_value741)) - _t1450 = _t1452 + _t1443 = _t1444 + end + prediction733 = _t1443 + if prediction733 == 12 + _t1459 = parse_boolean_value(parser) + boolean_value745 = _t1459 + _t1460 = Proto.Value(value=OneOf(:boolean_value, boolean_value745)) + _t1458 = _t1460 else - if prediction729 == 11 + if prediction733 == 11 consume_literal!(parser, "missing") - _t1454 = Proto.MissingValue() - _t1455 = Proto.Value(value=OneOf(:missing_value, _t1454)) - _t1453 = _t1455 + _t1462 = Proto.MissingValue() + _t1463 = Proto.Value(value=OneOf(:missing_value, _t1462)) + _t1461 = _t1463 else - if prediction729 == 10 - decimal740 = consume_terminal!(parser, "DECIMAL") - _t1457 = Proto.Value(value=OneOf(:decimal_value, decimal740)) - _t1456 = _t1457 + if prediction733 == 10 + decimal744 = consume_terminal!(parser, "DECIMAL") + _t1465 = Proto.Value(value=OneOf(:decimal_value, decimal744)) + _t1464 = _t1465 else - if prediction729 == 9 - int128739 = consume_terminal!(parser, "INT128") - _t1459 = Proto.Value(value=OneOf(:int128_value, int128739)) - _t1458 = _t1459 + if prediction733 == 9 + int128743 = consume_terminal!(parser, "INT128") + _t1467 = Proto.Value(value=OneOf(:int128_value, int128743)) + _t1466 = _t1467 else - if prediction729 == 8 - uint128738 = consume_terminal!(parser, "UINT128") - _t1461 = Proto.Value(value=OneOf(:uint128_value, uint128738)) - _t1460 = _t1461 + if prediction733 == 8 + uint128742 = consume_terminal!(parser, "UINT128") + _t1469 = Proto.Value(value=OneOf(:uint128_value, uint128742)) + _t1468 = _t1469 else - if prediction729 == 7 - uint32737 = consume_terminal!(parser, "UINT32") - _t1463 = Proto.Value(value=OneOf(:uint32_value, uint32737)) - _t1462 = _t1463 + if prediction733 == 7 + uint32741 = consume_terminal!(parser, "UINT32") + _t1471 = Proto.Value(value=OneOf(:uint32_value, uint32741)) + _t1470 = _t1471 else - if prediction729 == 6 - float736 = consume_terminal!(parser, "FLOAT") - _t1465 = Proto.Value(value=OneOf(:float_value, float736)) - _t1464 = _t1465 + if prediction733 == 6 + float740 = consume_terminal!(parser, "FLOAT") + _t1473 = Proto.Value(value=OneOf(:float_value, float740)) + _t1472 = _t1473 else - if prediction729 == 5 - float32735 = consume_terminal!(parser, "FLOAT32") - _t1467 = Proto.Value(value=OneOf(:float32_value, float32735)) - _t1466 = _t1467 + if prediction733 == 5 + float32739 = consume_terminal!(parser, "FLOAT32") + _t1475 = Proto.Value(value=OneOf(:float32_value, float32739)) + _t1474 = _t1475 else - if prediction729 == 4 - int734 = consume_terminal!(parser, "INT") - _t1469 = Proto.Value(value=OneOf(:int_value, int734)) - _t1468 = _t1469 + if prediction733 == 4 + int738 = consume_terminal!(parser, "INT") + _t1477 = Proto.Value(value=OneOf(:int_value, int738)) + _t1476 = _t1477 else - if prediction729 == 3 - int32733 = consume_terminal!(parser, "INT32") - _t1471 = Proto.Value(value=OneOf(:int32_value, int32733)) - _t1470 = _t1471 + if prediction733 == 3 + int32737 = consume_terminal!(parser, "INT32") + _t1479 = Proto.Value(value=OneOf(:int32_value, int32737)) + _t1478 = _t1479 else - if prediction729 == 2 - string732 = consume_terminal!(parser, "STRING") - _t1473 = Proto.Value(value=OneOf(:string_value, string732)) - _t1472 = _t1473 + if prediction733 == 2 + string736 = consume_terminal!(parser, "STRING") + _t1481 = Proto.Value(value=OneOf(:string_value, string736)) + _t1480 = _t1481 else - if prediction729 == 1 - _t1475 = parse_raw_datetime(parser) - raw_datetime731 = _t1475 - _t1476 = Proto.Value(value=OneOf(:datetime_value, raw_datetime731)) - _t1474 = _t1476 + if prediction733 == 1 + _t1483 = parse_raw_datetime(parser) + raw_datetime735 = _t1483 + _t1484 = Proto.Value(value=OneOf(:datetime_value, raw_datetime735)) + _t1482 = _t1484 else - if prediction729 == 0 - _t1478 = parse_raw_date(parser) - raw_date730 = _t1478 - _t1479 = Proto.Value(value=OneOf(:date_value, raw_date730)) - _t1477 = _t1479 + if prediction733 == 0 + _t1486 = parse_raw_date(parser) + raw_date734 = _t1486 + _t1487 = Proto.Value(value=OneOf(:date_value, raw_date734)) + _t1485 = _t1487 else throw(ParseError("Unexpected token in raw_value" * ": " * string(lookahead(parser, 0)))) end - _t1474 = _t1477 + _t1482 = _t1485 end - _t1472 = _t1474 + _t1480 = _t1482 end - _t1470 = _t1472 + _t1478 = _t1480 end - _t1468 = _t1470 + _t1476 = _t1478 end - _t1466 = _t1468 + _t1474 = _t1476 end - _t1464 = _t1466 + _t1472 = _t1474 end - _t1462 = _t1464 + _t1470 = _t1472 end - _t1460 = _t1462 + _t1468 = _t1470 end - _t1458 = _t1460 + _t1466 = _t1468 end - _t1456 = _t1458 + _t1464 = _t1466 end - _t1453 = _t1456 + _t1461 = _t1464 end - _t1450 = _t1453 + _t1458 = _t1461 end - result743 = _t1450 - record_span!(parser, span_start742, "Value") - return result743 + result747 = _t1458 + record_span!(parser, span_start746, "Value") + return result747 end function parse_raw_date(parser::ParserState)::Proto.DateValue - span_start747 = span_start(parser) + span_start751 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "date") - int744 = consume_terminal!(parser, "INT") - int_3745 = consume_terminal!(parser, "INT") - int_4746 = consume_terminal!(parser, "INT") + int748 = consume_terminal!(parser, "INT") + int_3749 = consume_terminal!(parser, "INT") + int_4750 = consume_terminal!(parser, "INT") consume_literal!(parser, ")") - _t1480 = Proto.DateValue(year=Int32(int744), month=Int32(int_3745), day=Int32(int_4746)) - result748 = _t1480 - record_span!(parser, span_start747, "DateValue") - return result748 + _t1488 = Proto.DateValue(year=Int32(int748), month=Int32(int_3749), day=Int32(int_4750)) + result752 = _t1488 + record_span!(parser, span_start751, "DateValue") + return result752 end function parse_raw_datetime(parser::ParserState)::Proto.DateTimeValue - span_start756 = span_start(parser) + span_start760 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "datetime") - int749 = consume_terminal!(parser, "INT") - int_3750 = consume_terminal!(parser, "INT") - int_4751 = consume_terminal!(parser, "INT") - int_5752 = consume_terminal!(parser, "INT") - int_6753 = consume_terminal!(parser, "INT") - int_7754 = consume_terminal!(parser, "INT") + int753 = consume_terminal!(parser, "INT") + int_3754 = consume_terminal!(parser, "INT") + int_4755 = consume_terminal!(parser, "INT") + int_5756 = consume_terminal!(parser, "INT") + int_6757 = consume_terminal!(parser, "INT") + int_7758 = consume_terminal!(parser, "INT") if match_lookahead_terminal(parser, "INT", 0) - _t1481 = consume_terminal!(parser, "INT") + _t1489 = consume_terminal!(parser, "INT") else - _t1481 = nothing + _t1489 = nothing end - int_8755 = _t1481 + int_8759 = _t1489 consume_literal!(parser, ")") - _t1482 = Proto.DateTimeValue(year=Int32(int749), month=Int32(int_3750), day=Int32(int_4751), hour=Int32(int_5752), minute=Int32(int_6753), second=Int32(int_7754), microsecond=Int32((!isnothing(int_8755) ? int_8755 : 0))) - result757 = _t1482 - record_span!(parser, span_start756, "DateTimeValue") - return result757 + _t1490 = Proto.DateTimeValue(year=Int32(int753), month=Int32(int_3754), day=Int32(int_4755), hour=Int32(int_5756), minute=Int32(int_6757), second=Int32(int_7758), microsecond=Int32((!isnothing(int_8759) ? int_8759 : 0))) + result761 = _t1490 + record_span!(parser, span_start760, "DateTimeValue") + return result761 end function parse_boolean_value(parser::ParserState)::Bool if match_lookahead_literal(parser, "true", 0) - _t1483 = 0 + _t1491 = 0 else if match_lookahead_literal(parser, "false", 0) - _t1484 = 1 + _t1492 = 1 else - _t1484 = -1 + _t1492 = -1 end - _t1483 = _t1484 + _t1491 = _t1492 end - prediction758 = _t1483 - if prediction758 == 1 + prediction762 = _t1491 + if prediction762 == 1 consume_literal!(parser, "false") - _t1485 = false + _t1493 = false else - if prediction758 == 0 + if prediction762 == 0 consume_literal!(parser, "true") - _t1486 = true + _t1494 = true else throw(ParseError("Unexpected token in boolean_value" * ": " * string(lookahead(parser, 0)))) end - _t1485 = _t1486 + _t1493 = _t1494 end - return _t1485 + return _t1493 end function parse_sync(parser::ParserState)::Proto.Sync - span_start763 = span_start(parser) + span_start767 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "sync") - xs759 = Proto.FragmentId[] - cond760 = match_lookahead_literal(parser, ":", 0) - while cond760 - _t1487 = parse_fragment_id(parser) - item761 = _t1487 - push!(xs759, item761) - cond760 = match_lookahead_literal(parser, ":", 0) - end - fragment_ids762 = xs759 + xs763 = Proto.FragmentId[] + cond764 = match_lookahead_literal(parser, ":", 0) + while cond764 + _t1495 = parse_fragment_id(parser) + item765 = _t1495 + push!(xs763, item765) + cond764 = match_lookahead_literal(parser, ":", 0) + end + fragment_ids766 = xs763 consume_literal!(parser, ")") - _t1488 = Proto.Sync(fragments=fragment_ids762) - result764 = _t1488 - record_span!(parser, span_start763, "Sync") - return result764 + _t1496 = Proto.Sync(fragments=fragment_ids766) + result768 = _t1496 + record_span!(parser, span_start767, "Sync") + return result768 end function parse_fragment_id(parser::ParserState)::Proto.FragmentId - span_start766 = span_start(parser) + span_start770 = span_start(parser) consume_literal!(parser, ":") - symbol765 = consume_terminal!(parser, "SYMBOL") - result767 = Proto.FragmentId(Vector{UInt8}(symbol765)) - record_span!(parser, span_start766, "FragmentId") - return result767 + symbol769 = consume_terminal!(parser, "SYMBOL") + result771 = Proto.FragmentId(Vector{UInt8}(symbol769)) + record_span!(parser, span_start770, "FragmentId") + return result771 end function parse_epoch(parser::ParserState)::Proto.Epoch - span_start770 = span_start(parser) + span_start774 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "epoch") if (match_lookahead_literal(parser, "(", 0) && match_lookahead_literal(parser, "writes", 1)) - _t1490 = parse_epoch_writes(parser) - _t1489 = _t1490 + _t1498 = parse_epoch_writes(parser) + _t1497 = _t1498 else - _t1489 = nothing + _t1497 = nothing end - epoch_writes768 = _t1489 + epoch_writes772 = _t1497 if match_lookahead_literal(parser, "(", 0) - _t1492 = parse_epoch_reads(parser) - _t1491 = _t1492 + _t1500 = parse_epoch_reads(parser) + _t1499 = _t1500 else - _t1491 = nothing + _t1499 = nothing end - epoch_reads769 = _t1491 + epoch_reads773 = _t1499 consume_literal!(parser, ")") - _t1493 = Proto.Epoch(writes=(!isnothing(epoch_writes768) ? epoch_writes768 : Proto.Write[]), reads=(!isnothing(epoch_reads769) ? epoch_reads769 : Proto.Read[])) - result771 = _t1493 - record_span!(parser, span_start770, "Epoch") - return result771 + _t1501 = Proto.Epoch(writes=(!isnothing(epoch_writes772) ? epoch_writes772 : Proto.Write[]), reads=(!isnothing(epoch_reads773) ? epoch_reads773 : Proto.Read[])) + result775 = _t1501 + record_span!(parser, span_start774, "Epoch") + return result775 end function parse_epoch_writes(parser::ParserState)::Vector{Proto.Write} consume_literal!(parser, "(") consume_literal!(parser, "writes") - xs772 = Proto.Write[] - cond773 = match_lookahead_literal(parser, "(", 0) - while cond773 - _t1494 = parse_write(parser) - item774 = _t1494 - push!(xs772, item774) - cond773 = match_lookahead_literal(parser, "(", 0) - end - writes775 = xs772 + xs776 = Proto.Write[] + cond777 = match_lookahead_literal(parser, "(", 0) + while cond777 + _t1502 = parse_write(parser) + item778 = _t1502 + push!(xs776, item778) + cond777 = match_lookahead_literal(parser, "(", 0) + end + writes779 = xs776 consume_literal!(parser, ")") - return writes775 + return writes779 end function parse_write(parser::ParserState)::Proto.Write - span_start781 = span_start(parser) + span_start785 = span_start(parser) if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "undefine", 1) - _t1496 = 1 + _t1504 = 1 else if match_lookahead_literal(parser, "snapshot", 1) - _t1497 = 3 + _t1505 = 3 else if match_lookahead_literal(parser, "define", 1) - _t1498 = 0 + _t1506 = 0 else if match_lookahead_literal(parser, "context", 1) - _t1499 = 2 + _t1507 = 2 else - _t1499 = -1 + _t1507 = -1 end - _t1498 = _t1499 + _t1506 = _t1507 end - _t1497 = _t1498 + _t1505 = _t1506 end - _t1496 = _t1497 + _t1504 = _t1505 end - _t1495 = _t1496 + _t1503 = _t1504 else - _t1495 = -1 - end - prediction776 = _t1495 - if prediction776 == 3 - _t1501 = parse_snapshot(parser) - snapshot780 = _t1501 - _t1502 = Proto.Write(write_type=OneOf(:snapshot, snapshot780)) - _t1500 = _t1502 + _t1503 = -1 + end + prediction780 = _t1503 + if prediction780 == 3 + _t1509 = parse_snapshot(parser) + snapshot784 = _t1509 + _t1510 = Proto.Write(write_type=OneOf(:snapshot, snapshot784)) + _t1508 = _t1510 else - if prediction776 == 2 - _t1504 = parse_context(parser) - context779 = _t1504 - _t1505 = Proto.Write(write_type=OneOf(:context, context779)) - _t1503 = _t1505 + if prediction780 == 2 + _t1512 = parse_context(parser) + context783 = _t1512 + _t1513 = Proto.Write(write_type=OneOf(:context, context783)) + _t1511 = _t1513 else - if prediction776 == 1 - _t1507 = parse_undefine(parser) - undefine778 = _t1507 - _t1508 = Proto.Write(write_type=OneOf(:undefine, undefine778)) - _t1506 = _t1508 + if prediction780 == 1 + _t1515 = parse_undefine(parser) + undefine782 = _t1515 + _t1516 = Proto.Write(write_type=OneOf(:undefine, undefine782)) + _t1514 = _t1516 else - if prediction776 == 0 - _t1510 = parse_define(parser) - define777 = _t1510 - _t1511 = Proto.Write(write_type=OneOf(:define, define777)) - _t1509 = _t1511 + if prediction780 == 0 + _t1518 = parse_define(parser) + define781 = _t1518 + _t1519 = Proto.Write(write_type=OneOf(:define, define781)) + _t1517 = _t1519 else throw(ParseError("Unexpected token in write" * ": " * string(lookahead(parser, 0)))) end - _t1506 = _t1509 + _t1514 = _t1517 end - _t1503 = _t1506 + _t1511 = _t1514 end - _t1500 = _t1503 + _t1508 = _t1511 end - result782 = _t1500 - record_span!(parser, span_start781, "Write") - return result782 + result786 = _t1508 + record_span!(parser, span_start785, "Write") + return result786 end function parse_define(parser::ParserState)::Proto.Define - span_start784 = span_start(parser) + span_start788 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "define") - _t1512 = parse_fragment(parser) - fragment783 = _t1512 + _t1520 = parse_fragment(parser) + fragment787 = _t1520 consume_literal!(parser, ")") - _t1513 = Proto.Define(fragment=fragment783) - result785 = _t1513 - record_span!(parser, span_start784, "Define") - return result785 + _t1521 = Proto.Define(fragment=fragment787) + result789 = _t1521 + record_span!(parser, span_start788, "Define") + return result789 end function parse_fragment(parser::ParserState)::Proto.Fragment - span_start791 = span_start(parser) + span_start795 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "fragment") - _t1514 = parse_new_fragment_id(parser) - new_fragment_id786 = _t1514 - xs787 = Proto.Declaration[] - cond788 = match_lookahead_literal(parser, "(", 0) - while cond788 - _t1515 = parse_declaration(parser) - item789 = _t1515 - push!(xs787, item789) - cond788 = match_lookahead_literal(parser, "(", 0) - end - declarations790 = xs787 + _t1522 = parse_new_fragment_id(parser) + new_fragment_id790 = _t1522 + xs791 = Proto.Declaration[] + cond792 = match_lookahead_literal(parser, "(", 0) + while cond792 + _t1523 = parse_declaration(parser) + item793 = _t1523 + push!(xs791, item793) + cond792 = match_lookahead_literal(parser, "(", 0) + end + declarations794 = xs791 consume_literal!(parser, ")") - result792 = construct_fragment(parser, new_fragment_id786, declarations790) - record_span!(parser, span_start791, "Fragment") - return result792 + result796 = construct_fragment(parser, new_fragment_id790, declarations794) + record_span!(parser, span_start795, "Fragment") + return result796 end function parse_new_fragment_id(parser::ParserState)::Proto.FragmentId - span_start794 = span_start(parser) - _t1516 = parse_fragment_id(parser) - fragment_id793 = _t1516 - start_fragment!(parser, fragment_id793) - result795 = fragment_id793 - record_span!(parser, span_start794, "FragmentId") - return result795 + span_start798 = span_start(parser) + _t1524 = parse_fragment_id(parser) + fragment_id797 = _t1524 + start_fragment!(parser, fragment_id797) + result799 = fragment_id797 + record_span!(parser, span_start798, "FragmentId") + return result799 end function parse_declaration(parser::ParserState)::Proto.Declaration - span_start801 = span_start(parser) + span_start805 = span_start(parser) if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "iceberg_data", 1) - _t1518 = 3 + _t1526 = 3 else if match_lookahead_literal(parser, "functional_dependency", 1) - _t1519 = 2 + _t1527 = 2 else if match_lookahead_literal(parser, "edb", 1) - _t1520 = 3 + _t1528 = 3 else if match_lookahead_literal(parser, "def", 1) - _t1521 = 0 + _t1529 = 0 else if match_lookahead_literal(parser, "csv_data", 1) - _t1522 = 3 + _t1530 = 3 else if match_lookahead_literal(parser, "betree_relation", 1) - _t1523 = 3 + _t1531 = 3 else if match_lookahead_literal(parser, "algorithm", 1) - _t1524 = 1 + _t1532 = 1 else - _t1524 = -1 + _t1532 = -1 end - _t1523 = _t1524 + _t1531 = _t1532 end - _t1522 = _t1523 + _t1530 = _t1531 end - _t1521 = _t1522 + _t1529 = _t1530 end - _t1520 = _t1521 + _t1528 = _t1529 end - _t1519 = _t1520 + _t1527 = _t1528 end - _t1518 = _t1519 + _t1526 = _t1527 end - _t1517 = _t1518 + _t1525 = _t1526 else - _t1517 = -1 - end - prediction796 = _t1517 - if prediction796 == 3 - _t1526 = parse_data(parser) - data800 = _t1526 - _t1527 = Proto.Declaration(declaration_type=OneOf(:data, data800)) - _t1525 = _t1527 + _t1525 = -1 + end + prediction800 = _t1525 + if prediction800 == 3 + _t1534 = parse_data(parser) + data804 = _t1534 + _t1535 = Proto.Declaration(declaration_type=OneOf(:data, data804)) + _t1533 = _t1535 else - if prediction796 == 2 - _t1529 = parse_constraint(parser) - constraint799 = _t1529 - _t1530 = Proto.Declaration(declaration_type=OneOf(:constraint, constraint799)) - _t1528 = _t1530 + if prediction800 == 2 + _t1537 = parse_constraint(parser) + constraint803 = _t1537 + _t1538 = Proto.Declaration(declaration_type=OneOf(:constraint, constraint803)) + _t1536 = _t1538 else - if prediction796 == 1 - _t1532 = parse_algorithm(parser) - algorithm798 = _t1532 - _t1533 = Proto.Declaration(declaration_type=OneOf(:algorithm, algorithm798)) - _t1531 = _t1533 + if prediction800 == 1 + _t1540 = parse_algorithm(parser) + algorithm802 = _t1540 + _t1541 = Proto.Declaration(declaration_type=OneOf(:algorithm, algorithm802)) + _t1539 = _t1541 else - if prediction796 == 0 - _t1535 = parse_def(parser) - def797 = _t1535 - _t1536 = Proto.Declaration(declaration_type=OneOf(:def, def797)) - _t1534 = _t1536 + if prediction800 == 0 + _t1543 = parse_def(parser) + def801 = _t1543 + _t1544 = Proto.Declaration(declaration_type=OneOf(:def, def801)) + _t1542 = _t1544 else throw(ParseError("Unexpected token in declaration" * ": " * string(lookahead(parser, 0)))) end - _t1531 = _t1534 + _t1539 = _t1542 end - _t1528 = _t1531 + _t1536 = _t1539 end - _t1525 = _t1528 + _t1533 = _t1536 end - result802 = _t1525 - record_span!(parser, span_start801, "Declaration") - return result802 + result806 = _t1533 + record_span!(parser, span_start805, "Declaration") + return result806 end function parse_def(parser::ParserState)::Proto.Def - span_start806 = span_start(parser) + span_start810 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "def") - _t1537 = parse_relation_id(parser) - relation_id803 = _t1537 - _t1538 = parse_abstraction(parser) - abstraction804 = _t1538 + _t1545 = parse_relation_id(parser) + relation_id807 = _t1545 + _t1546 = parse_abstraction(parser) + abstraction808 = _t1546 if match_lookahead_literal(parser, "(", 0) - _t1540 = parse_attrs(parser) - _t1539 = _t1540 + _t1548 = parse_attrs(parser) + _t1547 = _t1548 else - _t1539 = nothing + _t1547 = nothing end - attrs805 = _t1539 + attrs809 = _t1547 consume_literal!(parser, ")") - _t1541 = Proto.Def(name=relation_id803, body=abstraction804, attrs=(!isnothing(attrs805) ? attrs805 : Proto.Attribute[])) - result807 = _t1541 - record_span!(parser, span_start806, "Def") - return result807 + _t1549 = Proto.Def(name=relation_id807, body=abstraction808, attrs=(!isnothing(attrs809) ? attrs809 : Proto.Attribute[])) + result811 = _t1549 + record_span!(parser, span_start810, "Def") + return result811 end function parse_relation_id(parser::ParserState)::Proto.RelationId - span_start811 = span_start(parser) + span_start815 = span_start(parser) if match_lookahead_literal(parser, ":", 0) - _t1542 = 0 + _t1550 = 0 else if match_lookahead_terminal(parser, "UINT128", 0) - _t1543 = 1 + _t1551 = 1 else - _t1543 = -1 + _t1551 = -1 end - _t1542 = _t1543 + _t1550 = _t1551 end - prediction808 = _t1542 - if prediction808 == 1 - uint128810 = consume_terminal!(parser, "UINT128") - _t1544 = Proto.RelationId(uint128810.low, uint128810.high) + prediction812 = _t1550 + if prediction812 == 1 + uint128814 = consume_terminal!(parser, "UINT128") + _t1552 = Proto.RelationId(uint128814.low, uint128814.high) else - if prediction808 == 0 + if prediction812 == 0 consume_literal!(parser, ":") - symbol809 = consume_terminal!(parser, "SYMBOL") - _t1545 = relation_id_from_string(parser, symbol809) + symbol813 = consume_terminal!(parser, "SYMBOL") + _t1553 = relation_id_from_string(parser, symbol813) else throw(ParseError("Unexpected token in relation_id" * ": " * string(lookahead(parser, 0)))) end - _t1544 = _t1545 + _t1552 = _t1553 end - result812 = _t1544 - record_span!(parser, span_start811, "RelationId") - return result812 + result816 = _t1552 + record_span!(parser, span_start815, "RelationId") + return result816 end function parse_abstraction(parser::ParserState)::Proto.Abstraction - span_start815 = span_start(parser) + span_start819 = span_start(parser) consume_literal!(parser, "(") - _t1546 = parse_bindings(parser) - bindings813 = _t1546 - _t1547 = parse_formula(parser) - formula814 = _t1547 + _t1554 = parse_bindings(parser) + bindings817 = _t1554 + _t1555 = parse_formula(parser) + formula818 = _t1555 consume_literal!(parser, ")") - _t1548 = Proto.Abstraction(vars=vcat(bindings813[1], !isnothing(bindings813[2]) ? bindings813[2] : []), value=formula814) - result816 = _t1548 - record_span!(parser, span_start815, "Abstraction") - return result816 + _t1556 = Proto.Abstraction(vars=vcat(bindings817[1], !isnothing(bindings817[2]) ? bindings817[2] : []), value=formula818) + result820 = _t1556 + record_span!(parser, span_start819, "Abstraction") + return result820 end function parse_bindings(parser::ParserState)::Tuple{Vector{Proto.Binding}, Vector{Proto.Binding}} consume_literal!(parser, "[") - xs817 = Proto.Binding[] - cond818 = match_lookahead_terminal(parser, "SYMBOL", 0) - while cond818 - _t1549 = parse_binding(parser) - item819 = _t1549 - push!(xs817, item819) - cond818 = match_lookahead_terminal(parser, "SYMBOL", 0) - end - bindings820 = xs817 + xs821 = Proto.Binding[] + cond822 = match_lookahead_terminal(parser, "SYMBOL", 0) + while cond822 + _t1557 = parse_binding(parser) + item823 = _t1557 + push!(xs821, item823) + cond822 = match_lookahead_terminal(parser, "SYMBOL", 0) + end + bindings824 = xs821 if match_lookahead_literal(parser, "|", 0) - _t1551 = parse_value_bindings(parser) - _t1550 = _t1551 + _t1559 = parse_value_bindings(parser) + _t1558 = _t1559 else - _t1550 = nothing + _t1558 = nothing end - value_bindings821 = _t1550 + value_bindings825 = _t1558 consume_literal!(parser, "]") - return (bindings820, (!isnothing(value_bindings821) ? value_bindings821 : Proto.Binding[]),) + return (bindings824, (!isnothing(value_bindings825) ? value_bindings825 : Proto.Binding[]),) end function parse_binding(parser::ParserState)::Proto.Binding - span_start824 = span_start(parser) - symbol822 = consume_terminal!(parser, "SYMBOL") + span_start828 = span_start(parser) + symbol826 = consume_terminal!(parser, "SYMBOL") consume_literal!(parser, "::") - _t1552 = parse_type(parser) - type823 = _t1552 - _t1553 = Proto.Var(name=symbol822) - _t1554 = Proto.Binding(var=_t1553, var"#type"=type823) - result825 = _t1554 - record_span!(parser, span_start824, "Binding") - return result825 + _t1560 = parse_type(parser) + type827 = _t1560 + _t1561 = Proto.Var(name=symbol826) + _t1562 = Proto.Binding(var=_t1561, var"#type"=type827) + result829 = _t1562 + record_span!(parser, span_start828, "Binding") + return result829 end function parse_type(parser::ParserState)::Proto.var"#Type" - span_start841 = span_start(parser) + span_start846 = span_start(parser) if match_lookahead_literal(parser, "UNKNOWN", 0) - _t1555 = 0 + _t1563 = 0 else if match_lookahead_literal(parser, "UINT32", 0) - _t1556 = 13 + _t1564 = 13 else if match_lookahead_literal(parser, "UINT128", 0) - _t1557 = 4 + _t1565 = 4 else if match_lookahead_literal(parser, "STRING", 0) - _t1558 = 1 + _t1566 = 1 else if match_lookahead_literal(parser, "MISSING", 0) - _t1559 = 8 + _t1567 = 8 else if match_lookahead_literal(parser, "INT32", 0) - _t1560 = 11 + _t1568 = 11 else if match_lookahead_literal(parser, "INT128", 0) - _t1561 = 5 + _t1569 = 5 else if match_lookahead_literal(parser, "INT", 0) - _t1562 = 2 + _t1570 = 2 else if match_lookahead_literal(parser, "FLOAT32", 0) - _t1563 = 12 + _t1571 = 12 else if match_lookahead_literal(parser, "FLOAT", 0) - _t1564 = 3 + _t1572 = 3 else if match_lookahead_literal(parser, "DATETIME", 0) - _t1565 = 7 + _t1573 = 7 else if match_lookahead_literal(parser, "DATE", 0) - _t1566 = 6 + _t1574 = 6 else if match_lookahead_literal(parser, "BOOLEAN", 0) - _t1567 = 10 + _t1575 = 10 else if match_lookahead_literal(parser, "(", 0) - _t1568 = 9 + if match_lookahead_literal(parser, "FIXED", 1) + _t1577 = 14 + else + if match_lookahead_literal(parser, "DECIMAL", 1) + _t1578 = 9 + else + _t1578 = -1 + end + _t1577 = _t1578 + end + _t1576 = _t1577 else - _t1568 = -1 + _t1576 = -1 end - _t1567 = _t1568 + _t1575 = _t1576 end - _t1566 = _t1567 + _t1574 = _t1575 end - _t1565 = _t1566 + _t1573 = _t1574 end - _t1564 = _t1565 + _t1572 = _t1573 end - _t1563 = _t1564 + _t1571 = _t1572 end - _t1562 = _t1563 + _t1570 = _t1571 end - _t1561 = _t1562 + _t1569 = _t1570 end - _t1560 = _t1561 + _t1568 = _t1569 end - _t1559 = _t1560 + _t1567 = _t1568 end - _t1558 = _t1559 + _t1566 = _t1567 end - _t1557 = _t1558 + _t1565 = _t1566 end - _t1556 = _t1557 + _t1564 = _t1565 end - _t1555 = _t1556 - end - prediction826 = _t1555 - if prediction826 == 13 - _t1570 = parse_uint32_type(parser) - uint32_type840 = _t1570 - _t1571 = Proto.var"#Type"(var"#type"=OneOf(:uint32_type, uint32_type840)) - _t1569 = _t1571 + _t1563 = _t1564 + end + prediction830 = _t1563 + if prediction830 == 14 + _t1580 = parse_fixed_type(parser) + fixed_type845 = _t1580 + _t1581 = Proto.var"#Type"(var"#type"=OneOf(:fixed_type, fixed_type845)) + _t1579 = _t1581 else - if prediction826 == 12 - _t1573 = parse_float32_type(parser) - float32_type839 = _t1573 - _t1574 = Proto.var"#Type"(var"#type"=OneOf(:float32_type, float32_type839)) - _t1572 = _t1574 + if prediction830 == 13 + _t1583 = parse_uint32_type(parser) + uint32_type844 = _t1583 + _t1584 = Proto.var"#Type"(var"#type"=OneOf(:uint32_type, uint32_type844)) + _t1582 = _t1584 else - if prediction826 == 11 - _t1576 = parse_int32_type(parser) - int32_type838 = _t1576 - _t1577 = Proto.var"#Type"(var"#type"=OneOf(:int32_type, int32_type838)) - _t1575 = _t1577 + if prediction830 == 12 + _t1586 = parse_float32_type(parser) + float32_type843 = _t1586 + _t1587 = Proto.var"#Type"(var"#type"=OneOf(:float32_type, float32_type843)) + _t1585 = _t1587 else - if prediction826 == 10 - _t1579 = parse_boolean_type(parser) - boolean_type837 = _t1579 - _t1580 = Proto.var"#Type"(var"#type"=OneOf(:boolean_type, boolean_type837)) - _t1578 = _t1580 + if prediction830 == 11 + _t1589 = parse_int32_type(parser) + int32_type842 = _t1589 + _t1590 = Proto.var"#Type"(var"#type"=OneOf(:int32_type, int32_type842)) + _t1588 = _t1590 else - if prediction826 == 9 - _t1582 = parse_decimal_type(parser) - decimal_type836 = _t1582 - _t1583 = Proto.var"#Type"(var"#type"=OneOf(:decimal_type, decimal_type836)) - _t1581 = _t1583 + if prediction830 == 10 + _t1592 = parse_boolean_type(parser) + boolean_type841 = _t1592 + _t1593 = Proto.var"#Type"(var"#type"=OneOf(:boolean_type, boolean_type841)) + _t1591 = _t1593 else - if prediction826 == 8 - _t1585 = parse_missing_type(parser) - missing_type835 = _t1585 - _t1586 = Proto.var"#Type"(var"#type"=OneOf(:missing_type, missing_type835)) - _t1584 = _t1586 + if prediction830 == 9 + _t1595 = parse_decimal_type(parser) + decimal_type840 = _t1595 + _t1596 = Proto.var"#Type"(var"#type"=OneOf(:decimal_type, decimal_type840)) + _t1594 = _t1596 else - if prediction826 == 7 - _t1588 = parse_datetime_type(parser) - datetime_type834 = _t1588 - _t1589 = Proto.var"#Type"(var"#type"=OneOf(:datetime_type, datetime_type834)) - _t1587 = _t1589 + if prediction830 == 8 + _t1598 = parse_missing_type(parser) + missing_type839 = _t1598 + _t1599 = Proto.var"#Type"(var"#type"=OneOf(:missing_type, missing_type839)) + _t1597 = _t1599 else - if prediction826 == 6 - _t1591 = parse_date_type(parser) - date_type833 = _t1591 - _t1592 = Proto.var"#Type"(var"#type"=OneOf(:date_type, date_type833)) - _t1590 = _t1592 + if prediction830 == 7 + _t1601 = parse_datetime_type(parser) + datetime_type838 = _t1601 + _t1602 = Proto.var"#Type"(var"#type"=OneOf(:datetime_type, datetime_type838)) + _t1600 = _t1602 else - if prediction826 == 5 - _t1594 = parse_int128_type(parser) - int128_type832 = _t1594 - _t1595 = Proto.var"#Type"(var"#type"=OneOf(:int128_type, int128_type832)) - _t1593 = _t1595 + if prediction830 == 6 + _t1604 = parse_date_type(parser) + date_type837 = _t1604 + _t1605 = Proto.var"#Type"(var"#type"=OneOf(:date_type, date_type837)) + _t1603 = _t1605 else - if prediction826 == 4 - _t1597 = parse_uint128_type(parser) - uint128_type831 = _t1597 - _t1598 = Proto.var"#Type"(var"#type"=OneOf(:uint128_type, uint128_type831)) - _t1596 = _t1598 + if prediction830 == 5 + _t1607 = parse_int128_type(parser) + int128_type836 = _t1607 + _t1608 = Proto.var"#Type"(var"#type"=OneOf(:int128_type, int128_type836)) + _t1606 = _t1608 else - if prediction826 == 3 - _t1600 = parse_float_type(parser) - float_type830 = _t1600 - _t1601 = Proto.var"#Type"(var"#type"=OneOf(:float_type, float_type830)) - _t1599 = _t1601 + if prediction830 == 4 + _t1610 = parse_uint128_type(parser) + uint128_type835 = _t1610 + _t1611 = Proto.var"#Type"(var"#type"=OneOf(:uint128_type, uint128_type835)) + _t1609 = _t1611 else - if prediction826 == 2 - _t1603 = parse_int_type(parser) - int_type829 = _t1603 - _t1604 = Proto.var"#Type"(var"#type"=OneOf(:int_type, int_type829)) - _t1602 = _t1604 + if prediction830 == 3 + _t1613 = parse_float_type(parser) + float_type834 = _t1613 + _t1614 = Proto.var"#Type"(var"#type"=OneOf(:float_type, float_type834)) + _t1612 = _t1614 else - if prediction826 == 1 - _t1606 = parse_string_type(parser) - string_type828 = _t1606 - _t1607 = Proto.var"#Type"(var"#type"=OneOf(:string_type, string_type828)) - _t1605 = _t1607 + if prediction830 == 2 + _t1616 = parse_int_type(parser) + int_type833 = _t1616 + _t1617 = Proto.var"#Type"(var"#type"=OneOf(:int_type, int_type833)) + _t1615 = _t1617 else - if prediction826 == 0 - _t1609 = parse_unspecified_type(parser) - unspecified_type827 = _t1609 - _t1610 = Proto.var"#Type"(var"#type"=OneOf(:unspecified_type, unspecified_type827)) - _t1608 = _t1610 + if prediction830 == 1 + _t1619 = parse_string_type(parser) + string_type832 = _t1619 + _t1620 = Proto.var"#Type"(var"#type"=OneOf(:string_type, string_type832)) + _t1618 = _t1620 else - throw(ParseError("Unexpected token in type" * ": " * string(lookahead(parser, 0)))) + if prediction830 == 0 + _t1622 = parse_unspecified_type(parser) + unspecified_type831 = _t1622 + _t1623 = Proto.var"#Type"(var"#type"=OneOf(:unspecified_type, unspecified_type831)) + _t1621 = _t1623 + else + throw(ParseError("Unexpected token in type" * ": " * string(lookahead(parser, 0)))) + end + _t1618 = _t1621 end - _t1605 = _t1608 + _t1615 = _t1618 end - _t1602 = _t1605 + _t1612 = _t1615 end - _t1599 = _t1602 + _t1609 = _t1612 end - _t1596 = _t1599 + _t1606 = _t1609 end - _t1593 = _t1596 + _t1603 = _t1606 end - _t1590 = _t1593 + _t1600 = _t1603 end - _t1587 = _t1590 + _t1597 = _t1600 end - _t1584 = _t1587 + _t1594 = _t1597 end - _t1581 = _t1584 + _t1591 = _t1594 end - _t1578 = _t1581 + _t1588 = _t1591 end - _t1575 = _t1578 + _t1585 = _t1588 end - _t1572 = _t1575 + _t1582 = _t1585 end - _t1569 = _t1572 + _t1579 = _t1582 end - result842 = _t1569 - record_span!(parser, span_start841, "Type") - return result842 + result847 = _t1579 + record_span!(parser, span_start846, "Type") + return result847 end function parse_unspecified_type(parser::ParserState)::Proto.UnspecifiedType - span_start843 = span_start(parser) + span_start848 = span_start(parser) consume_literal!(parser, "UNKNOWN") - _t1611 = Proto.UnspecifiedType() - result844 = _t1611 - record_span!(parser, span_start843, "UnspecifiedType") - return result844 + _t1624 = Proto.UnspecifiedType() + result849 = _t1624 + record_span!(parser, span_start848, "UnspecifiedType") + return result849 end function parse_string_type(parser::ParserState)::Proto.StringType - span_start845 = span_start(parser) + span_start850 = span_start(parser) consume_literal!(parser, "STRING") - _t1612 = Proto.StringType() - result846 = _t1612 - record_span!(parser, span_start845, "StringType") - return result846 + _t1625 = Proto.StringType() + result851 = _t1625 + record_span!(parser, span_start850, "StringType") + return result851 end function parse_int_type(parser::ParserState)::Proto.IntType - span_start847 = span_start(parser) + span_start852 = span_start(parser) consume_literal!(parser, "INT") - _t1613 = Proto.IntType() - result848 = _t1613 - record_span!(parser, span_start847, "IntType") - return result848 + _t1626 = Proto.IntType() + result853 = _t1626 + record_span!(parser, span_start852, "IntType") + return result853 end function parse_float_type(parser::ParserState)::Proto.FloatType - span_start849 = span_start(parser) + span_start854 = span_start(parser) consume_literal!(parser, "FLOAT") - _t1614 = Proto.FloatType() - result850 = _t1614 - record_span!(parser, span_start849, "FloatType") - return result850 + _t1627 = Proto.FloatType() + result855 = _t1627 + record_span!(parser, span_start854, "FloatType") + return result855 end function parse_uint128_type(parser::ParserState)::Proto.UInt128Type - span_start851 = span_start(parser) + span_start856 = span_start(parser) consume_literal!(parser, "UINT128") - _t1615 = Proto.UInt128Type() - result852 = _t1615 - record_span!(parser, span_start851, "UInt128Type") - return result852 + _t1628 = Proto.UInt128Type() + result857 = _t1628 + record_span!(parser, span_start856, "UInt128Type") + return result857 end function parse_int128_type(parser::ParserState)::Proto.Int128Type - span_start853 = span_start(parser) + span_start858 = span_start(parser) consume_literal!(parser, "INT128") - _t1616 = Proto.Int128Type() - result854 = _t1616 - record_span!(parser, span_start853, "Int128Type") - return result854 + _t1629 = Proto.Int128Type() + result859 = _t1629 + record_span!(parser, span_start858, "Int128Type") + return result859 end function parse_date_type(parser::ParserState)::Proto.DateType - span_start855 = span_start(parser) + span_start860 = span_start(parser) consume_literal!(parser, "DATE") - _t1617 = Proto.DateType() - result856 = _t1617 - record_span!(parser, span_start855, "DateType") - return result856 + _t1630 = Proto.DateType() + result861 = _t1630 + record_span!(parser, span_start860, "DateType") + return result861 end function parse_datetime_type(parser::ParserState)::Proto.DateTimeType - span_start857 = span_start(parser) + span_start862 = span_start(parser) consume_literal!(parser, "DATETIME") - _t1618 = Proto.DateTimeType() - result858 = _t1618 - record_span!(parser, span_start857, "DateTimeType") - return result858 + _t1631 = Proto.DateTimeType() + result863 = _t1631 + record_span!(parser, span_start862, "DateTimeType") + return result863 end function parse_missing_type(parser::ParserState)::Proto.MissingType - span_start859 = span_start(parser) + span_start864 = span_start(parser) consume_literal!(parser, "MISSING") - _t1619 = Proto.MissingType() - result860 = _t1619 - record_span!(parser, span_start859, "MissingType") - return result860 + _t1632 = Proto.MissingType() + result865 = _t1632 + record_span!(parser, span_start864, "MissingType") + return result865 end function parse_decimal_type(parser::ParserState)::Proto.DecimalType - span_start863 = span_start(parser) + span_start868 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "DECIMAL") - int861 = consume_terminal!(parser, "INT") - int_3862 = consume_terminal!(parser, "INT") + int866 = consume_terminal!(parser, "INT") + int_3867 = consume_terminal!(parser, "INT") consume_literal!(parser, ")") - _t1620 = Proto.DecimalType(precision=Int32(int861), scale=Int32(int_3862)) - result864 = _t1620 - record_span!(parser, span_start863, "DecimalType") - return result864 + _t1633 = Proto.DecimalType(precision=Int32(int866), scale=Int32(int_3867)) + result869 = _t1633 + record_span!(parser, span_start868, "DecimalType") + return result869 end function parse_boolean_type(parser::ParserState)::Proto.BooleanType - span_start865 = span_start(parser) + span_start870 = span_start(parser) consume_literal!(parser, "BOOLEAN") - _t1621 = Proto.BooleanType() - result866 = _t1621 - record_span!(parser, span_start865, "BooleanType") - return result866 + _t1634 = Proto.BooleanType() + result871 = _t1634 + record_span!(parser, span_start870, "BooleanType") + return result871 end function parse_int32_type(parser::ParserState)::Proto.Int32Type - span_start867 = span_start(parser) + span_start872 = span_start(parser) consume_literal!(parser, "INT32") - _t1622 = Proto.Int32Type() - result868 = _t1622 - record_span!(parser, span_start867, "Int32Type") - return result868 + _t1635 = Proto.Int32Type() + result873 = _t1635 + record_span!(parser, span_start872, "Int32Type") + return result873 end function parse_float32_type(parser::ParserState)::Proto.Float32Type - span_start869 = span_start(parser) + span_start874 = span_start(parser) consume_literal!(parser, "FLOAT32") - _t1623 = Proto.Float32Type() - result870 = _t1623 - record_span!(parser, span_start869, "Float32Type") - return result870 + _t1636 = Proto.Float32Type() + result875 = _t1636 + record_span!(parser, span_start874, "Float32Type") + return result875 end function parse_uint32_type(parser::ParserState)::Proto.UInt32Type - span_start871 = span_start(parser) + span_start876 = span_start(parser) consume_literal!(parser, "UINT32") - _t1624 = Proto.UInt32Type() - result872 = _t1624 - record_span!(parser, span_start871, "UInt32Type") - return result872 + _t1637 = Proto.UInt32Type() + result877 = _t1637 + record_span!(parser, span_start876, "UInt32Type") + return result877 +end + +function parse_fixed_type(parser::ParserState)::Proto.FixedType + span_start879 = span_start(parser) + consume_literal!(parser, "(") + consume_literal!(parser, "FIXED") + int878 = consume_terminal!(parser, "INT") + consume_literal!(parser, ")") + _t1638 = Proto.FixedType(length=Int32(int878)) + result880 = _t1638 + record_span!(parser, span_start879, "FixedType") + return result880 end function parse_value_bindings(parser::ParserState)::Vector{Proto.Binding} consume_literal!(parser, "|") - xs873 = Proto.Binding[] - cond874 = match_lookahead_terminal(parser, "SYMBOL", 0) - while cond874 - _t1625 = parse_binding(parser) - item875 = _t1625 - push!(xs873, item875) - cond874 = match_lookahead_terminal(parser, "SYMBOL", 0) + xs881 = Proto.Binding[] + cond882 = match_lookahead_terminal(parser, "SYMBOL", 0) + while cond882 + _t1639 = parse_binding(parser) + item883 = _t1639 + push!(xs881, item883) + cond882 = match_lookahead_terminal(parser, "SYMBOL", 0) end - bindings876 = xs873 - return bindings876 + bindings884 = xs881 + return bindings884 end function parse_formula(parser::ParserState)::Proto.Formula - span_start891 = span_start(parser) + span_start899 = span_start(parser) if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "true", 1) - _t1627 = 0 + _t1641 = 0 else if match_lookahead_literal(parser, "relatom", 1) - _t1628 = 11 + _t1642 = 11 else if match_lookahead_literal(parser, "reduce", 1) - _t1629 = 3 + _t1643 = 3 else if match_lookahead_literal(parser, "primitive", 1) - _t1630 = 10 + _t1644 = 10 else if match_lookahead_literal(parser, "pragma", 1) - _t1631 = 9 + _t1645 = 9 else if match_lookahead_literal(parser, "or", 1) - _t1632 = 5 + _t1646 = 5 else if match_lookahead_literal(parser, "not", 1) - _t1633 = 6 + _t1647 = 6 else if match_lookahead_literal(parser, "ffi", 1) - _t1634 = 7 + _t1648 = 7 else if match_lookahead_literal(parser, "false", 1) - _t1635 = 1 + _t1649 = 1 else if match_lookahead_literal(parser, "exists", 1) - _t1636 = 2 + _t1650 = 2 else if match_lookahead_literal(parser, "cast", 1) - _t1637 = 12 + _t1651 = 12 else if match_lookahead_literal(parser, "atom", 1) - _t1638 = 8 + _t1652 = 8 else if match_lookahead_literal(parser, "and", 1) - _t1639 = 4 + _t1653 = 4 else if match_lookahead_literal(parser, ">=", 1) - _t1640 = 10 + _t1654 = 10 else if match_lookahead_literal(parser, ">", 1) - _t1641 = 10 + _t1655 = 10 else if match_lookahead_literal(parser, "=", 1) - _t1642 = 10 + _t1656 = 10 else if match_lookahead_literal(parser, "<=", 1) - _t1643 = 10 + _t1657 = 10 else if match_lookahead_literal(parser, "<", 1) - _t1644 = 10 + _t1658 = 10 else if match_lookahead_literal(parser, "/", 1) - _t1645 = 10 + _t1659 = 10 else if match_lookahead_literal(parser, "-", 1) - _t1646 = 10 + _t1660 = 10 else if match_lookahead_literal(parser, "+", 1) - _t1647 = 10 + _t1661 = 10 else if match_lookahead_literal(parser, "*", 1) - _t1648 = 10 + _t1662 = 10 else - _t1648 = -1 + _t1662 = -1 end - _t1647 = _t1648 + _t1661 = _t1662 end - _t1646 = _t1647 + _t1660 = _t1661 end - _t1645 = _t1646 + _t1659 = _t1660 end - _t1644 = _t1645 + _t1658 = _t1659 end - _t1643 = _t1644 + _t1657 = _t1658 end - _t1642 = _t1643 + _t1656 = _t1657 end - _t1641 = _t1642 + _t1655 = _t1656 end - _t1640 = _t1641 + _t1654 = _t1655 end - _t1639 = _t1640 + _t1653 = _t1654 end - _t1638 = _t1639 + _t1652 = _t1653 end - _t1637 = _t1638 + _t1651 = _t1652 end - _t1636 = _t1637 + _t1650 = _t1651 end - _t1635 = _t1636 + _t1649 = _t1650 end - _t1634 = _t1635 + _t1648 = _t1649 end - _t1633 = _t1634 + _t1647 = _t1648 end - _t1632 = _t1633 + _t1646 = _t1647 end - _t1631 = _t1632 + _t1645 = _t1646 end - _t1630 = _t1631 + _t1644 = _t1645 end - _t1629 = _t1630 + _t1643 = _t1644 end - _t1628 = _t1629 + _t1642 = _t1643 end - _t1627 = _t1628 + _t1641 = _t1642 end - _t1626 = _t1627 + _t1640 = _t1641 else - _t1626 = -1 - end - prediction877 = _t1626 - if prediction877 == 12 - _t1650 = parse_cast(parser) - cast890 = _t1650 - _t1651 = Proto.Formula(formula_type=OneOf(:cast, cast890)) - _t1649 = _t1651 + _t1640 = -1 + end + prediction885 = _t1640 + if prediction885 == 12 + _t1664 = parse_cast(parser) + cast898 = _t1664 + _t1665 = Proto.Formula(formula_type=OneOf(:cast, cast898)) + _t1663 = _t1665 else - if prediction877 == 11 - _t1653 = parse_rel_atom(parser) - rel_atom889 = _t1653 - _t1654 = Proto.Formula(formula_type=OneOf(:rel_atom, rel_atom889)) - _t1652 = _t1654 + if prediction885 == 11 + _t1667 = parse_rel_atom(parser) + rel_atom897 = _t1667 + _t1668 = Proto.Formula(formula_type=OneOf(:rel_atom, rel_atom897)) + _t1666 = _t1668 else - if prediction877 == 10 - _t1656 = parse_primitive(parser) - primitive888 = _t1656 - _t1657 = Proto.Formula(formula_type=OneOf(:primitive, primitive888)) - _t1655 = _t1657 + if prediction885 == 10 + _t1670 = parse_primitive(parser) + primitive896 = _t1670 + _t1671 = Proto.Formula(formula_type=OneOf(:primitive, primitive896)) + _t1669 = _t1671 else - if prediction877 == 9 - _t1659 = parse_pragma(parser) - pragma887 = _t1659 - _t1660 = Proto.Formula(formula_type=OneOf(:pragma, pragma887)) - _t1658 = _t1660 + if prediction885 == 9 + _t1673 = parse_pragma(parser) + pragma895 = _t1673 + _t1674 = Proto.Formula(formula_type=OneOf(:pragma, pragma895)) + _t1672 = _t1674 else - if prediction877 == 8 - _t1662 = parse_atom(parser) - atom886 = _t1662 - _t1663 = Proto.Formula(formula_type=OneOf(:atom, atom886)) - _t1661 = _t1663 + if prediction885 == 8 + _t1676 = parse_atom(parser) + atom894 = _t1676 + _t1677 = Proto.Formula(formula_type=OneOf(:atom, atom894)) + _t1675 = _t1677 else - if prediction877 == 7 - _t1665 = parse_ffi(parser) - ffi885 = _t1665 - _t1666 = Proto.Formula(formula_type=OneOf(:ffi, ffi885)) - _t1664 = _t1666 + if prediction885 == 7 + _t1679 = parse_ffi(parser) + ffi893 = _t1679 + _t1680 = Proto.Formula(formula_type=OneOf(:ffi, ffi893)) + _t1678 = _t1680 else - if prediction877 == 6 - _t1668 = parse_not(parser) - not884 = _t1668 - _t1669 = Proto.Formula(formula_type=OneOf(:not, not884)) - _t1667 = _t1669 + if prediction885 == 6 + _t1682 = parse_not(parser) + not892 = _t1682 + _t1683 = Proto.Formula(formula_type=OneOf(:not, not892)) + _t1681 = _t1683 else - if prediction877 == 5 - _t1671 = parse_disjunction(parser) - disjunction883 = _t1671 - _t1672 = Proto.Formula(formula_type=OneOf(:disjunction, disjunction883)) - _t1670 = _t1672 + if prediction885 == 5 + _t1685 = parse_disjunction(parser) + disjunction891 = _t1685 + _t1686 = Proto.Formula(formula_type=OneOf(:disjunction, disjunction891)) + _t1684 = _t1686 else - if prediction877 == 4 - _t1674 = parse_conjunction(parser) - conjunction882 = _t1674 - _t1675 = Proto.Formula(formula_type=OneOf(:conjunction, conjunction882)) - _t1673 = _t1675 + if prediction885 == 4 + _t1688 = parse_conjunction(parser) + conjunction890 = _t1688 + _t1689 = Proto.Formula(formula_type=OneOf(:conjunction, conjunction890)) + _t1687 = _t1689 else - if prediction877 == 3 - _t1677 = parse_reduce(parser) - reduce881 = _t1677 - _t1678 = Proto.Formula(formula_type=OneOf(:reduce, reduce881)) - _t1676 = _t1678 + if prediction885 == 3 + _t1691 = parse_reduce(parser) + reduce889 = _t1691 + _t1692 = Proto.Formula(formula_type=OneOf(:reduce, reduce889)) + _t1690 = _t1692 else - if prediction877 == 2 - _t1680 = parse_exists(parser) - exists880 = _t1680 - _t1681 = Proto.Formula(formula_type=OneOf(:exists, exists880)) - _t1679 = _t1681 + if prediction885 == 2 + _t1694 = parse_exists(parser) + exists888 = _t1694 + _t1695 = Proto.Formula(formula_type=OneOf(:exists, exists888)) + _t1693 = _t1695 else - if prediction877 == 1 - _t1683 = parse_false(parser) - false879 = _t1683 - _t1684 = Proto.Formula(formula_type=OneOf(:disjunction, false879)) - _t1682 = _t1684 + if prediction885 == 1 + _t1697 = parse_false(parser) + false887 = _t1697 + _t1698 = Proto.Formula(formula_type=OneOf(:disjunction, false887)) + _t1696 = _t1698 else - if prediction877 == 0 - _t1686 = parse_true(parser) - true878 = _t1686 - _t1687 = Proto.Formula(formula_type=OneOf(:conjunction, true878)) - _t1685 = _t1687 + if prediction885 == 0 + _t1700 = parse_true(parser) + true886 = _t1700 + _t1701 = Proto.Formula(formula_type=OneOf(:conjunction, true886)) + _t1699 = _t1701 else throw(ParseError("Unexpected token in formula" * ": " * string(lookahead(parser, 0)))) end - _t1682 = _t1685 + _t1696 = _t1699 end - _t1679 = _t1682 + _t1693 = _t1696 end - _t1676 = _t1679 + _t1690 = _t1693 end - _t1673 = _t1676 + _t1687 = _t1690 end - _t1670 = _t1673 + _t1684 = _t1687 end - _t1667 = _t1670 + _t1681 = _t1684 end - _t1664 = _t1667 + _t1678 = _t1681 end - _t1661 = _t1664 + _t1675 = _t1678 end - _t1658 = _t1661 + _t1672 = _t1675 end - _t1655 = _t1658 + _t1669 = _t1672 end - _t1652 = _t1655 + _t1666 = _t1669 end - _t1649 = _t1652 + _t1663 = _t1666 end - result892 = _t1649 - record_span!(parser, span_start891, "Formula") - return result892 + result900 = _t1663 + record_span!(parser, span_start899, "Formula") + return result900 end function parse_true(parser::ParserState)::Proto.Conjunction - span_start893 = span_start(parser) + span_start901 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "true") consume_literal!(parser, ")") - _t1688 = Proto.Conjunction(args=Proto.Formula[]) - result894 = _t1688 - record_span!(parser, span_start893, "Conjunction") - return result894 + _t1702 = Proto.Conjunction(args=Proto.Formula[]) + result902 = _t1702 + record_span!(parser, span_start901, "Conjunction") + return result902 end function parse_false(parser::ParserState)::Proto.Disjunction - span_start895 = span_start(parser) + span_start903 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "false") consume_literal!(parser, ")") - _t1689 = Proto.Disjunction(args=Proto.Formula[]) - result896 = _t1689 - record_span!(parser, span_start895, "Disjunction") - return result896 + _t1703 = Proto.Disjunction(args=Proto.Formula[]) + result904 = _t1703 + record_span!(parser, span_start903, "Disjunction") + return result904 end function parse_exists(parser::ParserState)::Proto.Exists - span_start899 = span_start(parser) + span_start907 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "exists") - _t1690 = parse_bindings(parser) - bindings897 = _t1690 - _t1691 = parse_formula(parser) - formula898 = _t1691 + _t1704 = parse_bindings(parser) + bindings905 = _t1704 + _t1705 = parse_formula(parser) + formula906 = _t1705 consume_literal!(parser, ")") - _t1692 = Proto.Abstraction(vars=vcat(bindings897[1], !isnothing(bindings897[2]) ? bindings897[2] : []), value=formula898) - _t1693 = Proto.Exists(body=_t1692) - result900 = _t1693 - record_span!(parser, span_start899, "Exists") - return result900 + _t1706 = Proto.Abstraction(vars=vcat(bindings905[1], !isnothing(bindings905[2]) ? bindings905[2] : []), value=formula906) + _t1707 = Proto.Exists(body=_t1706) + result908 = _t1707 + record_span!(parser, span_start907, "Exists") + return result908 end function parse_reduce(parser::ParserState)::Proto.Reduce - span_start904 = span_start(parser) + span_start912 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "reduce") - _t1694 = parse_abstraction(parser) - abstraction901 = _t1694 - _t1695 = parse_abstraction(parser) - abstraction_3902 = _t1695 - _t1696 = parse_terms(parser) - terms903 = _t1696 + _t1708 = parse_abstraction(parser) + abstraction909 = _t1708 + _t1709 = parse_abstraction(parser) + abstraction_3910 = _t1709 + _t1710 = parse_terms(parser) + terms911 = _t1710 consume_literal!(parser, ")") - _t1697 = Proto.Reduce(op=abstraction901, body=abstraction_3902, terms=terms903) - result905 = _t1697 - record_span!(parser, span_start904, "Reduce") - return result905 + _t1711 = Proto.Reduce(op=abstraction909, body=abstraction_3910, terms=terms911) + result913 = _t1711 + record_span!(parser, span_start912, "Reduce") + return result913 end function parse_terms(parser::ParserState)::Vector{Proto.Term} consume_literal!(parser, "(") consume_literal!(parser, "terms") - xs906 = Proto.Term[] - cond907 = (((((((((((((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 cond907 - _t1698 = parse_term(parser) - item908 = _t1698 - push!(xs906, item908) - cond907 = (((((((((((((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 - terms909 = xs906 + xs914 = Proto.Term[] + cond915 = (((((((((((((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 cond915 + _t1712 = parse_term(parser) + item916 = _t1712 + push!(xs914, item916) + cond915 = (((((((((((((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 + terms917 = xs914 consume_literal!(parser, ")") - return terms909 + return terms917 end function parse_term(parser::ParserState)::Proto.Term - span_start913 = span_start(parser) + span_start921 = span_start(parser) if match_lookahead_literal(parser, "true", 0) - _t1699 = 1 + _t1713 = 1 else if match_lookahead_literal(parser, "missing", 0) - _t1700 = 1 + _t1714 = 1 else if match_lookahead_literal(parser, "false", 0) - _t1701 = 1 + _t1715 = 1 else if match_lookahead_literal(parser, "(", 0) - _t1702 = 1 + _t1716 = 1 else if match_lookahead_terminal(parser, "SYMBOL", 0) - _t1703 = 0 + _t1717 = 0 else if match_lookahead_terminal(parser, "UINT32", 0) - _t1704 = 1 + _t1718 = 1 else if match_lookahead_terminal(parser, "UINT128", 0) - _t1705 = 1 + _t1719 = 1 else if match_lookahead_terminal(parser, "STRING", 0) - _t1706 = 1 + _t1720 = 1 else if match_lookahead_terminal(parser, "INT32", 0) - _t1707 = 1 + _t1721 = 1 else if match_lookahead_terminal(parser, "INT128", 0) - _t1708 = 1 + _t1722 = 1 else if match_lookahead_terminal(parser, "INT", 0) - _t1709 = 1 + _t1723 = 1 else if match_lookahead_terminal(parser, "FLOAT32", 0) - _t1710 = 1 + _t1724 = 1 else if match_lookahead_terminal(parser, "FLOAT", 0) - _t1711 = 1 + _t1725 = 1 else if match_lookahead_terminal(parser, "DECIMAL", 0) - _t1712 = 1 + _t1726 = 1 else - _t1712 = -1 + _t1726 = -1 end - _t1711 = _t1712 + _t1725 = _t1726 end - _t1710 = _t1711 + _t1724 = _t1725 end - _t1709 = _t1710 + _t1723 = _t1724 end - _t1708 = _t1709 + _t1722 = _t1723 end - _t1707 = _t1708 + _t1721 = _t1722 end - _t1706 = _t1707 + _t1720 = _t1721 end - _t1705 = _t1706 + _t1719 = _t1720 end - _t1704 = _t1705 + _t1718 = _t1719 end - _t1703 = _t1704 + _t1717 = _t1718 end - _t1702 = _t1703 + _t1716 = _t1717 end - _t1701 = _t1702 + _t1715 = _t1716 end - _t1700 = _t1701 + _t1714 = _t1715 end - _t1699 = _t1700 - end - prediction910 = _t1699 - if prediction910 == 1 - _t1714 = parse_value(parser) - value912 = _t1714 - _t1715 = Proto.Term(term_type=OneOf(:constant, value912)) - _t1713 = _t1715 + _t1713 = _t1714 + end + prediction918 = _t1713 + if prediction918 == 1 + _t1728 = parse_value(parser) + value920 = _t1728 + _t1729 = Proto.Term(term_type=OneOf(:constant, value920)) + _t1727 = _t1729 else - if prediction910 == 0 - _t1717 = parse_var(parser) - var911 = _t1717 - _t1718 = Proto.Term(term_type=OneOf(:var, var911)) - _t1716 = _t1718 + if prediction918 == 0 + _t1731 = parse_var(parser) + var919 = _t1731 + _t1732 = Proto.Term(term_type=OneOf(:var, var919)) + _t1730 = _t1732 else throw(ParseError("Unexpected token in term" * ": " * string(lookahead(parser, 0)))) end - _t1713 = _t1716 + _t1727 = _t1730 end - result914 = _t1713 - record_span!(parser, span_start913, "Term") - return result914 + result922 = _t1727 + record_span!(parser, span_start921, "Term") + return result922 end function parse_var(parser::ParserState)::Proto.Var - span_start916 = span_start(parser) - symbol915 = consume_terminal!(parser, "SYMBOL") - _t1719 = Proto.Var(name=symbol915) - result917 = _t1719 - record_span!(parser, span_start916, "Var") - return result917 + span_start924 = span_start(parser) + symbol923 = consume_terminal!(parser, "SYMBOL") + _t1733 = Proto.Var(name=symbol923) + result925 = _t1733 + record_span!(parser, span_start924, "Var") + return result925 end function parse_value(parser::ParserState)::Proto.Value - span_start931 = span_start(parser) + span_start939 = span_start(parser) if match_lookahead_literal(parser, "true", 0) - _t1720 = 12 + _t1734 = 12 else if match_lookahead_literal(parser, "missing", 0) - _t1721 = 11 + _t1735 = 11 else if match_lookahead_literal(parser, "false", 0) - _t1722 = 12 + _t1736 = 12 else if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "datetime", 1) - _t1724 = 1 + _t1738 = 1 else if match_lookahead_literal(parser, "date", 1) - _t1725 = 0 + _t1739 = 0 else - _t1725 = -1 + _t1739 = -1 end - _t1724 = _t1725 + _t1738 = _t1739 end - _t1723 = _t1724 + _t1737 = _t1738 else if match_lookahead_terminal(parser, "UINT32", 0) - _t1726 = 7 + _t1740 = 7 else if match_lookahead_terminal(parser, "UINT128", 0) - _t1727 = 8 + _t1741 = 8 else if match_lookahead_terminal(parser, "STRING", 0) - _t1728 = 2 + _t1742 = 2 else if match_lookahead_terminal(parser, "INT32", 0) - _t1729 = 3 + _t1743 = 3 else if match_lookahead_terminal(parser, "INT128", 0) - _t1730 = 9 + _t1744 = 9 else if match_lookahead_terminal(parser, "INT", 0) - _t1731 = 4 + _t1745 = 4 else if match_lookahead_terminal(parser, "FLOAT32", 0) - _t1732 = 5 + _t1746 = 5 else if match_lookahead_terminal(parser, "FLOAT", 0) - _t1733 = 6 + _t1747 = 6 else if match_lookahead_terminal(parser, "DECIMAL", 0) - _t1734 = 10 + _t1748 = 10 else - _t1734 = -1 + _t1748 = -1 end - _t1733 = _t1734 + _t1747 = _t1748 end - _t1732 = _t1733 + _t1746 = _t1747 end - _t1731 = _t1732 + _t1745 = _t1746 end - _t1730 = _t1731 + _t1744 = _t1745 end - _t1729 = _t1730 + _t1743 = _t1744 end - _t1728 = _t1729 + _t1742 = _t1743 end - _t1727 = _t1728 + _t1741 = _t1742 end - _t1726 = _t1727 + _t1740 = _t1741 end - _t1723 = _t1726 + _t1737 = _t1740 end - _t1722 = _t1723 + _t1736 = _t1737 end - _t1721 = _t1722 + _t1735 = _t1736 end - _t1720 = _t1721 - end - prediction918 = _t1720 - if prediction918 == 12 - _t1736 = parse_boolean_value(parser) - boolean_value930 = _t1736 - _t1737 = Proto.Value(value=OneOf(:boolean_value, boolean_value930)) - _t1735 = _t1737 + _t1734 = _t1735 + end + prediction926 = _t1734 + if prediction926 == 12 + _t1750 = parse_boolean_value(parser) + boolean_value938 = _t1750 + _t1751 = Proto.Value(value=OneOf(:boolean_value, boolean_value938)) + _t1749 = _t1751 else - if prediction918 == 11 + if prediction926 == 11 consume_literal!(parser, "missing") - _t1739 = Proto.MissingValue() - _t1740 = Proto.Value(value=OneOf(:missing_value, _t1739)) - _t1738 = _t1740 + _t1753 = Proto.MissingValue() + _t1754 = Proto.Value(value=OneOf(:missing_value, _t1753)) + _t1752 = _t1754 else - if prediction918 == 10 - formatted_decimal929 = consume_terminal!(parser, "DECIMAL") - _t1742 = Proto.Value(value=OneOf(:decimal_value, formatted_decimal929)) - _t1741 = _t1742 + if prediction926 == 10 + formatted_decimal937 = consume_terminal!(parser, "DECIMAL") + _t1756 = Proto.Value(value=OneOf(:decimal_value, formatted_decimal937)) + _t1755 = _t1756 else - if prediction918 == 9 - formatted_int128928 = consume_terminal!(parser, "INT128") - _t1744 = Proto.Value(value=OneOf(:int128_value, formatted_int128928)) - _t1743 = _t1744 + if prediction926 == 9 + formatted_int128936 = consume_terminal!(parser, "INT128") + _t1758 = Proto.Value(value=OneOf(:int128_value, formatted_int128936)) + _t1757 = _t1758 else - if prediction918 == 8 - formatted_uint128927 = consume_terminal!(parser, "UINT128") - _t1746 = Proto.Value(value=OneOf(:uint128_value, formatted_uint128927)) - _t1745 = _t1746 + if prediction926 == 8 + formatted_uint128935 = consume_terminal!(parser, "UINT128") + _t1760 = Proto.Value(value=OneOf(:uint128_value, formatted_uint128935)) + _t1759 = _t1760 else - if prediction918 == 7 - formatted_uint32926 = consume_terminal!(parser, "UINT32") - _t1748 = Proto.Value(value=OneOf(:uint32_value, formatted_uint32926)) - _t1747 = _t1748 + if prediction926 == 7 + formatted_uint32934 = consume_terminal!(parser, "UINT32") + _t1762 = Proto.Value(value=OneOf(:uint32_value, formatted_uint32934)) + _t1761 = _t1762 else - if prediction918 == 6 - formatted_float925 = consume_terminal!(parser, "FLOAT") - _t1750 = Proto.Value(value=OneOf(:float_value, formatted_float925)) - _t1749 = _t1750 + if prediction926 == 6 + formatted_float933 = consume_terminal!(parser, "FLOAT") + _t1764 = Proto.Value(value=OneOf(:float_value, formatted_float933)) + _t1763 = _t1764 else - if prediction918 == 5 - formatted_float32924 = consume_terminal!(parser, "FLOAT32") - _t1752 = Proto.Value(value=OneOf(:float32_value, formatted_float32924)) - _t1751 = _t1752 + if prediction926 == 5 + formatted_float32932 = consume_terminal!(parser, "FLOAT32") + _t1766 = Proto.Value(value=OneOf(:float32_value, formatted_float32932)) + _t1765 = _t1766 else - if prediction918 == 4 - formatted_int923 = consume_terminal!(parser, "INT") - _t1754 = Proto.Value(value=OneOf(:int_value, formatted_int923)) - _t1753 = _t1754 + if prediction926 == 4 + formatted_int931 = consume_terminal!(parser, "INT") + _t1768 = Proto.Value(value=OneOf(:int_value, formatted_int931)) + _t1767 = _t1768 else - if prediction918 == 3 - formatted_int32922 = consume_terminal!(parser, "INT32") - _t1756 = Proto.Value(value=OneOf(:int32_value, formatted_int32922)) - _t1755 = _t1756 + if prediction926 == 3 + formatted_int32930 = consume_terminal!(parser, "INT32") + _t1770 = Proto.Value(value=OneOf(:int32_value, formatted_int32930)) + _t1769 = _t1770 else - if prediction918 == 2 - formatted_string921 = consume_terminal!(parser, "STRING") - _t1758 = Proto.Value(value=OneOf(:string_value, formatted_string921)) - _t1757 = _t1758 + if prediction926 == 2 + formatted_string929 = consume_terminal!(parser, "STRING") + _t1772 = Proto.Value(value=OneOf(:string_value, formatted_string929)) + _t1771 = _t1772 else - if prediction918 == 1 - _t1760 = parse_datetime(parser) - datetime920 = _t1760 - _t1761 = Proto.Value(value=OneOf(:datetime_value, datetime920)) - _t1759 = _t1761 + if prediction926 == 1 + _t1774 = parse_datetime(parser) + datetime928 = _t1774 + _t1775 = Proto.Value(value=OneOf(:datetime_value, datetime928)) + _t1773 = _t1775 else - if prediction918 == 0 - _t1763 = parse_date(parser) - date919 = _t1763 - _t1764 = Proto.Value(value=OneOf(:date_value, date919)) - _t1762 = _t1764 + if prediction926 == 0 + _t1777 = parse_date(parser) + date927 = _t1777 + _t1778 = Proto.Value(value=OneOf(:date_value, date927)) + _t1776 = _t1778 else throw(ParseError("Unexpected token in value" * ": " * string(lookahead(parser, 0)))) end - _t1759 = _t1762 + _t1773 = _t1776 end - _t1757 = _t1759 + _t1771 = _t1773 end - _t1755 = _t1757 + _t1769 = _t1771 end - _t1753 = _t1755 + _t1767 = _t1769 end - _t1751 = _t1753 + _t1765 = _t1767 end - _t1749 = _t1751 + _t1763 = _t1765 end - _t1747 = _t1749 + _t1761 = _t1763 end - _t1745 = _t1747 + _t1759 = _t1761 end - _t1743 = _t1745 + _t1757 = _t1759 end - _t1741 = _t1743 + _t1755 = _t1757 end - _t1738 = _t1741 + _t1752 = _t1755 end - _t1735 = _t1738 + _t1749 = _t1752 end - result932 = _t1735 - record_span!(parser, span_start931, "Value") - return result932 + result940 = _t1749 + record_span!(parser, span_start939, "Value") + return result940 end function parse_date(parser::ParserState)::Proto.DateValue - span_start936 = span_start(parser) + span_start944 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "date") - formatted_int933 = consume_terminal!(parser, "INT") - formatted_int_3934 = consume_terminal!(parser, "INT") - formatted_int_4935 = consume_terminal!(parser, "INT") + formatted_int941 = consume_terminal!(parser, "INT") + formatted_int_3942 = consume_terminal!(parser, "INT") + formatted_int_4943 = consume_terminal!(parser, "INT") consume_literal!(parser, ")") - _t1765 = Proto.DateValue(year=Int32(formatted_int933), month=Int32(formatted_int_3934), day=Int32(formatted_int_4935)) - result937 = _t1765 - record_span!(parser, span_start936, "DateValue") - return result937 + _t1779 = Proto.DateValue(year=Int32(formatted_int941), month=Int32(formatted_int_3942), day=Int32(formatted_int_4943)) + result945 = _t1779 + record_span!(parser, span_start944, "DateValue") + return result945 end function parse_datetime(parser::ParserState)::Proto.DateTimeValue - span_start945 = span_start(parser) + span_start953 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "datetime") - formatted_int938 = consume_terminal!(parser, "INT") - formatted_int_3939 = consume_terminal!(parser, "INT") - formatted_int_4940 = consume_terminal!(parser, "INT") - formatted_int_5941 = consume_terminal!(parser, "INT") - formatted_int_6942 = consume_terminal!(parser, "INT") - formatted_int_7943 = consume_terminal!(parser, "INT") + formatted_int946 = consume_terminal!(parser, "INT") + formatted_int_3947 = consume_terminal!(parser, "INT") + formatted_int_4948 = consume_terminal!(parser, "INT") + formatted_int_5949 = consume_terminal!(parser, "INT") + formatted_int_6950 = consume_terminal!(parser, "INT") + formatted_int_7951 = consume_terminal!(parser, "INT") if match_lookahead_terminal(parser, "INT", 0) - _t1766 = consume_terminal!(parser, "INT") + _t1780 = consume_terminal!(parser, "INT") else - _t1766 = nothing + _t1780 = nothing end - formatted_int_8944 = _t1766 + formatted_int_8952 = _t1780 consume_literal!(parser, ")") - _t1767 = Proto.DateTimeValue(year=Int32(formatted_int938), month=Int32(formatted_int_3939), day=Int32(formatted_int_4940), hour=Int32(formatted_int_5941), minute=Int32(formatted_int_6942), second=Int32(formatted_int_7943), microsecond=Int32((!isnothing(formatted_int_8944) ? formatted_int_8944 : 0))) - result946 = _t1767 - record_span!(parser, span_start945, "DateTimeValue") - return result946 + _t1781 = Proto.DateTimeValue(year=Int32(formatted_int946), month=Int32(formatted_int_3947), day=Int32(formatted_int_4948), hour=Int32(formatted_int_5949), minute=Int32(formatted_int_6950), second=Int32(formatted_int_7951), microsecond=Int32((!isnothing(formatted_int_8952) ? formatted_int_8952 : 0))) + result954 = _t1781 + record_span!(parser, span_start953, "DateTimeValue") + return result954 end function parse_conjunction(parser::ParserState)::Proto.Conjunction - span_start951 = span_start(parser) + span_start959 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "and") - xs947 = Proto.Formula[] - cond948 = match_lookahead_literal(parser, "(", 0) - while cond948 - _t1768 = parse_formula(parser) - item949 = _t1768 - push!(xs947, item949) - cond948 = match_lookahead_literal(parser, "(", 0) - end - formulas950 = xs947 + xs955 = Proto.Formula[] + cond956 = match_lookahead_literal(parser, "(", 0) + while cond956 + _t1782 = parse_formula(parser) + item957 = _t1782 + push!(xs955, item957) + cond956 = match_lookahead_literal(parser, "(", 0) + end + formulas958 = xs955 consume_literal!(parser, ")") - _t1769 = Proto.Conjunction(args=formulas950) - result952 = _t1769 - record_span!(parser, span_start951, "Conjunction") - return result952 + _t1783 = Proto.Conjunction(args=formulas958) + result960 = _t1783 + record_span!(parser, span_start959, "Conjunction") + return result960 end function parse_disjunction(parser::ParserState)::Proto.Disjunction - span_start957 = span_start(parser) + span_start965 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "or") - xs953 = Proto.Formula[] - cond954 = match_lookahead_literal(parser, "(", 0) - while cond954 - _t1770 = parse_formula(parser) - item955 = _t1770 - push!(xs953, item955) - cond954 = match_lookahead_literal(parser, "(", 0) - end - formulas956 = xs953 + xs961 = Proto.Formula[] + cond962 = match_lookahead_literal(parser, "(", 0) + while cond962 + _t1784 = parse_formula(parser) + item963 = _t1784 + push!(xs961, item963) + cond962 = match_lookahead_literal(parser, "(", 0) + end + formulas964 = xs961 consume_literal!(parser, ")") - _t1771 = Proto.Disjunction(args=formulas956) - result958 = _t1771 - record_span!(parser, span_start957, "Disjunction") - return result958 + _t1785 = Proto.Disjunction(args=formulas964) + result966 = _t1785 + record_span!(parser, span_start965, "Disjunction") + return result966 end function parse_not(parser::ParserState)::Proto.Not - span_start960 = span_start(parser) + span_start968 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "not") - _t1772 = parse_formula(parser) - formula959 = _t1772 + _t1786 = parse_formula(parser) + formula967 = _t1786 consume_literal!(parser, ")") - _t1773 = Proto.Not(arg=formula959) - result961 = _t1773 - record_span!(parser, span_start960, "Not") - return result961 + _t1787 = Proto.Not(arg=formula967) + result969 = _t1787 + record_span!(parser, span_start968, "Not") + return result969 end function parse_ffi(parser::ParserState)::Proto.FFI - span_start965 = span_start(parser) + span_start973 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "ffi") - _t1774 = parse_name(parser) - name962 = _t1774 - _t1775 = parse_ffi_args(parser) - ffi_args963 = _t1775 - _t1776 = parse_terms(parser) - terms964 = _t1776 + _t1788 = parse_name(parser) + name970 = _t1788 + _t1789 = parse_ffi_args(parser) + ffi_args971 = _t1789 + _t1790 = parse_terms(parser) + terms972 = _t1790 consume_literal!(parser, ")") - _t1777 = Proto.FFI(name=name962, args=ffi_args963, terms=terms964) - result966 = _t1777 - record_span!(parser, span_start965, "FFI") - return result966 + _t1791 = Proto.FFI(name=name970, args=ffi_args971, terms=terms972) + result974 = _t1791 + record_span!(parser, span_start973, "FFI") + return result974 end function parse_name(parser::ParserState)::String consume_literal!(parser, ":") - symbol967 = consume_terminal!(parser, "SYMBOL") - return symbol967 + symbol975 = consume_terminal!(parser, "SYMBOL") + return symbol975 end function parse_ffi_args(parser::ParserState)::Vector{Proto.Abstraction} consume_literal!(parser, "(") consume_literal!(parser, "args") - xs968 = Proto.Abstraction[] - cond969 = match_lookahead_literal(parser, "(", 0) - while cond969 - _t1778 = parse_abstraction(parser) - item970 = _t1778 - push!(xs968, item970) - cond969 = match_lookahead_literal(parser, "(", 0) - end - abstractions971 = xs968 + xs976 = Proto.Abstraction[] + cond977 = match_lookahead_literal(parser, "(", 0) + while cond977 + _t1792 = parse_abstraction(parser) + item978 = _t1792 + push!(xs976, item978) + cond977 = match_lookahead_literal(parser, "(", 0) + end + abstractions979 = xs976 consume_literal!(parser, ")") - return abstractions971 + return abstractions979 end function parse_atom(parser::ParserState)::Proto.Atom - span_start977 = span_start(parser) + span_start985 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "atom") - _t1779 = parse_relation_id(parser) - relation_id972 = _t1779 - xs973 = Proto.Term[] - cond974 = (((((((((((((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 cond974 - _t1780 = parse_term(parser) - item975 = _t1780 - push!(xs973, item975) - cond974 = (((((((((((((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 - terms976 = xs973 + _t1793 = parse_relation_id(parser) + relation_id980 = _t1793 + xs981 = Proto.Term[] + cond982 = (((((((((((((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 cond982 + _t1794 = parse_term(parser) + item983 = _t1794 + push!(xs981, item983) + cond982 = (((((((((((((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 + terms984 = xs981 consume_literal!(parser, ")") - _t1781 = Proto.Atom(name=relation_id972, terms=terms976) - result978 = _t1781 - record_span!(parser, span_start977, "Atom") - return result978 + _t1795 = Proto.Atom(name=relation_id980, terms=terms984) + result986 = _t1795 + record_span!(parser, span_start985, "Atom") + return result986 end function parse_pragma(parser::ParserState)::Proto.Pragma - span_start984 = span_start(parser) + span_start992 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "pragma") - _t1782 = parse_name(parser) - name979 = _t1782 - xs980 = Proto.Term[] - cond981 = (((((((((((((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 cond981 - _t1783 = parse_term(parser) - item982 = _t1783 - push!(xs980, item982) - cond981 = (((((((((((((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 - terms983 = xs980 + _t1796 = parse_name(parser) + name987 = _t1796 + xs988 = Proto.Term[] + cond989 = (((((((((((((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 cond989 + _t1797 = parse_term(parser) + item990 = _t1797 + push!(xs988, item990) + cond989 = (((((((((((((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 + terms991 = xs988 consume_literal!(parser, ")") - _t1784 = Proto.Pragma(name=name979, terms=terms983) - result985 = _t1784 - record_span!(parser, span_start984, "Pragma") - return result985 + _t1798 = Proto.Pragma(name=name987, terms=terms991) + result993 = _t1798 + record_span!(parser, span_start992, "Pragma") + return result993 end function parse_primitive(parser::ParserState)::Proto.Primitive - span_start1001 = span_start(parser) + span_start1009 = span_start(parser) if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "primitive", 1) - _t1786 = 9 + _t1800 = 9 else if match_lookahead_literal(parser, ">=", 1) - _t1787 = 4 + _t1801 = 4 else if match_lookahead_literal(parser, ">", 1) - _t1788 = 3 + _t1802 = 3 else if match_lookahead_literal(parser, "=", 1) - _t1789 = 0 + _t1803 = 0 else if match_lookahead_literal(parser, "<=", 1) - _t1790 = 2 + _t1804 = 2 else if match_lookahead_literal(parser, "<", 1) - _t1791 = 1 + _t1805 = 1 else if match_lookahead_literal(parser, "/", 1) - _t1792 = 8 + _t1806 = 8 else if match_lookahead_literal(parser, "-", 1) - _t1793 = 6 + _t1807 = 6 else if match_lookahead_literal(parser, "+", 1) - _t1794 = 5 + _t1808 = 5 else if match_lookahead_literal(parser, "*", 1) - _t1795 = 7 + _t1809 = 7 else - _t1795 = -1 + _t1809 = -1 end - _t1794 = _t1795 + _t1808 = _t1809 end - _t1793 = _t1794 + _t1807 = _t1808 end - _t1792 = _t1793 + _t1806 = _t1807 end - _t1791 = _t1792 + _t1805 = _t1806 end - _t1790 = _t1791 + _t1804 = _t1805 end - _t1789 = _t1790 + _t1803 = _t1804 end - _t1788 = _t1789 + _t1802 = _t1803 end - _t1787 = _t1788 + _t1801 = _t1802 end - _t1786 = _t1787 + _t1800 = _t1801 end - _t1785 = _t1786 + _t1799 = _t1800 else - _t1785 = -1 + _t1799 = -1 end - prediction986 = _t1785 - if prediction986 == 9 + prediction994 = _t1799 + if prediction994 == 9 consume_literal!(parser, "(") consume_literal!(parser, "primitive") - _t1797 = parse_name(parser) - name996 = _t1797 - xs997 = Proto.RelTerm[] - cond998 = ((((((((((((((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 cond998 - _t1798 = parse_rel_term(parser) - item999 = _t1798 - push!(xs997, item999) - cond998 = ((((((((((((((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)) + _t1811 = parse_name(parser) + name1004 = _t1811 + xs1005 = Proto.RelTerm[] + cond1006 = ((((((((((((((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 cond1006 + _t1812 = parse_rel_term(parser) + item1007 = _t1812 + push!(xs1005, item1007) + cond1006 = ((((((((((((((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_terms1000 = xs997 + rel_terms1008 = xs1005 consume_literal!(parser, ")") - _t1799 = Proto.Primitive(name=name996, terms=rel_terms1000) - _t1796 = _t1799 + _t1813 = Proto.Primitive(name=name1004, terms=rel_terms1008) + _t1810 = _t1813 else - if prediction986 == 8 - _t1801 = parse_divide(parser) - divide995 = _t1801 - _t1800 = divide995 + if prediction994 == 8 + _t1815 = parse_divide(parser) + divide1003 = _t1815 + _t1814 = divide1003 else - if prediction986 == 7 - _t1803 = parse_multiply(parser) - multiply994 = _t1803 - _t1802 = multiply994 + if prediction994 == 7 + _t1817 = parse_multiply(parser) + multiply1002 = _t1817 + _t1816 = multiply1002 else - if prediction986 == 6 - _t1805 = parse_minus(parser) - minus993 = _t1805 - _t1804 = minus993 + if prediction994 == 6 + _t1819 = parse_minus(parser) + minus1001 = _t1819 + _t1818 = minus1001 else - if prediction986 == 5 - _t1807 = parse_add(parser) - add992 = _t1807 - _t1806 = add992 + if prediction994 == 5 + _t1821 = parse_add(parser) + add1000 = _t1821 + _t1820 = add1000 else - if prediction986 == 4 - _t1809 = parse_gt_eq(parser) - gt_eq991 = _t1809 - _t1808 = gt_eq991 + if prediction994 == 4 + _t1823 = parse_gt_eq(parser) + gt_eq999 = _t1823 + _t1822 = gt_eq999 else - if prediction986 == 3 - _t1811 = parse_gt(parser) - gt990 = _t1811 - _t1810 = gt990 + if prediction994 == 3 + _t1825 = parse_gt(parser) + gt998 = _t1825 + _t1824 = gt998 else - if prediction986 == 2 - _t1813 = parse_lt_eq(parser) - lt_eq989 = _t1813 - _t1812 = lt_eq989 + if prediction994 == 2 + _t1827 = parse_lt_eq(parser) + lt_eq997 = _t1827 + _t1826 = lt_eq997 else - if prediction986 == 1 - _t1815 = parse_lt(parser) - lt988 = _t1815 - _t1814 = lt988 + if prediction994 == 1 + _t1829 = parse_lt(parser) + lt996 = _t1829 + _t1828 = lt996 else - if prediction986 == 0 - _t1817 = parse_eq(parser) - eq987 = _t1817 - _t1816 = eq987 + if prediction994 == 0 + _t1831 = parse_eq(parser) + eq995 = _t1831 + _t1830 = eq995 else throw(ParseError("Unexpected token in primitive" * ": " * string(lookahead(parser, 0)))) end - _t1814 = _t1816 + _t1828 = _t1830 end - _t1812 = _t1814 + _t1826 = _t1828 end - _t1810 = _t1812 + _t1824 = _t1826 end - _t1808 = _t1810 + _t1822 = _t1824 end - _t1806 = _t1808 + _t1820 = _t1822 end - _t1804 = _t1806 + _t1818 = _t1820 end - _t1802 = _t1804 + _t1816 = _t1818 end - _t1800 = _t1802 + _t1814 = _t1816 end - _t1796 = _t1800 + _t1810 = _t1814 end - result1002 = _t1796 - record_span!(parser, span_start1001, "Primitive") - return result1002 + result1010 = _t1810 + record_span!(parser, span_start1009, "Primitive") + return result1010 end function parse_eq(parser::ParserState)::Proto.Primitive - span_start1005 = span_start(parser) + span_start1013 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "=") - _t1818 = parse_term(parser) - term1003 = _t1818 - _t1819 = parse_term(parser) - term_31004 = _t1819 + _t1832 = parse_term(parser) + term1011 = _t1832 + _t1833 = parse_term(parser) + term_31012 = _t1833 consume_literal!(parser, ")") - _t1820 = Proto.RelTerm(rel_term_type=OneOf(:term, term1003)) - _t1821 = Proto.RelTerm(rel_term_type=OneOf(:term, term_31004)) - _t1822 = Proto.Primitive(name="rel_primitive_eq", terms=Proto.RelTerm[_t1820, _t1821]) - result1006 = _t1822 - record_span!(parser, span_start1005, "Primitive") - return result1006 + _t1834 = Proto.RelTerm(rel_term_type=OneOf(:term, term1011)) + _t1835 = Proto.RelTerm(rel_term_type=OneOf(:term, term_31012)) + _t1836 = Proto.Primitive(name="rel_primitive_eq", terms=Proto.RelTerm[_t1834, _t1835]) + result1014 = _t1836 + record_span!(parser, span_start1013, "Primitive") + return result1014 end function parse_lt(parser::ParserState)::Proto.Primitive - span_start1009 = span_start(parser) + span_start1017 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "<") - _t1823 = parse_term(parser) - term1007 = _t1823 - _t1824 = parse_term(parser) - term_31008 = _t1824 + _t1837 = parse_term(parser) + term1015 = _t1837 + _t1838 = parse_term(parser) + term_31016 = _t1838 consume_literal!(parser, ")") - _t1825 = Proto.RelTerm(rel_term_type=OneOf(:term, term1007)) - _t1826 = Proto.RelTerm(rel_term_type=OneOf(:term, term_31008)) - _t1827 = Proto.Primitive(name="rel_primitive_lt_monotype", terms=Proto.RelTerm[_t1825, _t1826]) - result1010 = _t1827 - record_span!(parser, span_start1009, "Primitive") - return result1010 + _t1839 = Proto.RelTerm(rel_term_type=OneOf(:term, term1015)) + _t1840 = Proto.RelTerm(rel_term_type=OneOf(:term, term_31016)) + _t1841 = Proto.Primitive(name="rel_primitive_lt_monotype", terms=Proto.RelTerm[_t1839, _t1840]) + result1018 = _t1841 + record_span!(parser, span_start1017, "Primitive") + return result1018 end function parse_lt_eq(parser::ParserState)::Proto.Primitive - span_start1013 = span_start(parser) + span_start1021 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "<=") - _t1828 = parse_term(parser) - term1011 = _t1828 - _t1829 = parse_term(parser) - term_31012 = _t1829 + _t1842 = parse_term(parser) + term1019 = _t1842 + _t1843 = parse_term(parser) + term_31020 = _t1843 consume_literal!(parser, ")") - _t1830 = Proto.RelTerm(rel_term_type=OneOf(:term, term1011)) - _t1831 = Proto.RelTerm(rel_term_type=OneOf(:term, term_31012)) - _t1832 = Proto.Primitive(name="rel_primitive_lt_eq_monotype", terms=Proto.RelTerm[_t1830, _t1831]) - result1014 = _t1832 - record_span!(parser, span_start1013, "Primitive") - return result1014 + _t1844 = Proto.RelTerm(rel_term_type=OneOf(:term, term1019)) + _t1845 = Proto.RelTerm(rel_term_type=OneOf(:term, term_31020)) + _t1846 = Proto.Primitive(name="rel_primitive_lt_eq_monotype", terms=Proto.RelTerm[_t1844, _t1845]) + result1022 = _t1846 + record_span!(parser, span_start1021, "Primitive") + return result1022 end function parse_gt(parser::ParserState)::Proto.Primitive - span_start1017 = span_start(parser) + span_start1025 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, ">") - _t1833 = parse_term(parser) - term1015 = _t1833 - _t1834 = parse_term(parser) - term_31016 = _t1834 + _t1847 = parse_term(parser) + term1023 = _t1847 + _t1848 = parse_term(parser) + term_31024 = _t1848 consume_literal!(parser, ")") - _t1835 = Proto.RelTerm(rel_term_type=OneOf(:term, term1015)) - _t1836 = Proto.RelTerm(rel_term_type=OneOf(:term, term_31016)) - _t1837 = Proto.Primitive(name="rel_primitive_gt_monotype", terms=Proto.RelTerm[_t1835, _t1836]) - result1018 = _t1837 - record_span!(parser, span_start1017, "Primitive") - return result1018 + _t1849 = Proto.RelTerm(rel_term_type=OneOf(:term, term1023)) + _t1850 = Proto.RelTerm(rel_term_type=OneOf(:term, term_31024)) + _t1851 = Proto.Primitive(name="rel_primitive_gt_monotype", terms=Proto.RelTerm[_t1849, _t1850]) + result1026 = _t1851 + record_span!(parser, span_start1025, "Primitive") + return result1026 end function parse_gt_eq(parser::ParserState)::Proto.Primitive - span_start1021 = span_start(parser) + span_start1029 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, ">=") - _t1838 = parse_term(parser) - term1019 = _t1838 - _t1839 = parse_term(parser) - term_31020 = _t1839 + _t1852 = parse_term(parser) + term1027 = _t1852 + _t1853 = parse_term(parser) + term_31028 = _t1853 consume_literal!(parser, ")") - _t1840 = Proto.RelTerm(rel_term_type=OneOf(:term, term1019)) - _t1841 = Proto.RelTerm(rel_term_type=OneOf(:term, term_31020)) - _t1842 = Proto.Primitive(name="rel_primitive_gt_eq_monotype", terms=Proto.RelTerm[_t1840, _t1841]) - result1022 = _t1842 - record_span!(parser, span_start1021, "Primitive") - return result1022 + _t1854 = Proto.RelTerm(rel_term_type=OneOf(:term, term1027)) + _t1855 = Proto.RelTerm(rel_term_type=OneOf(:term, term_31028)) + _t1856 = Proto.Primitive(name="rel_primitive_gt_eq_monotype", terms=Proto.RelTerm[_t1854, _t1855]) + result1030 = _t1856 + record_span!(parser, span_start1029, "Primitive") + return result1030 end function parse_add(parser::ParserState)::Proto.Primitive - span_start1026 = span_start(parser) + span_start1034 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "+") - _t1843 = parse_term(parser) - term1023 = _t1843 - _t1844 = parse_term(parser) - term_31024 = _t1844 - _t1845 = parse_term(parser) - term_41025 = _t1845 + _t1857 = parse_term(parser) + term1031 = _t1857 + _t1858 = parse_term(parser) + term_31032 = _t1858 + _t1859 = parse_term(parser) + term_41033 = _t1859 consume_literal!(parser, ")") - _t1846 = Proto.RelTerm(rel_term_type=OneOf(:term, term1023)) - _t1847 = Proto.RelTerm(rel_term_type=OneOf(:term, term_31024)) - _t1848 = Proto.RelTerm(rel_term_type=OneOf(:term, term_41025)) - _t1849 = Proto.Primitive(name="rel_primitive_add_monotype", terms=Proto.RelTerm[_t1846, _t1847, _t1848]) - result1027 = _t1849 - record_span!(parser, span_start1026, "Primitive") - return result1027 + _t1860 = Proto.RelTerm(rel_term_type=OneOf(:term, term1031)) + _t1861 = Proto.RelTerm(rel_term_type=OneOf(:term, term_31032)) + _t1862 = Proto.RelTerm(rel_term_type=OneOf(:term, term_41033)) + _t1863 = Proto.Primitive(name="rel_primitive_add_monotype", terms=Proto.RelTerm[_t1860, _t1861, _t1862]) + result1035 = _t1863 + record_span!(parser, span_start1034, "Primitive") + return result1035 end function parse_minus(parser::ParserState)::Proto.Primitive - span_start1031 = span_start(parser) + span_start1039 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "-") - _t1850 = parse_term(parser) - term1028 = _t1850 - _t1851 = parse_term(parser) - term_31029 = _t1851 - _t1852 = parse_term(parser) - term_41030 = _t1852 + _t1864 = parse_term(parser) + term1036 = _t1864 + _t1865 = parse_term(parser) + term_31037 = _t1865 + _t1866 = parse_term(parser) + term_41038 = _t1866 consume_literal!(parser, ")") - _t1853 = Proto.RelTerm(rel_term_type=OneOf(:term, term1028)) - _t1854 = Proto.RelTerm(rel_term_type=OneOf(:term, term_31029)) - _t1855 = Proto.RelTerm(rel_term_type=OneOf(:term, term_41030)) - _t1856 = Proto.Primitive(name="rel_primitive_subtract_monotype", terms=Proto.RelTerm[_t1853, _t1854, _t1855]) - result1032 = _t1856 - record_span!(parser, span_start1031, "Primitive") - return result1032 + _t1867 = Proto.RelTerm(rel_term_type=OneOf(:term, term1036)) + _t1868 = Proto.RelTerm(rel_term_type=OneOf(:term, term_31037)) + _t1869 = Proto.RelTerm(rel_term_type=OneOf(:term, term_41038)) + _t1870 = Proto.Primitive(name="rel_primitive_subtract_monotype", terms=Proto.RelTerm[_t1867, _t1868, _t1869]) + result1040 = _t1870 + record_span!(parser, span_start1039, "Primitive") + return result1040 end function parse_multiply(parser::ParserState)::Proto.Primitive - span_start1036 = span_start(parser) + span_start1044 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "*") - _t1857 = parse_term(parser) - term1033 = _t1857 - _t1858 = parse_term(parser) - term_31034 = _t1858 - _t1859 = parse_term(parser) - term_41035 = _t1859 + _t1871 = parse_term(parser) + term1041 = _t1871 + _t1872 = parse_term(parser) + term_31042 = _t1872 + _t1873 = parse_term(parser) + term_41043 = _t1873 consume_literal!(parser, ")") - _t1860 = Proto.RelTerm(rel_term_type=OneOf(:term, term1033)) - _t1861 = Proto.RelTerm(rel_term_type=OneOf(:term, term_31034)) - _t1862 = Proto.RelTerm(rel_term_type=OneOf(:term, term_41035)) - _t1863 = Proto.Primitive(name="rel_primitive_multiply_monotype", terms=Proto.RelTerm[_t1860, _t1861, _t1862]) - result1037 = _t1863 - record_span!(parser, span_start1036, "Primitive") - return result1037 + _t1874 = Proto.RelTerm(rel_term_type=OneOf(:term, term1041)) + _t1875 = Proto.RelTerm(rel_term_type=OneOf(:term, term_31042)) + _t1876 = Proto.RelTerm(rel_term_type=OneOf(:term, term_41043)) + _t1877 = Proto.Primitive(name="rel_primitive_multiply_monotype", terms=Proto.RelTerm[_t1874, _t1875, _t1876]) + result1045 = _t1877 + record_span!(parser, span_start1044, "Primitive") + return result1045 end function parse_divide(parser::ParserState)::Proto.Primitive - span_start1041 = span_start(parser) + span_start1049 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "/") - _t1864 = parse_term(parser) - term1038 = _t1864 - _t1865 = parse_term(parser) - term_31039 = _t1865 - _t1866 = parse_term(parser) - term_41040 = _t1866 + _t1878 = parse_term(parser) + term1046 = _t1878 + _t1879 = parse_term(parser) + term_31047 = _t1879 + _t1880 = parse_term(parser) + term_41048 = _t1880 consume_literal!(parser, ")") - _t1867 = Proto.RelTerm(rel_term_type=OneOf(:term, term1038)) - _t1868 = Proto.RelTerm(rel_term_type=OneOf(:term, term_31039)) - _t1869 = Proto.RelTerm(rel_term_type=OneOf(:term, term_41040)) - _t1870 = Proto.Primitive(name="rel_primitive_divide_monotype", terms=Proto.RelTerm[_t1867, _t1868, _t1869]) - result1042 = _t1870 - record_span!(parser, span_start1041, "Primitive") - return result1042 + _t1881 = Proto.RelTerm(rel_term_type=OneOf(:term, term1046)) + _t1882 = Proto.RelTerm(rel_term_type=OneOf(:term, term_31047)) + _t1883 = Proto.RelTerm(rel_term_type=OneOf(:term, term_41048)) + _t1884 = Proto.Primitive(name="rel_primitive_divide_monotype", terms=Proto.RelTerm[_t1881, _t1882, _t1883]) + result1050 = _t1884 + record_span!(parser, span_start1049, "Primitive") + return result1050 end function parse_rel_term(parser::ParserState)::Proto.RelTerm - span_start1046 = span_start(parser) + span_start1054 = span_start(parser) if match_lookahead_literal(parser, "true", 0) - _t1871 = 1 + _t1885 = 1 else if match_lookahead_literal(parser, "missing", 0) - _t1872 = 1 + _t1886 = 1 else if match_lookahead_literal(parser, "false", 0) - _t1873 = 1 + _t1887 = 1 else if match_lookahead_literal(parser, "(", 0) - _t1874 = 1 + _t1888 = 1 else if match_lookahead_literal(parser, "#", 0) - _t1875 = 0 + _t1889 = 0 else if match_lookahead_terminal(parser, "SYMBOL", 0) - _t1876 = 1 + _t1890 = 1 else if match_lookahead_terminal(parser, "UINT32", 0) - _t1877 = 1 + _t1891 = 1 else if match_lookahead_terminal(parser, "UINT128", 0) - _t1878 = 1 + _t1892 = 1 else if match_lookahead_terminal(parser, "STRING", 0) - _t1879 = 1 + _t1893 = 1 else if match_lookahead_terminal(parser, "INT32", 0) - _t1880 = 1 + _t1894 = 1 else if match_lookahead_terminal(parser, "INT128", 0) - _t1881 = 1 + _t1895 = 1 else if match_lookahead_terminal(parser, "INT", 0) - _t1882 = 1 + _t1896 = 1 else if match_lookahead_terminal(parser, "FLOAT32", 0) - _t1883 = 1 + _t1897 = 1 else if match_lookahead_terminal(parser, "FLOAT", 0) - _t1884 = 1 + _t1898 = 1 else if match_lookahead_terminal(parser, "DECIMAL", 0) - _t1885 = 1 + _t1899 = 1 else - _t1885 = -1 + _t1899 = -1 end - _t1884 = _t1885 + _t1898 = _t1899 end - _t1883 = _t1884 + _t1897 = _t1898 end - _t1882 = _t1883 + _t1896 = _t1897 end - _t1881 = _t1882 + _t1895 = _t1896 end - _t1880 = _t1881 + _t1894 = _t1895 end - _t1879 = _t1880 + _t1893 = _t1894 end - _t1878 = _t1879 + _t1892 = _t1893 end - _t1877 = _t1878 + _t1891 = _t1892 end - _t1876 = _t1877 + _t1890 = _t1891 end - _t1875 = _t1876 + _t1889 = _t1890 end - _t1874 = _t1875 + _t1888 = _t1889 end - _t1873 = _t1874 + _t1887 = _t1888 end - _t1872 = _t1873 + _t1886 = _t1887 end - _t1871 = _t1872 - end - prediction1043 = _t1871 - if prediction1043 == 1 - _t1887 = parse_term(parser) - term1045 = _t1887 - _t1888 = Proto.RelTerm(rel_term_type=OneOf(:term, term1045)) - _t1886 = _t1888 + _t1885 = _t1886 + end + prediction1051 = _t1885 + if prediction1051 == 1 + _t1901 = parse_term(parser) + term1053 = _t1901 + _t1902 = Proto.RelTerm(rel_term_type=OneOf(:term, term1053)) + _t1900 = _t1902 else - if prediction1043 == 0 - _t1890 = parse_specialized_value(parser) - specialized_value1044 = _t1890 - _t1891 = Proto.RelTerm(rel_term_type=OneOf(:specialized_value, specialized_value1044)) - _t1889 = _t1891 + if prediction1051 == 0 + _t1904 = parse_specialized_value(parser) + specialized_value1052 = _t1904 + _t1905 = Proto.RelTerm(rel_term_type=OneOf(:specialized_value, specialized_value1052)) + _t1903 = _t1905 else throw(ParseError("Unexpected token in rel_term" * ": " * string(lookahead(parser, 0)))) end - _t1886 = _t1889 + _t1900 = _t1903 end - result1047 = _t1886 - record_span!(parser, span_start1046, "RelTerm") - return result1047 + result1055 = _t1900 + record_span!(parser, span_start1054, "RelTerm") + return result1055 end function parse_specialized_value(parser::ParserState)::Proto.Value - span_start1049 = span_start(parser) + span_start1057 = span_start(parser) consume_literal!(parser, "#") - _t1892 = parse_raw_value(parser) - raw_value1048 = _t1892 - result1050 = raw_value1048 - record_span!(parser, span_start1049, "Value") - return result1050 + _t1906 = parse_raw_value(parser) + raw_value1056 = _t1906 + result1058 = raw_value1056 + record_span!(parser, span_start1057, "Value") + return result1058 end function parse_rel_atom(parser::ParserState)::Proto.RelAtom - span_start1056 = span_start(parser) + span_start1064 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "relatom") - _t1893 = parse_name(parser) - name1051 = _t1893 - xs1052 = Proto.RelTerm[] - cond1053 = ((((((((((((((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 cond1053 - _t1894 = parse_rel_term(parser) - item1054 = _t1894 - push!(xs1052, item1054) - cond1053 = ((((((((((((((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_terms1055 = xs1052 + _t1907 = parse_name(parser) + name1059 = _t1907 + xs1060 = Proto.RelTerm[] + cond1061 = ((((((((((((((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 cond1061 + _t1908 = parse_rel_term(parser) + item1062 = _t1908 + push!(xs1060, item1062) + cond1061 = ((((((((((((((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_terms1063 = xs1060 consume_literal!(parser, ")") - _t1895 = Proto.RelAtom(name=name1051, terms=rel_terms1055) - result1057 = _t1895 - record_span!(parser, span_start1056, "RelAtom") - return result1057 + _t1909 = Proto.RelAtom(name=name1059, terms=rel_terms1063) + result1065 = _t1909 + record_span!(parser, span_start1064, "RelAtom") + return result1065 end function parse_cast(parser::ParserState)::Proto.Cast - span_start1060 = span_start(parser) + span_start1068 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "cast") - _t1896 = parse_term(parser) - term1058 = _t1896 - _t1897 = parse_term(parser) - term_31059 = _t1897 + _t1910 = parse_term(parser) + term1066 = _t1910 + _t1911 = parse_term(parser) + term_31067 = _t1911 consume_literal!(parser, ")") - _t1898 = Proto.Cast(input=term1058, result=term_31059) - result1061 = _t1898 - record_span!(parser, span_start1060, "Cast") - return result1061 + _t1912 = Proto.Cast(input=term1066, result=term_31067) + result1069 = _t1912 + record_span!(parser, span_start1068, "Cast") + return result1069 end function parse_attrs(parser::ParserState)::Vector{Proto.Attribute} consume_literal!(parser, "(") consume_literal!(parser, "attrs") - xs1062 = Proto.Attribute[] - cond1063 = match_lookahead_literal(parser, "(", 0) - while cond1063 - _t1899 = parse_attribute(parser) - item1064 = _t1899 - push!(xs1062, item1064) - cond1063 = match_lookahead_literal(parser, "(", 0) - end - attributes1065 = xs1062 + xs1070 = Proto.Attribute[] + cond1071 = match_lookahead_literal(parser, "(", 0) + while cond1071 + _t1913 = parse_attribute(parser) + item1072 = _t1913 + push!(xs1070, item1072) + cond1071 = match_lookahead_literal(parser, "(", 0) + end + attributes1073 = xs1070 consume_literal!(parser, ")") - return attributes1065 + return attributes1073 end function parse_attribute(parser::ParserState)::Proto.Attribute - span_start1071 = span_start(parser) + span_start1079 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "attribute") - _t1900 = parse_name(parser) - name1066 = _t1900 - xs1067 = Proto.Value[] - cond1068 = ((((((((((((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 cond1068 - _t1901 = parse_raw_value(parser) - item1069 = _t1901 - push!(xs1067, item1069) - cond1068 = ((((((((((((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_values1070 = xs1067 + _t1914 = parse_name(parser) + name1074 = _t1914 + xs1075 = Proto.Value[] + cond1076 = ((((((((((((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 cond1076 + _t1915 = parse_raw_value(parser) + item1077 = _t1915 + push!(xs1075, item1077) + cond1076 = ((((((((((((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_values1078 = xs1075 consume_literal!(parser, ")") - _t1902 = Proto.Attribute(name=name1066, args=raw_values1070) - result1072 = _t1902 - record_span!(parser, span_start1071, "Attribute") - return result1072 + _t1916 = Proto.Attribute(name=name1074, args=raw_values1078) + result1080 = _t1916 + record_span!(parser, span_start1079, "Attribute") + return result1080 end function parse_algorithm(parser::ParserState)::Proto.Algorithm - span_start1079 = span_start(parser) + span_start1087 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "algorithm") - xs1073 = Proto.RelationId[] - cond1074 = (match_lookahead_literal(parser, ":", 0) || match_lookahead_terminal(parser, "UINT128", 0)) - while cond1074 - _t1903 = parse_relation_id(parser) - item1075 = _t1903 - push!(xs1073, item1075) - cond1074 = (match_lookahead_literal(parser, ":", 0) || match_lookahead_terminal(parser, "UINT128", 0)) - end - relation_ids1076 = xs1073 - _t1904 = parse_script(parser) - script1077 = _t1904 + xs1081 = Proto.RelationId[] + cond1082 = (match_lookahead_literal(parser, ":", 0) || match_lookahead_terminal(parser, "UINT128", 0)) + while cond1082 + _t1917 = parse_relation_id(parser) + item1083 = _t1917 + push!(xs1081, item1083) + cond1082 = (match_lookahead_literal(parser, ":", 0) || match_lookahead_terminal(parser, "UINT128", 0)) + end + relation_ids1084 = xs1081 + _t1918 = parse_script(parser) + script1085 = _t1918 if match_lookahead_literal(parser, "(", 0) - _t1906 = parse_attrs(parser) - _t1905 = _t1906 + _t1920 = parse_attrs(parser) + _t1919 = _t1920 else - _t1905 = nothing + _t1919 = nothing end - attrs1078 = _t1905 + attrs1086 = _t1919 consume_literal!(parser, ")") - _t1907 = Proto.Algorithm(var"#global"=relation_ids1076, body=script1077, attrs=(!isnothing(attrs1078) ? attrs1078 : Proto.Attribute[])) - result1080 = _t1907 - record_span!(parser, span_start1079, "Algorithm") - return result1080 + _t1921 = Proto.Algorithm(var"#global"=relation_ids1084, body=script1085, attrs=(!isnothing(attrs1086) ? attrs1086 : Proto.Attribute[])) + result1088 = _t1921 + record_span!(parser, span_start1087, "Algorithm") + return result1088 end function parse_script(parser::ParserState)::Proto.Script - span_start1085 = span_start(parser) + span_start1093 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "script") - xs1081 = Proto.Construct[] - cond1082 = match_lookahead_literal(parser, "(", 0) - while cond1082 - _t1908 = parse_construct(parser) - item1083 = _t1908 - push!(xs1081, item1083) - cond1082 = match_lookahead_literal(parser, "(", 0) - end - constructs1084 = xs1081 + xs1089 = Proto.Construct[] + cond1090 = match_lookahead_literal(parser, "(", 0) + while cond1090 + _t1922 = parse_construct(parser) + item1091 = _t1922 + push!(xs1089, item1091) + cond1090 = match_lookahead_literal(parser, "(", 0) + end + constructs1092 = xs1089 consume_literal!(parser, ")") - _t1909 = Proto.Script(constructs=constructs1084) - result1086 = _t1909 - record_span!(parser, span_start1085, "Script") - return result1086 + _t1923 = Proto.Script(constructs=constructs1092) + result1094 = _t1923 + record_span!(parser, span_start1093, "Script") + return result1094 end function parse_construct(parser::ParserState)::Proto.Construct - span_start1090 = span_start(parser) + span_start1098 = span_start(parser) if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "upsert", 1) - _t1911 = 1 + _t1925 = 1 else if match_lookahead_literal(parser, "monus", 1) - _t1912 = 1 + _t1926 = 1 else if match_lookahead_literal(parser, "monoid", 1) - _t1913 = 1 + _t1927 = 1 else if match_lookahead_literal(parser, "loop", 1) - _t1914 = 0 + _t1928 = 0 else if match_lookahead_literal(parser, "break", 1) - _t1915 = 1 + _t1929 = 1 else if match_lookahead_literal(parser, "assign", 1) - _t1916 = 1 + _t1930 = 1 else - _t1916 = -1 + _t1930 = -1 end - _t1915 = _t1916 + _t1929 = _t1930 end - _t1914 = _t1915 + _t1928 = _t1929 end - _t1913 = _t1914 + _t1927 = _t1928 end - _t1912 = _t1913 + _t1926 = _t1927 end - _t1911 = _t1912 + _t1925 = _t1926 end - _t1910 = _t1911 + _t1924 = _t1925 else - _t1910 = -1 - end - prediction1087 = _t1910 - if prediction1087 == 1 - _t1918 = parse_instruction(parser) - instruction1089 = _t1918 - _t1919 = Proto.Construct(construct_type=OneOf(:instruction, instruction1089)) - _t1917 = _t1919 + _t1924 = -1 + end + prediction1095 = _t1924 + if prediction1095 == 1 + _t1932 = parse_instruction(parser) + instruction1097 = _t1932 + _t1933 = Proto.Construct(construct_type=OneOf(:instruction, instruction1097)) + _t1931 = _t1933 else - if prediction1087 == 0 - _t1921 = parse_loop(parser) - loop1088 = _t1921 - _t1922 = Proto.Construct(construct_type=OneOf(:loop, loop1088)) - _t1920 = _t1922 + if prediction1095 == 0 + _t1935 = parse_loop(parser) + loop1096 = _t1935 + _t1936 = Proto.Construct(construct_type=OneOf(:loop, loop1096)) + _t1934 = _t1936 else throw(ParseError("Unexpected token in construct" * ": " * string(lookahead(parser, 0)))) end - _t1917 = _t1920 + _t1931 = _t1934 end - result1091 = _t1917 - record_span!(parser, span_start1090, "Construct") - return result1091 + result1099 = _t1931 + record_span!(parser, span_start1098, "Construct") + return result1099 end function parse_loop(parser::ParserState)::Proto.Loop - span_start1095 = span_start(parser) + span_start1103 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "loop") - _t1923 = parse_init(parser) - init1092 = _t1923 - _t1924 = parse_script(parser) - script1093 = _t1924 + _t1937 = parse_init(parser) + init1100 = _t1937 + _t1938 = parse_script(parser) + script1101 = _t1938 if match_lookahead_literal(parser, "(", 0) - _t1926 = parse_attrs(parser) - _t1925 = _t1926 + _t1940 = parse_attrs(parser) + _t1939 = _t1940 else - _t1925 = nothing + _t1939 = nothing end - attrs1094 = _t1925 + attrs1102 = _t1939 consume_literal!(parser, ")") - _t1927 = Proto.Loop(init=init1092, body=script1093, attrs=(!isnothing(attrs1094) ? attrs1094 : Proto.Attribute[])) - result1096 = _t1927 - record_span!(parser, span_start1095, "Loop") - return result1096 + _t1941 = Proto.Loop(init=init1100, body=script1101, attrs=(!isnothing(attrs1102) ? attrs1102 : Proto.Attribute[])) + result1104 = _t1941 + record_span!(parser, span_start1103, "Loop") + return result1104 end function parse_init(parser::ParserState)::Vector{Proto.Instruction} consume_literal!(parser, "(") consume_literal!(parser, "init") - xs1097 = Proto.Instruction[] - cond1098 = match_lookahead_literal(parser, "(", 0) - while cond1098 - _t1928 = parse_instruction(parser) - item1099 = _t1928 - push!(xs1097, item1099) - cond1098 = match_lookahead_literal(parser, "(", 0) - end - instructions1100 = xs1097 + xs1105 = Proto.Instruction[] + cond1106 = match_lookahead_literal(parser, "(", 0) + while cond1106 + _t1942 = parse_instruction(parser) + item1107 = _t1942 + push!(xs1105, item1107) + cond1106 = match_lookahead_literal(parser, "(", 0) + end + instructions1108 = xs1105 consume_literal!(parser, ")") - return instructions1100 + return instructions1108 end function parse_instruction(parser::ParserState)::Proto.Instruction - span_start1107 = span_start(parser) + span_start1115 = span_start(parser) if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "upsert", 1) - _t1930 = 1 + _t1944 = 1 else if match_lookahead_literal(parser, "monus", 1) - _t1931 = 4 + _t1945 = 4 else if match_lookahead_literal(parser, "monoid", 1) - _t1932 = 3 + _t1946 = 3 else if match_lookahead_literal(parser, "break", 1) - _t1933 = 2 + _t1947 = 2 else if match_lookahead_literal(parser, "assign", 1) - _t1934 = 0 + _t1948 = 0 else - _t1934 = -1 + _t1948 = -1 end - _t1933 = _t1934 + _t1947 = _t1948 end - _t1932 = _t1933 + _t1946 = _t1947 end - _t1931 = _t1932 + _t1945 = _t1946 end - _t1930 = _t1931 + _t1944 = _t1945 end - _t1929 = _t1930 + _t1943 = _t1944 else - _t1929 = -1 - end - prediction1101 = _t1929 - if prediction1101 == 4 - _t1936 = parse_monus_def(parser) - monus_def1106 = _t1936 - _t1937 = Proto.Instruction(instr_type=OneOf(:monus_def, monus_def1106)) - _t1935 = _t1937 + _t1943 = -1 + end + prediction1109 = _t1943 + if prediction1109 == 4 + _t1950 = parse_monus_def(parser) + monus_def1114 = _t1950 + _t1951 = Proto.Instruction(instr_type=OneOf(:monus_def, monus_def1114)) + _t1949 = _t1951 else - if prediction1101 == 3 - _t1939 = parse_monoid_def(parser) - monoid_def1105 = _t1939 - _t1940 = Proto.Instruction(instr_type=OneOf(:monoid_def, monoid_def1105)) - _t1938 = _t1940 + if prediction1109 == 3 + _t1953 = parse_monoid_def(parser) + monoid_def1113 = _t1953 + _t1954 = Proto.Instruction(instr_type=OneOf(:monoid_def, monoid_def1113)) + _t1952 = _t1954 else - if prediction1101 == 2 - _t1942 = parse_break(parser) - break1104 = _t1942 - _t1943 = Proto.Instruction(instr_type=OneOf(:var"#break", break1104)) - _t1941 = _t1943 + if prediction1109 == 2 + _t1956 = parse_break(parser) + break1112 = _t1956 + _t1957 = Proto.Instruction(instr_type=OneOf(:var"#break", break1112)) + _t1955 = _t1957 else - if prediction1101 == 1 - _t1945 = parse_upsert(parser) - upsert1103 = _t1945 - _t1946 = Proto.Instruction(instr_type=OneOf(:upsert, upsert1103)) - _t1944 = _t1946 + if prediction1109 == 1 + _t1959 = parse_upsert(parser) + upsert1111 = _t1959 + _t1960 = Proto.Instruction(instr_type=OneOf(:upsert, upsert1111)) + _t1958 = _t1960 else - if prediction1101 == 0 - _t1948 = parse_assign(parser) - assign1102 = _t1948 - _t1949 = Proto.Instruction(instr_type=OneOf(:assign, assign1102)) - _t1947 = _t1949 + if prediction1109 == 0 + _t1962 = parse_assign(parser) + assign1110 = _t1962 + _t1963 = Proto.Instruction(instr_type=OneOf(:assign, assign1110)) + _t1961 = _t1963 else throw(ParseError("Unexpected token in instruction" * ": " * string(lookahead(parser, 0)))) end - _t1944 = _t1947 + _t1958 = _t1961 end - _t1941 = _t1944 + _t1955 = _t1958 end - _t1938 = _t1941 + _t1952 = _t1955 end - _t1935 = _t1938 + _t1949 = _t1952 end - result1108 = _t1935 - record_span!(parser, span_start1107, "Instruction") - return result1108 + result1116 = _t1949 + record_span!(parser, span_start1115, "Instruction") + return result1116 end function parse_assign(parser::ParserState)::Proto.Assign - span_start1112 = span_start(parser) + span_start1120 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "assign") - _t1950 = parse_relation_id(parser) - relation_id1109 = _t1950 - _t1951 = parse_abstraction(parser) - abstraction1110 = _t1951 + _t1964 = parse_relation_id(parser) + relation_id1117 = _t1964 + _t1965 = parse_abstraction(parser) + abstraction1118 = _t1965 if match_lookahead_literal(parser, "(", 0) - _t1953 = parse_attrs(parser) - _t1952 = _t1953 + _t1967 = parse_attrs(parser) + _t1966 = _t1967 else - _t1952 = nothing + _t1966 = nothing end - attrs1111 = _t1952 + attrs1119 = _t1966 consume_literal!(parser, ")") - _t1954 = Proto.Assign(name=relation_id1109, body=abstraction1110, attrs=(!isnothing(attrs1111) ? attrs1111 : Proto.Attribute[])) - result1113 = _t1954 - record_span!(parser, span_start1112, "Assign") - return result1113 + _t1968 = Proto.Assign(name=relation_id1117, body=abstraction1118, attrs=(!isnothing(attrs1119) ? attrs1119 : Proto.Attribute[])) + result1121 = _t1968 + record_span!(parser, span_start1120, "Assign") + return result1121 end function parse_upsert(parser::ParserState)::Proto.Upsert - span_start1117 = span_start(parser) + span_start1125 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "upsert") - _t1955 = parse_relation_id(parser) - relation_id1114 = _t1955 - _t1956 = parse_abstraction_with_arity(parser) - abstraction_with_arity1115 = _t1956 + _t1969 = parse_relation_id(parser) + relation_id1122 = _t1969 + _t1970 = parse_abstraction_with_arity(parser) + abstraction_with_arity1123 = _t1970 if match_lookahead_literal(parser, "(", 0) - _t1958 = parse_attrs(parser) - _t1957 = _t1958 + _t1972 = parse_attrs(parser) + _t1971 = _t1972 else - _t1957 = nothing + _t1971 = nothing end - attrs1116 = _t1957 + attrs1124 = _t1971 consume_literal!(parser, ")") - _t1959 = Proto.Upsert(name=relation_id1114, body=abstraction_with_arity1115[1], attrs=(!isnothing(attrs1116) ? attrs1116 : Proto.Attribute[]), value_arity=abstraction_with_arity1115[2]) - result1118 = _t1959 - record_span!(parser, span_start1117, "Upsert") - return result1118 + _t1973 = Proto.Upsert(name=relation_id1122, body=abstraction_with_arity1123[1], attrs=(!isnothing(attrs1124) ? attrs1124 : Proto.Attribute[]), value_arity=abstraction_with_arity1123[2]) + result1126 = _t1973 + record_span!(parser, span_start1125, "Upsert") + return result1126 end function parse_abstraction_with_arity(parser::ParserState)::Tuple{Proto.Abstraction, Int64} consume_literal!(parser, "(") - _t1960 = parse_bindings(parser) - bindings1119 = _t1960 - _t1961 = parse_formula(parser) - formula1120 = _t1961 + _t1974 = parse_bindings(parser) + bindings1127 = _t1974 + _t1975 = parse_formula(parser) + formula1128 = _t1975 consume_literal!(parser, ")") - _t1962 = Proto.Abstraction(vars=vcat(bindings1119[1], !isnothing(bindings1119[2]) ? bindings1119[2] : []), value=formula1120) - return (_t1962, length(bindings1119[2]),) + _t1976 = Proto.Abstraction(vars=vcat(bindings1127[1], !isnothing(bindings1127[2]) ? bindings1127[2] : []), value=formula1128) + return (_t1976, length(bindings1127[2]),) end function parse_break(parser::ParserState)::Proto.Break - span_start1124 = span_start(parser) + span_start1132 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "break") - _t1963 = parse_relation_id(parser) - relation_id1121 = _t1963 - _t1964 = parse_abstraction(parser) - abstraction1122 = _t1964 + _t1977 = parse_relation_id(parser) + relation_id1129 = _t1977 + _t1978 = parse_abstraction(parser) + abstraction1130 = _t1978 if match_lookahead_literal(parser, "(", 0) - _t1966 = parse_attrs(parser) - _t1965 = _t1966 + _t1980 = parse_attrs(parser) + _t1979 = _t1980 else - _t1965 = nothing + _t1979 = nothing end - attrs1123 = _t1965 + attrs1131 = _t1979 consume_literal!(parser, ")") - _t1967 = Proto.Break(name=relation_id1121, body=abstraction1122, attrs=(!isnothing(attrs1123) ? attrs1123 : Proto.Attribute[])) - result1125 = _t1967 - record_span!(parser, span_start1124, "Break") - return result1125 + _t1981 = Proto.Break(name=relation_id1129, body=abstraction1130, attrs=(!isnothing(attrs1131) ? attrs1131 : Proto.Attribute[])) + result1133 = _t1981 + record_span!(parser, span_start1132, "Break") + return result1133 end function parse_monoid_def(parser::ParserState)::Proto.MonoidDef - span_start1130 = span_start(parser) + span_start1138 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "monoid") - _t1968 = parse_monoid(parser) - monoid1126 = _t1968 - _t1969 = parse_relation_id(parser) - relation_id1127 = _t1969 - _t1970 = parse_abstraction_with_arity(parser) - abstraction_with_arity1128 = _t1970 + _t1982 = parse_monoid(parser) + monoid1134 = _t1982 + _t1983 = parse_relation_id(parser) + relation_id1135 = _t1983 + _t1984 = parse_abstraction_with_arity(parser) + abstraction_with_arity1136 = _t1984 if match_lookahead_literal(parser, "(", 0) - _t1972 = parse_attrs(parser) - _t1971 = _t1972 + _t1986 = parse_attrs(parser) + _t1985 = _t1986 else - _t1971 = nothing + _t1985 = nothing end - attrs1129 = _t1971 + attrs1137 = _t1985 consume_literal!(parser, ")") - _t1973 = Proto.MonoidDef(monoid=monoid1126, name=relation_id1127, body=abstraction_with_arity1128[1], attrs=(!isnothing(attrs1129) ? attrs1129 : Proto.Attribute[]), value_arity=abstraction_with_arity1128[2]) - result1131 = _t1973 - record_span!(parser, span_start1130, "MonoidDef") - return result1131 + _t1987 = Proto.MonoidDef(monoid=monoid1134, name=relation_id1135, body=abstraction_with_arity1136[1], attrs=(!isnothing(attrs1137) ? attrs1137 : Proto.Attribute[]), value_arity=abstraction_with_arity1136[2]) + result1139 = _t1987 + record_span!(parser, span_start1138, "MonoidDef") + return result1139 end function parse_monoid(parser::ParserState)::Proto.Monoid - span_start1137 = span_start(parser) + span_start1145 = span_start(parser) if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "sum", 1) - _t1975 = 3 + _t1989 = 3 else if match_lookahead_literal(parser, "or", 1) - _t1976 = 0 + _t1990 = 0 else if match_lookahead_literal(parser, "min", 1) - _t1977 = 1 + _t1991 = 1 else if match_lookahead_literal(parser, "max", 1) - _t1978 = 2 + _t1992 = 2 else - _t1978 = -1 + _t1992 = -1 end - _t1977 = _t1978 + _t1991 = _t1992 end - _t1976 = _t1977 + _t1990 = _t1991 end - _t1975 = _t1976 + _t1989 = _t1990 end - _t1974 = _t1975 + _t1988 = _t1989 else - _t1974 = -1 - end - prediction1132 = _t1974 - if prediction1132 == 3 - _t1980 = parse_sum_monoid(parser) - sum_monoid1136 = _t1980 - _t1981 = Proto.Monoid(value=OneOf(:sum_monoid, sum_monoid1136)) - _t1979 = _t1981 + _t1988 = -1 + end + prediction1140 = _t1988 + if prediction1140 == 3 + _t1994 = parse_sum_monoid(parser) + sum_monoid1144 = _t1994 + _t1995 = Proto.Monoid(value=OneOf(:sum_monoid, sum_monoid1144)) + _t1993 = _t1995 else - if prediction1132 == 2 - _t1983 = parse_max_monoid(parser) - max_monoid1135 = _t1983 - _t1984 = Proto.Monoid(value=OneOf(:max_monoid, max_monoid1135)) - _t1982 = _t1984 + if prediction1140 == 2 + _t1997 = parse_max_monoid(parser) + max_monoid1143 = _t1997 + _t1998 = Proto.Monoid(value=OneOf(:max_monoid, max_monoid1143)) + _t1996 = _t1998 else - if prediction1132 == 1 - _t1986 = parse_min_monoid(parser) - min_monoid1134 = _t1986 - _t1987 = Proto.Monoid(value=OneOf(:min_monoid, min_monoid1134)) - _t1985 = _t1987 + if prediction1140 == 1 + _t2000 = parse_min_monoid(parser) + min_monoid1142 = _t2000 + _t2001 = Proto.Monoid(value=OneOf(:min_monoid, min_monoid1142)) + _t1999 = _t2001 else - if prediction1132 == 0 - _t1989 = parse_or_monoid(parser) - or_monoid1133 = _t1989 - _t1990 = Proto.Monoid(value=OneOf(:or_monoid, or_monoid1133)) - _t1988 = _t1990 + if prediction1140 == 0 + _t2003 = parse_or_monoid(parser) + or_monoid1141 = _t2003 + _t2004 = Proto.Monoid(value=OneOf(:or_monoid, or_monoid1141)) + _t2002 = _t2004 else throw(ParseError("Unexpected token in monoid" * ": " * string(lookahead(parser, 0)))) end - _t1985 = _t1988 + _t1999 = _t2002 end - _t1982 = _t1985 + _t1996 = _t1999 end - _t1979 = _t1982 + _t1993 = _t1996 end - result1138 = _t1979 - record_span!(parser, span_start1137, "Monoid") - return result1138 + result1146 = _t1993 + record_span!(parser, span_start1145, "Monoid") + return result1146 end function parse_or_monoid(parser::ParserState)::Proto.OrMonoid - span_start1139 = span_start(parser) + span_start1147 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "or") consume_literal!(parser, ")") - _t1991 = Proto.OrMonoid() - result1140 = _t1991 - record_span!(parser, span_start1139, "OrMonoid") - return result1140 + _t2005 = Proto.OrMonoid() + result1148 = _t2005 + record_span!(parser, span_start1147, "OrMonoid") + return result1148 end function parse_min_monoid(parser::ParserState)::Proto.MinMonoid - span_start1142 = span_start(parser) + span_start1150 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "min") - _t1992 = parse_type(parser) - type1141 = _t1992 + _t2006 = parse_type(parser) + type1149 = _t2006 consume_literal!(parser, ")") - _t1993 = Proto.MinMonoid(var"#type"=type1141) - result1143 = _t1993 - record_span!(parser, span_start1142, "MinMonoid") - return result1143 + _t2007 = Proto.MinMonoid(var"#type"=type1149) + result1151 = _t2007 + record_span!(parser, span_start1150, "MinMonoid") + return result1151 end function parse_max_monoid(parser::ParserState)::Proto.MaxMonoid - span_start1145 = span_start(parser) + span_start1153 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "max") - _t1994 = parse_type(parser) - type1144 = _t1994 + _t2008 = parse_type(parser) + type1152 = _t2008 consume_literal!(parser, ")") - _t1995 = Proto.MaxMonoid(var"#type"=type1144) - result1146 = _t1995 - record_span!(parser, span_start1145, "MaxMonoid") - return result1146 + _t2009 = Proto.MaxMonoid(var"#type"=type1152) + result1154 = _t2009 + record_span!(parser, span_start1153, "MaxMonoid") + return result1154 end function parse_sum_monoid(parser::ParserState)::Proto.SumMonoid - span_start1148 = span_start(parser) + span_start1156 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "sum") - _t1996 = parse_type(parser) - type1147 = _t1996 + _t2010 = parse_type(parser) + type1155 = _t2010 consume_literal!(parser, ")") - _t1997 = Proto.SumMonoid(var"#type"=type1147) - result1149 = _t1997 - record_span!(parser, span_start1148, "SumMonoid") - return result1149 + _t2011 = Proto.SumMonoid(var"#type"=type1155) + result1157 = _t2011 + record_span!(parser, span_start1156, "SumMonoid") + return result1157 end function parse_monus_def(parser::ParserState)::Proto.MonusDef - span_start1154 = span_start(parser) + span_start1162 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "monus") - _t1998 = parse_monoid(parser) - monoid1150 = _t1998 - _t1999 = parse_relation_id(parser) - relation_id1151 = _t1999 - _t2000 = parse_abstraction_with_arity(parser) - abstraction_with_arity1152 = _t2000 + _t2012 = parse_monoid(parser) + monoid1158 = _t2012 + _t2013 = parse_relation_id(parser) + relation_id1159 = _t2013 + _t2014 = parse_abstraction_with_arity(parser) + abstraction_with_arity1160 = _t2014 if match_lookahead_literal(parser, "(", 0) - _t2002 = parse_attrs(parser) - _t2001 = _t2002 + _t2016 = parse_attrs(parser) + _t2015 = _t2016 else - _t2001 = nothing + _t2015 = nothing end - attrs1153 = _t2001 + attrs1161 = _t2015 consume_literal!(parser, ")") - _t2003 = Proto.MonusDef(monoid=monoid1150, name=relation_id1151, body=abstraction_with_arity1152[1], attrs=(!isnothing(attrs1153) ? attrs1153 : Proto.Attribute[]), value_arity=abstraction_with_arity1152[2]) - result1155 = _t2003 - record_span!(parser, span_start1154, "MonusDef") - return result1155 + _t2017 = Proto.MonusDef(monoid=monoid1158, name=relation_id1159, body=abstraction_with_arity1160[1], attrs=(!isnothing(attrs1161) ? attrs1161 : Proto.Attribute[]), value_arity=abstraction_with_arity1160[2]) + result1163 = _t2017 + record_span!(parser, span_start1162, "MonusDef") + return result1163 end function parse_constraint(parser::ParserState)::Proto.Constraint - span_start1160 = span_start(parser) + span_start1168 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "functional_dependency") - _t2004 = parse_relation_id(parser) - relation_id1156 = _t2004 - _t2005 = parse_abstraction(parser) - abstraction1157 = _t2005 - _t2006 = parse_functional_dependency_keys(parser) - functional_dependency_keys1158 = _t2006 - _t2007 = parse_functional_dependency_values(parser) - functional_dependency_values1159 = _t2007 + _t2018 = parse_relation_id(parser) + relation_id1164 = _t2018 + _t2019 = parse_abstraction(parser) + abstraction1165 = _t2019 + _t2020 = parse_functional_dependency_keys(parser) + functional_dependency_keys1166 = _t2020 + _t2021 = parse_functional_dependency_values(parser) + functional_dependency_values1167 = _t2021 consume_literal!(parser, ")") - _t2008 = Proto.FunctionalDependency(guard=abstraction1157, keys=functional_dependency_keys1158, values=functional_dependency_values1159) - _t2009 = Proto.Constraint(constraint_type=OneOf(:functional_dependency, _t2008), name=relation_id1156) - result1161 = _t2009 - record_span!(parser, span_start1160, "Constraint") - return result1161 + _t2022 = Proto.FunctionalDependency(guard=abstraction1165, keys=functional_dependency_keys1166, values=functional_dependency_values1167) + _t2023 = Proto.Constraint(constraint_type=OneOf(:functional_dependency, _t2022), name=relation_id1164) + result1169 = _t2023 + record_span!(parser, span_start1168, "Constraint") + return result1169 end function parse_functional_dependency_keys(parser::ParserState)::Vector{Proto.Var} consume_literal!(parser, "(") consume_literal!(parser, "keys") - xs1162 = Proto.Var[] - cond1163 = match_lookahead_terminal(parser, "SYMBOL", 0) - while cond1163 - _t2010 = parse_var(parser) - item1164 = _t2010 - push!(xs1162, item1164) - cond1163 = match_lookahead_terminal(parser, "SYMBOL", 0) - end - vars1165 = xs1162 + xs1170 = Proto.Var[] + cond1171 = match_lookahead_terminal(parser, "SYMBOL", 0) + while cond1171 + _t2024 = parse_var(parser) + item1172 = _t2024 + push!(xs1170, item1172) + cond1171 = match_lookahead_terminal(parser, "SYMBOL", 0) + end + vars1173 = xs1170 consume_literal!(parser, ")") - return vars1165 + return vars1173 end function parse_functional_dependency_values(parser::ParserState)::Vector{Proto.Var} consume_literal!(parser, "(") consume_literal!(parser, "values") - xs1166 = Proto.Var[] - cond1167 = match_lookahead_terminal(parser, "SYMBOL", 0) - while cond1167 - _t2011 = parse_var(parser) - item1168 = _t2011 - push!(xs1166, item1168) - cond1167 = match_lookahead_terminal(parser, "SYMBOL", 0) - end - vars1169 = xs1166 + xs1174 = Proto.Var[] + cond1175 = match_lookahead_terminal(parser, "SYMBOL", 0) + while cond1175 + _t2025 = parse_var(parser) + item1176 = _t2025 + push!(xs1174, item1176) + cond1175 = match_lookahead_terminal(parser, "SYMBOL", 0) + end + vars1177 = xs1174 consume_literal!(parser, ")") - return vars1169 + return vars1177 end function parse_data(parser::ParserState)::Proto.Data - span_start1175 = span_start(parser) + span_start1183 = span_start(parser) if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "iceberg_data", 1) - _t2013 = 3 + _t2027 = 3 else if match_lookahead_literal(parser, "edb", 1) - _t2014 = 0 + _t2028 = 0 else if match_lookahead_literal(parser, "csv_data", 1) - _t2015 = 2 + _t2029 = 2 else if match_lookahead_literal(parser, "betree_relation", 1) - _t2016 = 1 + _t2030 = 1 else - _t2016 = -1 + _t2030 = -1 end - _t2015 = _t2016 + _t2029 = _t2030 end - _t2014 = _t2015 + _t2028 = _t2029 end - _t2013 = _t2014 + _t2027 = _t2028 end - _t2012 = _t2013 + _t2026 = _t2027 else - _t2012 = -1 - end - prediction1170 = _t2012 - if prediction1170 == 3 - _t2018 = parse_iceberg_data(parser) - iceberg_data1174 = _t2018 - _t2019 = Proto.Data(data_type=OneOf(:iceberg_data, iceberg_data1174)) - _t2017 = _t2019 + _t2026 = -1 + end + prediction1178 = _t2026 + if prediction1178 == 3 + _t2032 = parse_iceberg_data(parser) + iceberg_data1182 = _t2032 + _t2033 = Proto.Data(data_type=OneOf(:iceberg_data, iceberg_data1182)) + _t2031 = _t2033 else - if prediction1170 == 2 - _t2021 = parse_csv_data(parser) - csv_data1173 = _t2021 - _t2022 = Proto.Data(data_type=OneOf(:csv_data, csv_data1173)) - _t2020 = _t2022 + if prediction1178 == 2 + _t2035 = parse_csv_data(parser) + csv_data1181 = _t2035 + _t2036 = Proto.Data(data_type=OneOf(:csv_data, csv_data1181)) + _t2034 = _t2036 else - if prediction1170 == 1 - _t2024 = parse_betree_relation(parser) - betree_relation1172 = _t2024 - _t2025 = Proto.Data(data_type=OneOf(:betree_relation, betree_relation1172)) - _t2023 = _t2025 + if prediction1178 == 1 + _t2038 = parse_betree_relation(parser) + betree_relation1180 = _t2038 + _t2039 = Proto.Data(data_type=OneOf(:betree_relation, betree_relation1180)) + _t2037 = _t2039 else - if prediction1170 == 0 - _t2027 = parse_edb(parser) - edb1171 = _t2027 - _t2028 = Proto.Data(data_type=OneOf(:edb, edb1171)) - _t2026 = _t2028 + if prediction1178 == 0 + _t2041 = parse_edb(parser) + edb1179 = _t2041 + _t2042 = Proto.Data(data_type=OneOf(:edb, edb1179)) + _t2040 = _t2042 else throw(ParseError("Unexpected token in data" * ": " * string(lookahead(parser, 0)))) end - _t2023 = _t2026 + _t2037 = _t2040 end - _t2020 = _t2023 + _t2034 = _t2037 end - _t2017 = _t2020 + _t2031 = _t2034 end - result1176 = _t2017 - record_span!(parser, span_start1175, "Data") - return result1176 + result1184 = _t2031 + record_span!(parser, span_start1183, "Data") + return result1184 end function parse_edb(parser::ParserState)::Proto.EDB - span_start1180 = span_start(parser) + span_start1188 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "edb") - _t2029 = parse_relation_id(parser) - relation_id1177 = _t2029 - _t2030 = parse_edb_path(parser) - edb_path1178 = _t2030 - _t2031 = parse_edb_types(parser) - edb_types1179 = _t2031 + _t2043 = parse_relation_id(parser) + relation_id1185 = _t2043 + _t2044 = parse_edb_path(parser) + edb_path1186 = _t2044 + _t2045 = parse_edb_types(parser) + edb_types1187 = _t2045 consume_literal!(parser, ")") - _t2032 = Proto.EDB(target_id=relation_id1177, path=edb_path1178, types=edb_types1179) - result1181 = _t2032 - record_span!(parser, span_start1180, "EDB") - return result1181 + _t2046 = Proto.EDB(target_id=relation_id1185, path=edb_path1186, types=edb_types1187) + result1189 = _t2046 + record_span!(parser, span_start1188, "EDB") + return result1189 end function parse_edb_path(parser::ParserState)::Vector{String} consume_literal!(parser, "[") - xs1182 = String[] - cond1183 = match_lookahead_terminal(parser, "STRING", 0) - while cond1183 - item1184 = consume_terminal!(parser, "STRING") - push!(xs1182, item1184) - cond1183 = match_lookahead_terminal(parser, "STRING", 0) - end - strings1185 = xs1182 + xs1190 = String[] + cond1191 = match_lookahead_terminal(parser, "STRING", 0) + while cond1191 + item1192 = consume_terminal!(parser, "STRING") + push!(xs1190, item1192) + cond1191 = match_lookahead_terminal(parser, "STRING", 0) + end + strings1193 = xs1190 consume_literal!(parser, "]") - return strings1185 + return strings1193 end function parse_edb_types(parser::ParserState)::Vector{Proto.var"#Type"} consume_literal!(parser, "[") - xs1186 = Proto.var"#Type"[] - cond1187 = (((((((((((((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 cond1187 - _t2033 = parse_type(parser) - item1188 = _t2033 - push!(xs1186, item1188) - cond1187 = (((((((((((((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 - types1189 = xs1186 + xs1194 = Proto.var"#Type"[] + cond1195 = (((((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "BOOLEAN", 0)) || match_lookahead_literal(parser, "DATE", 0)) || match_lookahead_literal(parser, "DATETIME", 0)) || match_lookahead_literal(parser, "FLOAT", 0)) || match_lookahead_literal(parser, "FLOAT32", 0)) || match_lookahead_literal(parser, "INT", 0)) || match_lookahead_literal(parser, "INT128", 0)) || match_lookahead_literal(parser, "INT32", 0)) || match_lookahead_literal(parser, "MISSING", 0)) || match_lookahead_literal(parser, "STRING", 0)) || match_lookahead_literal(parser, "UINT128", 0)) || match_lookahead_literal(parser, "UINT32", 0)) || match_lookahead_literal(parser, "UNKNOWN", 0)) + while cond1195 + _t2047 = parse_type(parser) + item1196 = _t2047 + push!(xs1194, item1196) + cond1195 = (((((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "BOOLEAN", 0)) || match_lookahead_literal(parser, "DATE", 0)) || match_lookahead_literal(parser, "DATETIME", 0)) || match_lookahead_literal(parser, "FLOAT", 0)) || match_lookahead_literal(parser, "FLOAT32", 0)) || match_lookahead_literal(parser, "INT", 0)) || match_lookahead_literal(parser, "INT128", 0)) || match_lookahead_literal(parser, "INT32", 0)) || match_lookahead_literal(parser, "MISSING", 0)) || match_lookahead_literal(parser, "STRING", 0)) || match_lookahead_literal(parser, "UINT128", 0)) || match_lookahead_literal(parser, "UINT32", 0)) || match_lookahead_literal(parser, "UNKNOWN", 0)) + end + types1197 = xs1194 consume_literal!(parser, "]") - return types1189 + return types1197 end function parse_betree_relation(parser::ParserState)::Proto.BeTreeRelation - span_start1192 = span_start(parser) + span_start1200 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "betree_relation") - _t2034 = parse_relation_id(parser) - relation_id1190 = _t2034 - _t2035 = parse_betree_info(parser) - betree_info1191 = _t2035 + _t2048 = parse_relation_id(parser) + relation_id1198 = _t2048 + _t2049 = parse_betree_info(parser) + betree_info1199 = _t2049 consume_literal!(parser, ")") - _t2036 = Proto.BeTreeRelation(name=relation_id1190, relation_info=betree_info1191) - result1193 = _t2036 - record_span!(parser, span_start1192, "BeTreeRelation") - return result1193 + _t2050 = Proto.BeTreeRelation(name=relation_id1198, relation_info=betree_info1199) + result1201 = _t2050 + record_span!(parser, span_start1200, "BeTreeRelation") + return result1201 end function parse_betree_info(parser::ParserState)::Proto.BeTreeInfo - span_start1197 = span_start(parser) + span_start1205 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "betree_info") - _t2037 = parse_betree_info_key_types(parser) - betree_info_key_types1194 = _t2037 - _t2038 = parse_betree_info_value_types(parser) - betree_info_value_types1195 = _t2038 - _t2039 = parse_config_dict(parser) - config_dict1196 = _t2039 + _t2051 = parse_betree_info_key_types(parser) + betree_info_key_types1202 = _t2051 + _t2052 = parse_betree_info_value_types(parser) + betree_info_value_types1203 = _t2052 + _t2053 = parse_config_dict(parser) + config_dict1204 = _t2053 consume_literal!(parser, ")") - _t2040 = construct_betree_info(parser, betree_info_key_types1194, betree_info_value_types1195, config_dict1196) - result1198 = _t2040 - record_span!(parser, span_start1197, "BeTreeInfo") - return result1198 + _t2054 = construct_betree_info(parser, betree_info_key_types1202, betree_info_value_types1203, config_dict1204) + result1206 = _t2054 + record_span!(parser, span_start1205, "BeTreeInfo") + return result1206 end function parse_betree_info_key_types(parser::ParserState)::Vector{Proto.var"#Type"} consume_literal!(parser, "(") consume_literal!(parser, "key_types") - xs1199 = Proto.var"#Type"[] - cond1200 = (((((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "BOOLEAN", 0)) || match_lookahead_literal(parser, "DATE", 0)) || match_lookahead_literal(parser, "DATETIME", 0)) || match_lookahead_literal(parser, "FLOAT", 0)) || match_lookahead_literal(parser, "FLOAT32", 0)) || match_lookahead_literal(parser, "INT", 0)) || match_lookahead_literal(parser, "INT128", 0)) || match_lookahead_literal(parser, "INT32", 0)) || match_lookahead_literal(parser, "MISSING", 0)) || match_lookahead_literal(parser, "STRING", 0)) || match_lookahead_literal(parser, "UINT128", 0)) || match_lookahead_literal(parser, "UINT32", 0)) || match_lookahead_literal(parser, "UNKNOWN", 0)) - while cond1200 - _t2041 = parse_type(parser) - item1201 = _t2041 - push!(xs1199, item1201) - cond1200 = (((((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "BOOLEAN", 0)) || match_lookahead_literal(parser, "DATE", 0)) || match_lookahead_literal(parser, "DATETIME", 0)) || match_lookahead_literal(parser, "FLOAT", 0)) || match_lookahead_literal(parser, "FLOAT32", 0)) || match_lookahead_literal(parser, "INT", 0)) || match_lookahead_literal(parser, "INT128", 0)) || match_lookahead_literal(parser, "INT32", 0)) || match_lookahead_literal(parser, "MISSING", 0)) || match_lookahead_literal(parser, "STRING", 0)) || match_lookahead_literal(parser, "UINT128", 0)) || match_lookahead_literal(parser, "UINT32", 0)) || match_lookahead_literal(parser, "UNKNOWN", 0)) - end - types1202 = xs1199 + xs1207 = Proto.var"#Type"[] + cond1208 = (((((((((((((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 cond1208 + _t2055 = parse_type(parser) + item1209 = _t2055 + push!(xs1207, item1209) + cond1208 = (((((((((((((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 + types1210 = xs1207 consume_literal!(parser, ")") - return types1202 + return types1210 end function parse_betree_info_value_types(parser::ParserState)::Vector{Proto.var"#Type"} consume_literal!(parser, "(") consume_literal!(parser, "value_types") - xs1203 = Proto.var"#Type"[] - cond1204 = (((((((((((((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 cond1204 - _t2042 = parse_type(parser) - item1205 = _t2042 - push!(xs1203, item1205) - cond1204 = (((((((((((((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 - types1206 = xs1203 + xs1211 = Proto.var"#Type"[] + cond1212 = (((((((((((((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 cond1212 + _t2056 = parse_type(parser) + item1213 = _t2056 + push!(xs1211, item1213) + cond1212 = (((((((((((((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 + types1214 = xs1211 consume_literal!(parser, ")") - return types1206 + return types1214 end function parse_csv_data(parser::ParserState)::Proto.CSVData - span_start1212 = span_start(parser) + span_start1220 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "csv_data") - _t2043 = parse_csvlocator(parser) - csvlocator1207 = _t2043 - _t2044 = parse_csv_config(parser) - csv_config1208 = _t2044 + _t2057 = parse_csvlocator(parser) + csvlocator1215 = _t2057 + _t2058 = parse_csv_config(parser) + csv_config1216 = _t2058 if (match_lookahead_literal(parser, "(", 0) && match_lookahead_literal(parser, "columns", 1)) - _t2046 = parse_gnf_columns(parser) - _t2045 = _t2046 + _t2060 = parse_gnf_columns(parser) + _t2059 = _t2060 else - _t2045 = nothing + _t2059 = nothing end - gnf_columns1209 = _t2045 + gnf_columns1217 = _t2059 if (match_lookahead_literal(parser, "(", 0) && match_lookahead_literal(parser, "relations", 1)) - _t2048 = parse_target_relations(parser) - _t2047 = _t2048 + _t2062 = parse_target_relations(parser) + _t2061 = _t2062 else - _t2047 = nothing + _t2061 = nothing end - target_relations1210 = _t2047 - _t2049 = parse_csv_asof(parser) - csv_asof1211 = _t2049 + target_relations1218 = _t2061 + _t2063 = parse_csv_asof(parser) + csv_asof1219 = _t2063 consume_literal!(parser, ")") - _t2050 = construct_csv_data(parser, csvlocator1207, csv_config1208, gnf_columns1209, target_relations1210, csv_asof1211) - result1213 = _t2050 - record_span!(parser, span_start1212, "CSVData") - return result1213 + _t2064 = construct_csv_data(parser, csvlocator1215, csv_config1216, gnf_columns1217, target_relations1218, csv_asof1219) + result1221 = _t2064 + record_span!(parser, span_start1220, "CSVData") + return result1221 end function parse_csvlocator(parser::ParserState)::Proto.CSVLocator - span_start1216 = span_start(parser) + span_start1224 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "csv_locator") if (match_lookahead_literal(parser, "(", 0) && match_lookahead_literal(parser, "paths", 1)) - _t2052 = parse_csv_locator_paths(parser) - _t2051 = _t2052 + _t2066 = parse_csv_locator_paths(parser) + _t2065 = _t2066 else - _t2051 = nothing + _t2065 = nothing end - csv_locator_paths1214 = _t2051 + csv_locator_paths1222 = _t2065 if match_lookahead_literal(parser, "(", 0) - _t2054 = parse_csv_locator_inline_data(parser) - _t2053 = _t2054 + _t2068 = parse_csv_locator_inline_data(parser) + _t2067 = _t2068 else - _t2053 = nothing + _t2067 = nothing end - csv_locator_inline_data1215 = _t2053 + csv_locator_inline_data1223 = _t2067 consume_literal!(parser, ")") - _t2055 = Proto.CSVLocator(paths=(!isnothing(csv_locator_paths1214) ? csv_locator_paths1214 : String[]), inline_data=Vector{UInt8}((!isnothing(csv_locator_inline_data1215) ? csv_locator_inline_data1215 : ""))) - result1217 = _t2055 - record_span!(parser, span_start1216, "CSVLocator") - return result1217 + _t2069 = Proto.CSVLocator(paths=(!isnothing(csv_locator_paths1222) ? csv_locator_paths1222 : String[]), inline_data=Vector{UInt8}((!isnothing(csv_locator_inline_data1223) ? csv_locator_inline_data1223 : ""))) + result1225 = _t2069 + record_span!(parser, span_start1224, "CSVLocator") + return result1225 end function parse_csv_locator_paths(parser::ParserState)::Vector{String} consume_literal!(parser, "(") consume_literal!(parser, "paths") - xs1218 = String[] - cond1219 = match_lookahead_terminal(parser, "STRING", 0) - while cond1219 - item1220 = consume_terminal!(parser, "STRING") - push!(xs1218, item1220) - cond1219 = match_lookahead_terminal(parser, "STRING", 0) - end - strings1221 = xs1218 + xs1226 = String[] + cond1227 = match_lookahead_terminal(parser, "STRING", 0) + while cond1227 + item1228 = consume_terminal!(parser, "STRING") + push!(xs1226, item1228) + cond1227 = match_lookahead_terminal(parser, "STRING", 0) + end + strings1229 = xs1226 consume_literal!(parser, ")") - return strings1221 + return strings1229 end function parse_csv_locator_inline_data(parser::ParserState)::String consume_literal!(parser, "(") consume_literal!(parser, "inline_data") - formatted_string1222 = consume_terminal!(parser, "STRING") + formatted_string1230 = consume_terminal!(parser, "STRING") consume_literal!(parser, ")") - return formatted_string1222 + return formatted_string1230 end function parse_csv_config(parser::ParserState)::Proto.CSVConfig - span_start1225 = span_start(parser) + span_start1233 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "csv_config") - _t2056 = parse_config_dict(parser) - config_dict1223 = _t2056 + _t2070 = parse_config_dict(parser) + config_dict1231 = _t2070 if match_lookahead_literal(parser, "(", 0) - _t2058 = parse__storage_integration(parser) - _t2057 = _t2058 + _t2072 = parse__storage_integration(parser) + _t2071 = _t2072 else - _t2057 = nothing + _t2071 = nothing end - _storage_integration1224 = _t2057 + _storage_integration1232 = _t2071 consume_literal!(parser, ")") - _t2059 = construct_csv_config(parser, config_dict1223, _storage_integration1224) - result1226 = _t2059 - record_span!(parser, span_start1225, "CSVConfig") - return result1226 + _t2073 = construct_csv_config(parser, config_dict1231, _storage_integration1232) + result1234 = _t2073 + record_span!(parser, span_start1233, "CSVConfig") + return result1234 end function parse__storage_integration(parser::ParserState)::Vector{Tuple{String, Proto.Value}} consume_literal!(parser, "(") consume_literal!(parser, "storage_integration") - _t2060 = parse_config_dict(parser) - config_dict1227 = _t2060 + _t2074 = parse_config_dict(parser) + config_dict1235 = _t2074 consume_literal!(parser, ")") - return config_dict1227 + return config_dict1235 end function parse_gnf_columns(parser::ParserState)::Vector{Proto.GNFColumn} consume_literal!(parser, "(") consume_literal!(parser, "columns") - xs1228 = Proto.GNFColumn[] - cond1229 = match_lookahead_literal(parser, "(", 0) - while cond1229 - _t2061 = parse_gnf_column(parser) - item1230 = _t2061 - push!(xs1228, item1230) - cond1229 = match_lookahead_literal(parser, "(", 0) - end - gnf_columns1231 = xs1228 + xs1236 = Proto.GNFColumn[] + cond1237 = match_lookahead_literal(parser, "(", 0) + while cond1237 + _t2075 = parse_gnf_column(parser) + item1238 = _t2075 + push!(xs1236, item1238) + cond1237 = match_lookahead_literal(parser, "(", 0) + end + gnf_columns1239 = xs1236 consume_literal!(parser, ")") - return gnf_columns1231 + return gnf_columns1239 end function parse_gnf_column(parser::ParserState)::Proto.GNFColumn - span_start1238 = span_start(parser) + span_start1246 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "column") - _t2062 = parse_gnf_column_path(parser) - gnf_column_path1232 = _t2062 + _t2076 = parse_gnf_column_path(parser) + gnf_column_path1240 = _t2076 if (match_lookahead_literal(parser, ":", 0) || match_lookahead_terminal(parser, "UINT128", 0)) - _t2064 = parse_relation_id(parser) - _t2063 = _t2064 + _t2078 = parse_relation_id(parser) + _t2077 = _t2078 else - _t2063 = nothing + _t2077 = nothing end - relation_id1233 = _t2063 + relation_id1241 = _t2077 consume_literal!(parser, "[") - xs1234 = Proto.var"#Type"[] - cond1235 = (((((((((((((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 cond1235 - _t2065 = parse_type(parser) - item1236 = _t2065 - push!(xs1234, item1236) - cond1235 = (((((((((((((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 - types1237 = xs1234 + xs1242 = Proto.var"#Type"[] + cond1243 = (((((((((((((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 cond1243 + _t2079 = parse_type(parser) + item1244 = _t2079 + push!(xs1242, item1244) + cond1243 = (((((((((((((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 + types1245 = xs1242 consume_literal!(parser, "]") consume_literal!(parser, ")") - _t2066 = Proto.GNFColumn(column_path=gnf_column_path1232, target_id=relation_id1233, types=types1237) - result1239 = _t2066 - record_span!(parser, span_start1238, "GNFColumn") - return result1239 + _t2080 = Proto.GNFColumn(column_path=gnf_column_path1240, target_id=relation_id1241, types=types1245) + result1247 = _t2080 + record_span!(parser, span_start1246, "GNFColumn") + return result1247 end function parse_gnf_column_path(parser::ParserState)::Vector{String} if match_lookahead_literal(parser, "[", 0) - _t2067 = 1 + _t2081 = 1 else if match_lookahead_terminal(parser, "STRING", 0) - _t2068 = 0 + _t2082 = 0 else - _t2068 = -1 + _t2082 = -1 end - _t2067 = _t2068 + _t2081 = _t2082 end - prediction1240 = _t2067 - if prediction1240 == 1 + prediction1248 = _t2081 + if prediction1248 == 1 consume_literal!(parser, "[") - xs1242 = String[] - cond1243 = match_lookahead_terminal(parser, "STRING", 0) - while cond1243 - item1244 = consume_terminal!(parser, "STRING") - push!(xs1242, item1244) - cond1243 = match_lookahead_terminal(parser, "STRING", 0) + xs1250 = String[] + cond1251 = match_lookahead_terminal(parser, "STRING", 0) + while cond1251 + item1252 = consume_terminal!(parser, "STRING") + push!(xs1250, item1252) + cond1251 = match_lookahead_terminal(parser, "STRING", 0) end - strings1245 = xs1242 + strings1253 = xs1250 consume_literal!(parser, "]") - _t2069 = strings1245 + _t2083 = strings1253 else - if prediction1240 == 0 - string1241 = consume_terminal!(parser, "STRING") - _t2070 = String[string1241] + if prediction1248 == 0 + string1249 = consume_terminal!(parser, "STRING") + _t2084 = String[string1249] else throw(ParseError("Unexpected token in gnf_column_path" * ": " * string(lookahead(parser, 0)))) end - _t2069 = _t2070 + _t2083 = _t2084 end - return _t2069 + return _t2083 end function parse_target_relations(parser::ParserState)::Proto.TargetRelations - span_start1249 = span_start(parser) + span_start1257 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "relations") - _t2071 = parse_relation_keys(parser) - relation_keys1246 = _t2071 - _t2072 = parse_relation_body(parser) - relation_body1247 = _t2072 + _t2085 = parse_relation_keys(parser) + relation_keys1254 = _t2085 + _t2086 = parse_relation_body(parser) + relation_body1255 = _t2086 if match_lookahead_literal(parser, "(", 0) - _t2074 = parse_load_errors(parser) - _t2073 = _t2074 + _t2088 = parse_load_errors(parser) + _t2087 = _t2088 else - _t2073 = nothing + _t2087 = nothing end - load_errors1248 = _t2073 + load_errors1256 = _t2087 consume_literal!(parser, ")") - _t2075 = construct_relations(parser, relation_keys1246, relation_body1247, load_errors1248) - result1250 = _t2075 - record_span!(parser, span_start1249, "TargetRelations") - return result1250 + _t2089 = construct_relations(parser, relation_keys1254, relation_body1255, load_errors1256) + result1258 = _t2089 + record_span!(parser, span_start1257, "TargetRelations") + return result1258 end function parse_relation_keys(parser::ParserState)::Tuple{Vector{Proto.NamedColumn}, Bool} if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "keys", 1) if match_lookahead_literal(parser, "synthetic", 2) - _t2078 = 1 + _t2092 = 1 else if match_lookahead_literal(parser, ")", 2) - _t2079 = 0 + _t2093 = 0 else if match_lookahead_literal(parser, "(", 2) - _t2080 = 0 + _t2094 = 0 else - _t2080 = -1 + _t2094 = -1 end - _t2079 = _t2080 + _t2093 = _t2094 end - _t2078 = _t2079 + _t2092 = _t2093 end - _t2077 = _t2078 + _t2091 = _t2092 else - _t2077 = -1 + _t2091 = -1 end - _t2076 = _t2077 + _t2090 = _t2091 else - _t2076 = -1 + _t2090 = -1 end - prediction1251 = _t2076 - if prediction1251 == 1 + prediction1259 = _t2090 + if prediction1259 == 1 consume_literal!(parser, "(") consume_literal!(parser, "keys") consume_literal!(parser, "synthetic") consume_literal!(parser, ")") - _t2081 = (Proto.NamedColumn[], true,) + _t2095 = (Proto.NamedColumn[], true,) else - if prediction1251 == 0 + if prediction1259 == 0 consume_literal!(parser, "(") consume_literal!(parser, "keys") - xs1252 = Proto.NamedColumn[] - cond1253 = match_lookahead_literal(parser, "(", 0) - while cond1253 - _t2083 = parse_named_column(parser) - item1254 = _t2083 - push!(xs1252, item1254) - cond1253 = match_lookahead_literal(parser, "(", 0) + xs1260 = Proto.NamedColumn[] + cond1261 = match_lookahead_literal(parser, "(", 0) + while cond1261 + _t2097 = parse_named_column(parser) + item1262 = _t2097 + push!(xs1260, item1262) + cond1261 = match_lookahead_literal(parser, "(", 0) end - named_columns1255 = xs1252 + named_columns1263 = xs1260 consume_literal!(parser, ")") - _t2082 = (named_columns1255, false,) + _t2096 = (named_columns1263, false,) else throw(ParseError("Unexpected token in relation_keys" * ": " * string(lookahead(parser, 0)))) end - _t2081 = _t2082 + _t2095 = _t2096 end - return _t2081 + return _t2095 end function parse_named_column(parser::ParserState)::Proto.NamedColumn - span_start1258 = span_start(parser) + span_start1266 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "column") - string1256 = consume_terminal!(parser, "STRING") - _t2084 = parse_type(parser) - type1257 = _t2084 + string1264 = consume_terminal!(parser, "STRING") + _t2098 = parse_type(parser) + type1265 = _t2098 consume_literal!(parser, ")") - _t2085 = Proto.NamedColumn(name=string1256, var"#type"=type1257) - result1259 = _t2085 - record_span!(parser, span_start1258, "NamedColumn") - return result1259 + _t2099 = Proto.NamedColumn(name=string1264, var"#type"=type1265) + result1267 = _t2099 + record_span!(parser, span_start1266, "NamedColumn") + return result1267 end function parse_relation_body(parser::ParserState)::Proto.TargetRelations - span_start1264 = span_start(parser) + span_start1272 = span_start(parser) if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "relation", 1) - _t2087 = 0 + _t2101 = 0 else if match_lookahead_literal(parser, "inserts", 1) - _t2088 = 1 + _t2102 = 1 else - _t2088 = 0 + _t2102 = 0 end - _t2087 = _t2088 + _t2101 = _t2102 end - _t2086 = _t2087 + _t2100 = _t2101 else - _t2086 = 0 - end - prediction1260 = _t2086 - if prediction1260 == 1 - _t2090 = parse_cdc_inserts(parser) - cdc_inserts1262 = _t2090 - _t2091 = parse_cdc_deletes(parser) - cdc_deletes1263 = _t2091 - _t2092 = construct_cdc_relations(parser, cdc_inserts1262, cdc_deletes1263) - _t2089 = _t2092 + _t2100 = 0 + end + prediction1268 = _t2100 + if prediction1268 == 1 + _t2104 = parse_cdc_inserts(parser) + cdc_inserts1270 = _t2104 + _t2105 = parse_cdc_deletes(parser) + cdc_deletes1271 = _t2105 + _t2106 = construct_cdc_relations(parser, cdc_inserts1270, cdc_deletes1271) + _t2103 = _t2106 else - if prediction1260 == 0 - _t2094 = parse_non_cdc_relations(parser) - non_cdc_relations1261 = _t2094 - _t2095 = construct_non_cdc_relations(parser, non_cdc_relations1261) - _t2093 = _t2095 + if prediction1268 == 0 + _t2108 = parse_non_cdc_relations(parser) + non_cdc_relations1269 = _t2108 + _t2109 = construct_non_cdc_relations(parser, non_cdc_relations1269) + _t2107 = _t2109 else throw(ParseError("Unexpected token in relation_body" * ": " * string(lookahead(parser, 0)))) end - _t2089 = _t2093 + _t2103 = _t2107 end - result1265 = _t2089 - record_span!(parser, span_start1264, "TargetRelations") - return result1265 + result1273 = _t2103 + record_span!(parser, span_start1272, "TargetRelations") + return result1273 end function parse_non_cdc_relations(parser::ParserState)::Vector{Proto.TargetRelation} - xs1266 = Proto.TargetRelation[] - cond1267 = (match_lookahead_literal(parser, "(", 0) && match_lookahead_literal(parser, "relation", 1)) - while cond1267 - _t2096 = parse_target_relation(parser) - item1268 = _t2096 - push!(xs1266, item1268) - cond1267 = (match_lookahead_literal(parser, "(", 0) && match_lookahead_literal(parser, "relation", 1)) + xs1274 = Proto.TargetRelation[] + cond1275 = (match_lookahead_literal(parser, "(", 0) && match_lookahead_literal(parser, "relation", 1)) + while cond1275 + _t2110 = parse_target_relation(parser) + item1276 = _t2110 + push!(xs1274, item1276) + cond1275 = (match_lookahead_literal(parser, "(", 0) && match_lookahead_literal(parser, "relation", 1)) end - return xs1266 + return xs1274 end function parse_target_relation(parser::ParserState)::Proto.TargetRelation - span_start1274 = span_start(parser) + span_start1282 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "relation") - _t2097 = parse_relation_id(parser) - relation_id1269 = _t2097 - xs1270 = Proto.NamedColumn[] - cond1271 = match_lookahead_literal(parser, "(", 0) - while cond1271 - _t2098 = parse_named_column(parser) - item1272 = _t2098 - push!(xs1270, item1272) - cond1271 = match_lookahead_literal(parser, "(", 0) - end - named_columns1273 = xs1270 + _t2111 = parse_relation_id(parser) + relation_id1277 = _t2111 + xs1278 = Proto.NamedColumn[] + cond1279 = match_lookahead_literal(parser, "(", 0) + while cond1279 + _t2112 = parse_named_column(parser) + item1280 = _t2112 + push!(xs1278, item1280) + cond1279 = match_lookahead_literal(parser, "(", 0) + end + named_columns1281 = xs1278 consume_literal!(parser, ")") - _t2099 = Proto.TargetRelation(target_id=relation_id1269, values=named_columns1273) - result1275 = _t2099 - record_span!(parser, span_start1274, "TargetRelation") - return result1275 + _t2113 = Proto.TargetRelation(target_id=relation_id1277, values=named_columns1281) + result1283 = _t2113 + record_span!(parser, span_start1282, "TargetRelation") + return result1283 end function parse_cdc_inserts(parser::ParserState)::Vector{Proto.TargetRelation} consume_literal!(parser, "(") consume_literal!(parser, "inserts") - xs1276 = Proto.TargetRelation[] - cond1277 = match_lookahead_literal(parser, "(", 0) - while cond1277 - _t2100 = parse_target_relation(parser) - item1278 = _t2100 - push!(xs1276, item1278) - cond1277 = match_lookahead_literal(parser, "(", 0) - end - target_relations1279 = xs1276 + xs1284 = Proto.TargetRelation[] + cond1285 = match_lookahead_literal(parser, "(", 0) + while cond1285 + _t2114 = parse_target_relation(parser) + item1286 = _t2114 + push!(xs1284, item1286) + cond1285 = match_lookahead_literal(parser, "(", 0) + end + target_relations1287 = xs1284 consume_literal!(parser, ")") - return target_relations1279 + return target_relations1287 end function parse_cdc_deletes(parser::ParserState)::Vector{Proto.TargetRelation} consume_literal!(parser, "(") consume_literal!(parser, "deletes") - xs1280 = Proto.TargetRelation[] - cond1281 = match_lookahead_literal(parser, "(", 0) - while cond1281 - _t2101 = parse_target_relation(parser) - item1282 = _t2101 - push!(xs1280, item1282) - cond1281 = match_lookahead_literal(parser, "(", 0) - end - target_relations1283 = xs1280 + xs1288 = Proto.TargetRelation[] + cond1289 = match_lookahead_literal(parser, "(", 0) + while cond1289 + _t2115 = parse_target_relation(parser) + item1290 = _t2115 + push!(xs1288, item1290) + cond1289 = match_lookahead_literal(parser, "(", 0) + end + target_relations1291 = xs1288 consume_literal!(parser, ")") - return target_relations1283 + return target_relations1291 end function parse_load_errors(parser::ParserState)::Proto.RelationId - span_start1285 = span_start(parser) + span_start1293 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "load_errors") - _t2102 = parse_relation_id(parser) - relation_id1284 = _t2102 + _t2116 = parse_relation_id(parser) + relation_id1292 = _t2116 consume_literal!(parser, ")") - result1286 = relation_id1284 - record_span!(parser, span_start1285, "RelationId") - return result1286 + result1294 = relation_id1292 + record_span!(parser, span_start1293, "RelationId") + return result1294 end function parse_csv_asof(parser::ParserState)::String consume_literal!(parser, "(") consume_literal!(parser, "asof") - string1287 = consume_terminal!(parser, "STRING") + string1295 = consume_terminal!(parser, "STRING") consume_literal!(parser, ")") - return string1287 + return string1295 end function parse_iceberg_data(parser::ParserState)::Proto.IcebergData - span_start1294 = span_start(parser) + span_start1302 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "iceberg_data") - _t2103 = parse_iceberg_locator(parser) - iceberg_locator1288 = _t2103 - _t2104 = parse_iceberg_catalog_config(parser) - iceberg_catalog_config1289 = _t2104 - _t2105 = parse_gnf_columns(parser) - gnf_columns1290 = _t2105 + _t2117 = parse_iceberg_locator(parser) + iceberg_locator1296 = _t2117 + _t2118 = parse_iceberg_catalog_config(parser) + iceberg_catalog_config1297 = _t2118 + _t2119 = parse_gnf_columns(parser) + gnf_columns1298 = _t2119 if (match_lookahead_literal(parser, "(", 0) && match_lookahead_literal(parser, "from_snapshot", 1)) - _t2107 = parse_iceberg_from_snapshot(parser) - _t2106 = _t2107 + _t2121 = parse_iceberg_from_snapshot(parser) + _t2120 = _t2121 else - _t2106 = nothing + _t2120 = nothing end - iceberg_from_snapshot1291 = _t2106 + iceberg_from_snapshot1299 = _t2120 if match_lookahead_literal(parser, "(", 0) - _t2109 = parse_iceberg_to_snapshot(parser) - _t2108 = _t2109 + _t2123 = parse_iceberg_to_snapshot(parser) + _t2122 = _t2123 else - _t2108 = nothing + _t2122 = nothing end - iceberg_to_snapshot1292 = _t2108 - _t2110 = parse_boolean_value(parser) - boolean_value1293 = _t2110 + iceberg_to_snapshot1300 = _t2122 + _t2124 = parse_boolean_value(parser) + boolean_value1301 = _t2124 consume_literal!(parser, ")") - _t2111 = construct_iceberg_data(parser, iceberg_locator1288, iceberg_catalog_config1289, gnf_columns1290, iceberg_from_snapshot1291, iceberg_to_snapshot1292, boolean_value1293) - result1295 = _t2111 - record_span!(parser, span_start1294, "IcebergData") - return result1295 + _t2125 = construct_iceberg_data(parser, iceberg_locator1296, iceberg_catalog_config1297, gnf_columns1298, iceberg_from_snapshot1299, iceberg_to_snapshot1300, boolean_value1301) + result1303 = _t2125 + record_span!(parser, span_start1302, "IcebergData") + return result1303 end function parse_iceberg_locator(parser::ParserState)::Proto.IcebergLocator - span_start1299 = span_start(parser) + span_start1307 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "iceberg_locator") - _t2112 = parse_iceberg_locator_table_name(parser) - iceberg_locator_table_name1296 = _t2112 - _t2113 = parse_iceberg_locator_namespace(parser) - iceberg_locator_namespace1297 = _t2113 - _t2114 = parse_iceberg_locator_warehouse(parser) - iceberg_locator_warehouse1298 = _t2114 + _t2126 = parse_iceberg_locator_table_name(parser) + iceberg_locator_table_name1304 = _t2126 + _t2127 = parse_iceberg_locator_namespace(parser) + iceberg_locator_namespace1305 = _t2127 + _t2128 = parse_iceberg_locator_warehouse(parser) + iceberg_locator_warehouse1306 = _t2128 consume_literal!(parser, ")") - _t2115 = Proto.IcebergLocator(table_name=iceberg_locator_table_name1296, namespace=iceberg_locator_namespace1297, warehouse=iceberg_locator_warehouse1298) - result1300 = _t2115 - record_span!(parser, span_start1299, "IcebergLocator") - return result1300 + _t2129 = Proto.IcebergLocator(table_name=iceberg_locator_table_name1304, namespace=iceberg_locator_namespace1305, warehouse=iceberg_locator_warehouse1306) + result1308 = _t2129 + record_span!(parser, span_start1307, "IcebergLocator") + return result1308 end function parse_iceberg_locator_table_name(parser::ParserState)::String consume_literal!(parser, "(") consume_literal!(parser, "table_name") - string1301 = consume_terminal!(parser, "STRING") + string1309 = consume_terminal!(parser, "STRING") consume_literal!(parser, ")") - return string1301 + return string1309 end function parse_iceberg_locator_namespace(parser::ParserState)::Vector{String} consume_literal!(parser, "(") consume_literal!(parser, "namespace") - xs1302 = String[] - cond1303 = match_lookahead_terminal(parser, "STRING", 0) - while cond1303 - item1304 = consume_terminal!(parser, "STRING") - push!(xs1302, item1304) - cond1303 = match_lookahead_terminal(parser, "STRING", 0) - end - strings1305 = xs1302 + xs1310 = String[] + cond1311 = match_lookahead_terminal(parser, "STRING", 0) + while cond1311 + item1312 = consume_terminal!(parser, "STRING") + push!(xs1310, item1312) + cond1311 = match_lookahead_terminal(parser, "STRING", 0) + end + strings1313 = xs1310 consume_literal!(parser, ")") - return strings1305 + return strings1313 end function parse_iceberg_locator_warehouse(parser::ParserState)::String consume_literal!(parser, "(") consume_literal!(parser, "warehouse") - string1306 = consume_terminal!(parser, "STRING") + string1314 = consume_terminal!(parser, "STRING") consume_literal!(parser, ")") - return string1306 + return string1314 end function parse_iceberg_catalog_config(parser::ParserState)::Proto.IcebergCatalogConfig - span_start1311 = span_start(parser) + span_start1319 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "iceberg_catalog_config") - _t2116 = parse_iceberg_catalog_uri(parser) - iceberg_catalog_uri1307 = _t2116 + _t2130 = parse_iceberg_catalog_uri(parser) + iceberg_catalog_uri1315 = _t2130 if (match_lookahead_literal(parser, "(", 0) && match_lookahead_literal(parser, "scope", 1)) - _t2118 = parse_iceberg_catalog_config_scope(parser) - _t2117 = _t2118 + _t2132 = parse_iceberg_catalog_config_scope(parser) + _t2131 = _t2132 else - _t2117 = nothing + _t2131 = nothing end - iceberg_catalog_config_scope1308 = _t2117 - _t2119 = parse_iceberg_properties(parser) - iceberg_properties1309 = _t2119 - _t2120 = parse_iceberg_auth_properties(parser) - iceberg_auth_properties1310 = _t2120 + iceberg_catalog_config_scope1316 = _t2131 + _t2133 = parse_iceberg_properties(parser) + iceberg_properties1317 = _t2133 + _t2134 = parse_iceberg_auth_properties(parser) + iceberg_auth_properties1318 = _t2134 consume_literal!(parser, ")") - _t2121 = construct_iceberg_catalog_config(parser, iceberg_catalog_uri1307, iceberg_catalog_config_scope1308, iceberg_properties1309, iceberg_auth_properties1310) - result1312 = _t2121 - record_span!(parser, span_start1311, "IcebergCatalogConfig") - return result1312 + _t2135 = construct_iceberg_catalog_config(parser, iceberg_catalog_uri1315, iceberg_catalog_config_scope1316, iceberg_properties1317, iceberg_auth_properties1318) + result1320 = _t2135 + record_span!(parser, span_start1319, "IcebergCatalogConfig") + return result1320 end function parse_iceberg_catalog_uri(parser::ParserState)::String consume_literal!(parser, "(") consume_literal!(parser, "catalog_uri") - string1313 = consume_terminal!(parser, "STRING") + string1321 = consume_terminal!(parser, "STRING") consume_literal!(parser, ")") - return string1313 + return string1321 end function parse_iceberg_catalog_config_scope(parser::ParserState)::String consume_literal!(parser, "(") consume_literal!(parser, "scope") - string1314 = consume_terminal!(parser, "STRING") + string1322 = consume_terminal!(parser, "STRING") consume_literal!(parser, ")") - return string1314 + return string1322 end function parse_iceberg_properties(parser::ParserState)::Vector{Tuple{String, String}} consume_literal!(parser, "(") consume_literal!(parser, "properties") - xs1315 = Tuple{String, String}[] - cond1316 = match_lookahead_literal(parser, "(", 0) - while cond1316 - _t2122 = parse_iceberg_property_entry(parser) - item1317 = _t2122 - push!(xs1315, item1317) - cond1316 = match_lookahead_literal(parser, "(", 0) - end - iceberg_property_entrys1318 = xs1315 + xs1323 = Tuple{String, String}[] + cond1324 = match_lookahead_literal(parser, "(", 0) + while cond1324 + _t2136 = parse_iceberg_property_entry(parser) + item1325 = _t2136 + push!(xs1323, item1325) + cond1324 = match_lookahead_literal(parser, "(", 0) + end + iceberg_property_entrys1326 = xs1323 consume_literal!(parser, ")") - return iceberg_property_entrys1318 + return iceberg_property_entrys1326 end function parse_iceberg_property_entry(parser::ParserState)::Tuple{String, String} consume_literal!(parser, "(") consume_literal!(parser, "prop") - string1319 = consume_terminal!(parser, "STRING") - string_31320 = consume_terminal!(parser, "STRING") + string1327 = consume_terminal!(parser, "STRING") + string_31328 = consume_terminal!(parser, "STRING") consume_literal!(parser, ")") - return (string1319, string_31320,) + return (string1327, string_31328,) end function parse_iceberg_auth_properties(parser::ParserState)::Vector{Tuple{String, String}} consume_literal!(parser, "(") consume_literal!(parser, "auth_properties") - xs1321 = Tuple{String, String}[] - cond1322 = match_lookahead_literal(parser, "(", 0) - while cond1322 - _t2123 = parse_iceberg_masked_property_entry(parser) - item1323 = _t2123 - push!(xs1321, item1323) - cond1322 = match_lookahead_literal(parser, "(", 0) - end - iceberg_masked_property_entrys1324 = xs1321 + xs1329 = Tuple{String, String}[] + cond1330 = match_lookahead_literal(parser, "(", 0) + while cond1330 + _t2137 = parse_iceberg_masked_property_entry(parser) + item1331 = _t2137 + push!(xs1329, item1331) + cond1330 = match_lookahead_literal(parser, "(", 0) + end + iceberg_masked_property_entrys1332 = xs1329 consume_literal!(parser, ")") - return iceberg_masked_property_entrys1324 + return iceberg_masked_property_entrys1332 end function parse_iceberg_masked_property_entry(parser::ParserState)::Tuple{String, String} consume_literal!(parser, "(") consume_literal!(parser, "prop") - string1325 = consume_terminal!(parser, "STRING") - string_31326 = consume_terminal!(parser, "STRING") + string1333 = consume_terminal!(parser, "STRING") + string_31334 = consume_terminal!(parser, "STRING") consume_literal!(parser, ")") - return (string1325, string_31326,) + return (string1333, string_31334,) end function parse_iceberg_from_snapshot(parser::ParserState)::String consume_literal!(parser, "(") consume_literal!(parser, "from_snapshot") - string1327 = consume_terminal!(parser, "STRING") + string1335 = consume_terminal!(parser, "STRING") consume_literal!(parser, ")") - return string1327 + return string1335 end function parse_iceberg_to_snapshot(parser::ParserState)::String consume_literal!(parser, "(") consume_literal!(parser, "to_snapshot") - string1328 = consume_terminal!(parser, "STRING") + string1336 = consume_terminal!(parser, "STRING") consume_literal!(parser, ")") - return string1328 + return string1336 end function parse_undefine(parser::ParserState)::Proto.Undefine - span_start1330 = span_start(parser) + span_start1338 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "undefine") - _t2124 = parse_fragment_id(parser) - fragment_id1329 = _t2124 + _t2138 = parse_fragment_id(parser) + fragment_id1337 = _t2138 consume_literal!(parser, ")") - _t2125 = Proto.Undefine(fragment_id=fragment_id1329) - result1331 = _t2125 - record_span!(parser, span_start1330, "Undefine") - return result1331 + _t2139 = Proto.Undefine(fragment_id=fragment_id1337) + result1339 = _t2139 + record_span!(parser, span_start1338, "Undefine") + return result1339 end function parse_context(parser::ParserState)::Proto.Context - span_start1336 = span_start(parser) + span_start1344 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "context") - xs1332 = Proto.RelationId[] - cond1333 = (match_lookahead_literal(parser, ":", 0) || match_lookahead_terminal(parser, "UINT128", 0)) - while cond1333 - _t2126 = parse_relation_id(parser) - item1334 = _t2126 - push!(xs1332, item1334) - cond1333 = (match_lookahead_literal(parser, ":", 0) || match_lookahead_terminal(parser, "UINT128", 0)) - end - relation_ids1335 = xs1332 + xs1340 = Proto.RelationId[] + cond1341 = (match_lookahead_literal(parser, ":", 0) || match_lookahead_terminal(parser, "UINT128", 0)) + while cond1341 + _t2140 = parse_relation_id(parser) + item1342 = _t2140 + push!(xs1340, item1342) + cond1341 = (match_lookahead_literal(parser, ":", 0) || match_lookahead_terminal(parser, "UINT128", 0)) + end + relation_ids1343 = xs1340 consume_literal!(parser, ")") - _t2127 = Proto.Context(relations=relation_ids1335) - result1337 = _t2127 - record_span!(parser, span_start1336, "Context") - return result1337 + _t2141 = Proto.Context(relations=relation_ids1343) + result1345 = _t2141 + record_span!(parser, span_start1344, "Context") + return result1345 end function parse_snapshot(parser::ParserState)::Proto.Snapshot - span_start1343 = span_start(parser) + span_start1351 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "snapshot") - _t2128 = parse_edb_path(parser) - edb_path1338 = _t2128 - xs1339 = Proto.SnapshotMapping[] - cond1340 = match_lookahead_literal(parser, "[", 0) - while cond1340 - _t2129 = parse_snapshot_mapping(parser) - item1341 = _t2129 - push!(xs1339, item1341) - cond1340 = match_lookahead_literal(parser, "[", 0) - end - snapshot_mappings1342 = xs1339 + _t2142 = parse_edb_path(parser) + edb_path1346 = _t2142 + xs1347 = Proto.SnapshotMapping[] + cond1348 = match_lookahead_literal(parser, "[", 0) + while cond1348 + _t2143 = parse_snapshot_mapping(parser) + item1349 = _t2143 + push!(xs1347, item1349) + cond1348 = match_lookahead_literal(parser, "[", 0) + end + snapshot_mappings1350 = xs1347 consume_literal!(parser, ")") - _t2130 = Proto.Snapshot(mappings=snapshot_mappings1342, prefix=edb_path1338) - result1344 = _t2130 - record_span!(parser, span_start1343, "Snapshot") - return result1344 + _t2144 = Proto.Snapshot(mappings=snapshot_mappings1350, prefix=edb_path1346) + result1352 = _t2144 + record_span!(parser, span_start1351, "Snapshot") + return result1352 end function parse_snapshot_mapping(parser::ParserState)::Proto.SnapshotMapping - span_start1347 = span_start(parser) - _t2131 = parse_edb_path(parser) - edb_path1345 = _t2131 - _t2132 = parse_relation_id(parser) - relation_id1346 = _t2132 - _t2133 = Proto.SnapshotMapping(destination_path=edb_path1345, source_relation=relation_id1346) - result1348 = _t2133 - record_span!(parser, span_start1347, "SnapshotMapping") - return result1348 + span_start1355 = span_start(parser) + _t2145 = parse_edb_path(parser) + edb_path1353 = _t2145 + _t2146 = parse_relation_id(parser) + relation_id1354 = _t2146 + _t2147 = Proto.SnapshotMapping(destination_path=edb_path1353, source_relation=relation_id1354) + result1356 = _t2147 + record_span!(parser, span_start1355, "SnapshotMapping") + return result1356 end function parse_epoch_reads(parser::ParserState)::Vector{Proto.Read} consume_literal!(parser, "(") consume_literal!(parser, "reads") - xs1349 = Proto.Read[] - cond1350 = match_lookahead_literal(parser, "(", 0) - while cond1350 - _t2134 = parse_read(parser) - item1351 = _t2134 - push!(xs1349, item1351) - cond1350 = match_lookahead_literal(parser, "(", 0) - end - reads1352 = xs1349 + xs1357 = Proto.Read[] + cond1358 = match_lookahead_literal(parser, "(", 0) + while cond1358 + _t2148 = parse_read(parser) + item1359 = _t2148 + push!(xs1357, item1359) + cond1358 = match_lookahead_literal(parser, "(", 0) + end + reads1360 = xs1357 consume_literal!(parser, ")") - return reads1352 + return reads1360 end function parse_read(parser::ParserState)::Proto.Read - span_start1359 = span_start(parser) + span_start1367 = span_start(parser) if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "what_if", 1) - _t2136 = 2 + _t2150 = 2 else if match_lookahead_literal(parser, "output", 1) - _t2137 = 1 + _t2151 = 1 else if match_lookahead_literal(parser, "export_iceberg", 1) - _t2138 = 4 + _t2152 = 4 else if match_lookahead_literal(parser, "export", 1) - _t2139 = 4 + _t2153 = 4 else if match_lookahead_literal(parser, "demand", 1) - _t2140 = 0 + _t2154 = 0 else if match_lookahead_literal(parser, "abort", 1) - _t2141 = 3 + _t2155 = 3 else - _t2141 = -1 + _t2155 = -1 end - _t2140 = _t2141 + _t2154 = _t2155 end - _t2139 = _t2140 + _t2153 = _t2154 end - _t2138 = _t2139 + _t2152 = _t2153 end - _t2137 = _t2138 + _t2151 = _t2152 end - _t2136 = _t2137 + _t2150 = _t2151 end - _t2135 = _t2136 + _t2149 = _t2150 else - _t2135 = -1 - end - prediction1353 = _t2135 - if prediction1353 == 4 - _t2143 = parse_export(parser) - export1358 = _t2143 - _t2144 = Proto.Read(read_type=OneOf(:var"#export", export1358)) - _t2142 = _t2144 + _t2149 = -1 + end + prediction1361 = _t2149 + if prediction1361 == 4 + _t2157 = parse_export(parser) + export1366 = _t2157 + _t2158 = Proto.Read(read_type=OneOf(:var"#export", export1366)) + _t2156 = _t2158 else - if prediction1353 == 3 - _t2146 = parse_abort(parser) - abort1357 = _t2146 - _t2147 = Proto.Read(read_type=OneOf(:abort, abort1357)) - _t2145 = _t2147 + if prediction1361 == 3 + _t2160 = parse_abort(parser) + abort1365 = _t2160 + _t2161 = Proto.Read(read_type=OneOf(:abort, abort1365)) + _t2159 = _t2161 else - if prediction1353 == 2 - _t2149 = parse_what_if(parser) - what_if1356 = _t2149 - _t2150 = Proto.Read(read_type=OneOf(:what_if, what_if1356)) - _t2148 = _t2150 + if prediction1361 == 2 + _t2163 = parse_what_if(parser) + what_if1364 = _t2163 + _t2164 = Proto.Read(read_type=OneOf(:what_if, what_if1364)) + _t2162 = _t2164 else - if prediction1353 == 1 - _t2152 = parse_output(parser) - output1355 = _t2152 - _t2153 = Proto.Read(read_type=OneOf(:output, output1355)) - _t2151 = _t2153 + if prediction1361 == 1 + _t2166 = parse_output(parser) + output1363 = _t2166 + _t2167 = Proto.Read(read_type=OneOf(:output, output1363)) + _t2165 = _t2167 else - if prediction1353 == 0 - _t2155 = parse_demand(parser) - demand1354 = _t2155 - _t2156 = Proto.Read(read_type=OneOf(:demand, demand1354)) - _t2154 = _t2156 + if prediction1361 == 0 + _t2169 = parse_demand(parser) + demand1362 = _t2169 + _t2170 = Proto.Read(read_type=OneOf(:demand, demand1362)) + _t2168 = _t2170 else throw(ParseError("Unexpected token in read" * ": " * string(lookahead(parser, 0)))) end - _t2151 = _t2154 + _t2165 = _t2168 end - _t2148 = _t2151 + _t2162 = _t2165 end - _t2145 = _t2148 + _t2159 = _t2162 end - _t2142 = _t2145 + _t2156 = _t2159 end - result1360 = _t2142 - record_span!(parser, span_start1359, "Read") - return result1360 + result1368 = _t2156 + record_span!(parser, span_start1367, "Read") + return result1368 end function parse_demand(parser::ParserState)::Proto.Demand - span_start1362 = span_start(parser) + span_start1370 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "demand") - _t2157 = parse_relation_id(parser) - relation_id1361 = _t2157 + _t2171 = parse_relation_id(parser) + relation_id1369 = _t2171 consume_literal!(parser, ")") - _t2158 = Proto.Demand(relation_id=relation_id1361) - result1363 = _t2158 - record_span!(parser, span_start1362, "Demand") - return result1363 + _t2172 = Proto.Demand(relation_id=relation_id1369) + result1371 = _t2172 + record_span!(parser, span_start1370, "Demand") + return result1371 end function parse_output(parser::ParserState)::Proto.Output - span_start1366 = span_start(parser) + span_start1374 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "output") - _t2159 = parse_name(parser) - name1364 = _t2159 - _t2160 = parse_relation_id(parser) - relation_id1365 = _t2160 + _t2173 = parse_name(parser) + name1372 = _t2173 + _t2174 = parse_relation_id(parser) + relation_id1373 = _t2174 consume_literal!(parser, ")") - _t2161 = Proto.Output(name=name1364, relation_id=relation_id1365) - result1367 = _t2161 - record_span!(parser, span_start1366, "Output") - return result1367 + _t2175 = Proto.Output(name=name1372, relation_id=relation_id1373) + result1375 = _t2175 + record_span!(parser, span_start1374, "Output") + return result1375 end function parse_what_if(parser::ParserState)::Proto.WhatIf - span_start1370 = span_start(parser) + span_start1378 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "what_if") - _t2162 = parse_name(parser) - name1368 = _t2162 - _t2163 = parse_epoch(parser) - epoch1369 = _t2163 + _t2176 = parse_name(parser) + name1376 = _t2176 + _t2177 = parse_epoch(parser) + epoch1377 = _t2177 consume_literal!(parser, ")") - _t2164 = Proto.WhatIf(branch=name1368, epoch=epoch1369) - result1371 = _t2164 - record_span!(parser, span_start1370, "WhatIf") - return result1371 + _t2178 = Proto.WhatIf(branch=name1376, epoch=epoch1377) + result1379 = _t2178 + record_span!(parser, span_start1378, "WhatIf") + return result1379 end function parse_abort(parser::ParserState)::Proto.Abort - span_start1374 = span_start(parser) + span_start1382 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "abort") if (match_lookahead_literal(parser, ":", 0) && match_lookahead_terminal(parser, "SYMBOL", 1)) - _t2166 = parse_name(parser) - _t2165 = _t2166 + _t2180 = parse_name(parser) + _t2179 = _t2180 else - _t2165 = nothing + _t2179 = nothing end - name1372 = _t2165 - _t2167 = parse_relation_id(parser) - relation_id1373 = _t2167 + name1380 = _t2179 + _t2181 = parse_relation_id(parser) + relation_id1381 = _t2181 consume_literal!(parser, ")") - _t2168 = Proto.Abort(name=(!isnothing(name1372) ? name1372 : "abort"), relation_id=relation_id1373) - result1375 = _t2168 - record_span!(parser, span_start1374, "Abort") - return result1375 + _t2182 = Proto.Abort(name=(!isnothing(name1380) ? name1380 : "abort"), relation_id=relation_id1381) + result1383 = _t2182 + record_span!(parser, span_start1382, "Abort") + return result1383 end function parse_export(parser::ParserState)::Proto.Export - span_start1379 = span_start(parser) + span_start1387 = span_start(parser) if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "export_iceberg", 1) - _t2170 = 1 + _t2184 = 1 else if match_lookahead_literal(parser, "export", 1) - _t2171 = 0 + _t2185 = 0 else - _t2171 = -1 + _t2185 = -1 end - _t2170 = _t2171 + _t2184 = _t2185 end - _t2169 = _t2170 + _t2183 = _t2184 else - _t2169 = -1 + _t2183 = -1 end - prediction1376 = _t2169 - if prediction1376 == 1 + prediction1384 = _t2183 + if prediction1384 == 1 consume_literal!(parser, "(") consume_literal!(parser, "export_iceberg") - _t2173 = parse_export_iceberg_config(parser) - export_iceberg_config1378 = _t2173 + _t2187 = parse_export_iceberg_config(parser) + export_iceberg_config1386 = _t2187 consume_literal!(parser, ")") - _t2174 = Proto.Export(export_config=OneOf(:iceberg_config, export_iceberg_config1378)) - _t2172 = _t2174 + _t2188 = Proto.Export(export_config=OneOf(:iceberg_config, export_iceberg_config1386)) + _t2186 = _t2188 else - if prediction1376 == 0 + if prediction1384 == 0 consume_literal!(parser, "(") consume_literal!(parser, "export") - _t2176 = parse_export_csv_config(parser) - export_csv_config1377 = _t2176 + _t2190 = parse_export_csv_config(parser) + export_csv_config1385 = _t2190 consume_literal!(parser, ")") - _t2177 = Proto.Export(export_config=OneOf(:csv_config, export_csv_config1377)) - _t2175 = _t2177 + _t2191 = Proto.Export(export_config=OneOf(:csv_config, export_csv_config1385)) + _t2189 = _t2191 else throw(ParseError("Unexpected token in export" * ": " * string(lookahead(parser, 0)))) end - _t2172 = _t2175 + _t2186 = _t2189 end - result1380 = _t2172 - record_span!(parser, span_start1379, "Export") - return result1380 + result1388 = _t2186 + record_span!(parser, span_start1387, "Export") + return result1388 end function parse_export_csv_config(parser::ParserState)::Proto.ExportCSVConfig - span_start1388 = span_start(parser) + span_start1396 = span_start(parser) if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "export_csv_config_v2", 1) - _t2179 = 0 + _t2193 = 0 else if match_lookahead_literal(parser, "export_csv_config", 1) - _t2180 = 1 + _t2194 = 1 else - _t2180 = -1 + _t2194 = -1 end - _t2179 = _t2180 + _t2193 = _t2194 end - _t2178 = _t2179 + _t2192 = _t2193 else - _t2178 = -1 + _t2192 = -1 end - prediction1381 = _t2178 - if prediction1381 == 1 + prediction1389 = _t2192 + if prediction1389 == 1 consume_literal!(parser, "(") consume_literal!(parser, "export_csv_config") - _t2182 = parse_export_csv_path(parser) - export_csv_path1385 = _t2182 - _t2183 = parse_export_csv_columns_list(parser) - export_csv_columns_list1386 = _t2183 - _t2184 = parse_config_dict(parser) - config_dict1387 = _t2184 + _t2196 = parse_export_csv_path(parser) + export_csv_path1393 = _t2196 + _t2197 = parse_export_csv_columns_list(parser) + export_csv_columns_list1394 = _t2197 + _t2198 = parse_config_dict(parser) + config_dict1395 = _t2198 consume_literal!(parser, ")") - _t2185 = construct_export_csv_config(parser, export_csv_path1385, export_csv_columns_list1386, config_dict1387) - _t2181 = _t2185 + _t2199 = construct_export_csv_config(parser, export_csv_path1393, export_csv_columns_list1394, config_dict1395) + _t2195 = _t2199 else - if prediction1381 == 0 + if prediction1389 == 0 consume_literal!(parser, "(") consume_literal!(parser, "export_csv_config_v2") - _t2187 = parse_export_csv_output_location(parser) - export_csv_output_location1382 = _t2187 - _t2188 = parse_export_csv_source(parser) - export_csv_source1383 = _t2188 - _t2189 = parse_csv_config(parser) - csv_config1384 = _t2189 + _t2201 = parse_export_csv_output_location(parser) + export_csv_output_location1390 = _t2201 + _t2202 = parse_export_csv_source(parser) + export_csv_source1391 = _t2202 + _t2203 = parse_csv_config(parser) + csv_config1392 = _t2203 consume_literal!(parser, ")") - _t2190 = construct_export_csv_config_with_location(parser, export_csv_output_location1382, export_csv_source1383, csv_config1384) - _t2186 = _t2190 + _t2204 = construct_export_csv_config_with_location(parser, export_csv_output_location1390, export_csv_source1391, csv_config1392) + _t2200 = _t2204 else throw(ParseError("Unexpected token in export_csv_config" * ": " * string(lookahead(parser, 0)))) end - _t2181 = _t2186 + _t2195 = _t2200 end - result1389 = _t2181 - record_span!(parser, span_start1388, "ExportCSVConfig") - return result1389 + result1397 = _t2195 + record_span!(parser, span_start1396, "ExportCSVConfig") + return result1397 end function parse_export_csv_output_location(parser::ParserState)::Tuple{String, String} if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "transaction_output_name", 1) - _t2192 = 1 + _t2206 = 1 else if match_lookahead_literal(parser, "path", 1) - _t2193 = 0 + _t2207 = 0 else - _t2193 = -1 + _t2207 = -1 end - _t2192 = _t2193 + _t2206 = _t2207 end - _t2191 = _t2192 + _t2205 = _t2206 else - _t2191 = -1 + _t2205 = -1 end - prediction1390 = _t2191 - if prediction1390 == 1 + prediction1398 = _t2205 + if prediction1398 == 1 consume_literal!(parser, "(") consume_literal!(parser, "transaction_output_name") - _t2195 = parse_name(parser) - name1392 = _t2195 + _t2209 = parse_name(parser) + name1400 = _t2209 consume_literal!(parser, ")") - _t2194 = ("", name1392,) + _t2208 = ("", name1400,) else - if prediction1390 == 0 + if prediction1398 == 0 consume_literal!(parser, "(") consume_literal!(parser, "path") - string1391 = consume_terminal!(parser, "STRING") + string1399 = consume_terminal!(parser, "STRING") consume_literal!(parser, ")") - _t2196 = (string1391, "",) + _t2210 = (string1399, "",) else throw(ParseError("Unexpected token in export_csv_output_location" * ": " * string(lookahead(parser, 0)))) end - _t2194 = _t2196 + _t2208 = _t2210 end - return _t2194 + return _t2208 end function parse_export_csv_source(parser::ParserState)::Proto.ExportCSVSource - span_start1399 = span_start(parser) + span_start1407 = span_start(parser) if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "table_def", 1) - _t2198 = 1 + _t2212 = 1 else if match_lookahead_literal(parser, "gnf_columns", 1) - _t2199 = 0 + _t2213 = 0 else - _t2199 = -1 + _t2213 = -1 end - _t2198 = _t2199 + _t2212 = _t2213 end - _t2197 = _t2198 + _t2211 = _t2212 else - _t2197 = -1 + _t2211 = -1 end - prediction1393 = _t2197 - if prediction1393 == 1 + prediction1401 = _t2211 + if prediction1401 == 1 consume_literal!(parser, "(") consume_literal!(parser, "table_def") - _t2201 = parse_relation_id(parser) - relation_id1398 = _t2201 + _t2215 = parse_relation_id(parser) + relation_id1406 = _t2215 consume_literal!(parser, ")") - _t2202 = Proto.ExportCSVSource(csv_source=OneOf(:table_def, relation_id1398)) - _t2200 = _t2202 + _t2216 = Proto.ExportCSVSource(csv_source=OneOf(:table_def, relation_id1406)) + _t2214 = _t2216 else - if prediction1393 == 0 + if prediction1401 == 0 consume_literal!(parser, "(") consume_literal!(parser, "gnf_columns") - xs1394 = Proto.ExportCSVColumn[] - cond1395 = match_lookahead_literal(parser, "(", 0) - while cond1395 - _t2204 = parse_export_csv_column(parser) - item1396 = _t2204 - push!(xs1394, item1396) - cond1395 = match_lookahead_literal(parser, "(", 0) + xs1402 = Proto.ExportCSVColumn[] + cond1403 = match_lookahead_literal(parser, "(", 0) + while cond1403 + _t2218 = parse_export_csv_column(parser) + item1404 = _t2218 + push!(xs1402, item1404) + cond1403 = match_lookahead_literal(parser, "(", 0) end - export_csv_columns1397 = xs1394 + export_csv_columns1405 = xs1402 consume_literal!(parser, ")") - _t2205 = Proto.ExportCSVColumns(columns=export_csv_columns1397) - _t2206 = Proto.ExportCSVSource(csv_source=OneOf(:gnf_columns, _t2205)) - _t2203 = _t2206 + _t2219 = Proto.ExportCSVColumns(columns=export_csv_columns1405) + _t2220 = Proto.ExportCSVSource(csv_source=OneOf(:gnf_columns, _t2219)) + _t2217 = _t2220 else throw(ParseError("Unexpected token in export_csv_source" * ": " * string(lookahead(parser, 0)))) end - _t2200 = _t2203 + _t2214 = _t2217 end - result1400 = _t2200 - record_span!(parser, span_start1399, "ExportCSVSource") - return result1400 + result1408 = _t2214 + record_span!(parser, span_start1407, "ExportCSVSource") + return result1408 end function parse_export_csv_column(parser::ParserState)::Proto.ExportCSVColumn - span_start1403 = span_start(parser) + span_start1411 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "column") - string1401 = consume_terminal!(parser, "STRING") - _t2207 = parse_relation_id(parser) - relation_id1402 = _t2207 + string1409 = consume_terminal!(parser, "STRING") + _t2221 = parse_relation_id(parser) + relation_id1410 = _t2221 consume_literal!(parser, ")") - _t2208 = Proto.ExportCSVColumn(column_name=string1401, column_data=relation_id1402) - result1404 = _t2208 - record_span!(parser, span_start1403, "ExportCSVColumn") - return result1404 + _t2222 = Proto.ExportCSVColumn(column_name=string1409, column_data=relation_id1410) + result1412 = _t2222 + record_span!(parser, span_start1411, "ExportCSVColumn") + return result1412 end function parse_export_csv_path(parser::ParserState)::String consume_literal!(parser, "(") consume_literal!(parser, "path") - string1405 = consume_terminal!(parser, "STRING") + string1413 = consume_terminal!(parser, "STRING") consume_literal!(parser, ")") - return string1405 + return string1413 end function parse_export_csv_columns_list(parser::ParserState)::Vector{Proto.ExportCSVColumn} consume_literal!(parser, "(") consume_literal!(parser, "columns") - xs1406 = Proto.ExportCSVColumn[] - cond1407 = match_lookahead_literal(parser, "(", 0) - while cond1407 - _t2209 = parse_export_csv_column(parser) - item1408 = _t2209 - push!(xs1406, item1408) - cond1407 = match_lookahead_literal(parser, "(", 0) - end - export_csv_columns1409 = xs1406 + xs1414 = Proto.ExportCSVColumn[] + cond1415 = match_lookahead_literal(parser, "(", 0) + while cond1415 + _t2223 = parse_export_csv_column(parser) + item1416 = _t2223 + push!(xs1414, item1416) + cond1415 = match_lookahead_literal(parser, "(", 0) + end + export_csv_columns1417 = xs1414 consume_literal!(parser, ")") - return export_csv_columns1409 + return export_csv_columns1417 end function parse_export_iceberg_config(parser::ParserState)::Proto.ExportIcebergConfig - span_start1415 = span_start(parser) + span_start1423 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "export_iceberg_config") - _t2210 = parse_iceberg_locator(parser) - iceberg_locator1410 = _t2210 - _t2211 = parse_iceberg_catalog_config(parser) - iceberg_catalog_config1411 = _t2211 - _t2212 = parse_export_iceberg_table_def(parser) - export_iceberg_table_def1412 = _t2212 - _t2213 = parse_iceberg_table_properties(parser) - iceberg_table_properties1413 = _t2213 + _t2224 = parse_iceberg_locator(parser) + iceberg_locator1418 = _t2224 + _t2225 = parse_iceberg_catalog_config(parser) + iceberg_catalog_config1419 = _t2225 + _t2226 = parse_export_iceberg_table_def(parser) + export_iceberg_table_def1420 = _t2226 + _t2227 = parse_iceberg_table_properties(parser) + iceberg_table_properties1421 = _t2227 if match_lookahead_literal(parser, "{", 0) - _t2215 = parse_config_dict(parser) - _t2214 = _t2215 + _t2229 = parse_config_dict(parser) + _t2228 = _t2229 else - _t2214 = nothing + _t2228 = nothing end - config_dict1414 = _t2214 + config_dict1422 = _t2228 consume_literal!(parser, ")") - _t2216 = construct_export_iceberg_config_full(parser, iceberg_locator1410, iceberg_catalog_config1411, export_iceberg_table_def1412, iceberg_table_properties1413, config_dict1414) - result1416 = _t2216 - record_span!(parser, span_start1415, "ExportIcebergConfig") - return result1416 + _t2230 = construct_export_iceberg_config_full(parser, iceberg_locator1418, iceberg_catalog_config1419, export_iceberg_table_def1420, iceberg_table_properties1421, config_dict1422) + result1424 = _t2230 + record_span!(parser, span_start1423, "ExportIcebergConfig") + return result1424 end function parse_export_iceberg_table_def(parser::ParserState)::Proto.RelationId - span_start1418 = span_start(parser) + span_start1426 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "table_def") - _t2217 = parse_relation_id(parser) - relation_id1417 = _t2217 + _t2231 = parse_relation_id(parser) + relation_id1425 = _t2231 consume_literal!(parser, ")") - result1419 = relation_id1417 - record_span!(parser, span_start1418, "RelationId") - return result1419 + result1427 = relation_id1425 + record_span!(parser, span_start1426, "RelationId") + return result1427 end function parse_iceberg_table_properties(parser::ParserState)::Vector{Tuple{String, String}} consume_literal!(parser, "(") consume_literal!(parser, "table_properties") - xs1420 = Tuple{String, String}[] - cond1421 = match_lookahead_literal(parser, "(", 0) - while cond1421 - _t2218 = parse_iceberg_property_entry(parser) - item1422 = _t2218 - push!(xs1420, item1422) - cond1421 = match_lookahead_literal(parser, "(", 0) - end - iceberg_property_entrys1423 = xs1420 + xs1428 = Tuple{String, String}[] + cond1429 = match_lookahead_literal(parser, "(", 0) + while cond1429 + _t2232 = parse_iceberg_property_entry(parser) + item1430 = _t2232 + push!(xs1428, item1430) + cond1429 = match_lookahead_literal(parser, "(", 0) + end + iceberg_property_entrys1431 = xs1428 consume_literal!(parser, ")") - return iceberg_property_entrys1423 + return iceberg_property_entrys1431 end diff --git a/sdks/julia/LogicalQueryProtocol.jl/src/pretty.jl b/sdks/julia/LogicalQueryProtocol.jl/src/pretty.jl index 20418ac1..77cc6433 100644 --- a/sdks/julia/LogicalQueryProtocol.jl/src/pretty.jl +++ b/sdks/julia/LogicalQueryProtocol.jl/src/pretty.jl @@ -384,7 +384,7 @@ function deconstruct_load_errors_optional(pp::PrettyPrinter, msg::Proto.TargetRe if _has_proto_field(msg, Symbol("load_errors")) return msg.load_errors else - _t1907 = nothing + _t1918 = nothing end return nothing end @@ -393,7 +393,7 @@ function deconstruct_csv_data_columns_optional(pp::PrettyPrinter, msg::Proto.CSV if _has_proto_field(msg, Symbol("relations")) return nothing else - _t1908 = nothing + _t1919 = nothing end return msg.columns end @@ -402,7 +402,7 @@ function deconstruct_csv_data_relations_optional(pp::PrettyPrinter, msg::Proto.C if _has_proto_field(msg, Symbol("relations")) return msg.relations else - _t1909 = nothing + _t1920 = nothing end return nothing end @@ -412,53 +412,53 @@ function deconstruct_export_csv_output_location(pp::PrettyPrinter, msg::Proto.Ex end function _make_value_int32(pp::PrettyPrinter, v::Int32)::Proto.Value - _t1910 = Proto.Value(value=OneOf(:int32_value, v)) - return _t1910 + _t1921 = Proto.Value(value=OneOf(:int32_value, v)) + return _t1921 end function _make_value_int64(pp::PrettyPrinter, v::Int64)::Proto.Value - _t1911 = Proto.Value(value=OneOf(:int_value, v)) - return _t1911 + _t1922 = Proto.Value(value=OneOf(:int_value, v)) + return _t1922 end function _make_value_float64(pp::PrettyPrinter, v::Float64)::Proto.Value - _t1912 = Proto.Value(value=OneOf(:float_value, v)) - return _t1912 + _t1923 = Proto.Value(value=OneOf(:float_value, v)) + return _t1923 end function _make_value_string(pp::PrettyPrinter, v::String)::Proto.Value - _t1913 = Proto.Value(value=OneOf(:string_value, v)) - return _t1913 + _t1924 = Proto.Value(value=OneOf(:string_value, v)) + return _t1924 end function _make_value_boolean(pp::PrettyPrinter, v::Bool)::Proto.Value - _t1914 = Proto.Value(value=OneOf(:boolean_value, v)) - return _t1914 + _t1925 = Proto.Value(value=OneOf(:boolean_value, v)) + return _t1925 end function _make_value_uint128(pp::PrettyPrinter, v::Proto.UInt128Value)::Proto.Value - _t1915 = Proto.Value(value=OneOf(:uint128_value, v)) - return _t1915 + _t1926 = Proto.Value(value=OneOf(:uint128_value, v)) + return _t1926 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 - _t1916 = _make_value_string(pp, "auto") - push!(result, ("ivm.maintenance_level", _t1916,)) + _t1927 = _make_value_string(pp, "auto") + push!(result, ("ivm.maintenance_level", _t1927,)) else if msg.ivm_config.level == Proto.MaintenanceLevel.MAINTENANCE_LEVEL_ALL - _t1917 = _make_value_string(pp, "all") - push!(result, ("ivm.maintenance_level", _t1917,)) + _t1928 = _make_value_string(pp, "all") + push!(result, ("ivm.maintenance_level", _t1928,)) else if msg.ivm_config.level == Proto.MaintenanceLevel.MAINTENANCE_LEVEL_OFF - _t1918 = _make_value_string(pp, "off") - push!(result, ("ivm.maintenance_level", _t1918,)) + _t1929 = _make_value_string(pp, "off") + push!(result, ("ivm.maintenance_level", _t1929,)) end end end - _t1919 = _make_value_int64(pp, msg.semantics_version) - push!(result, ("semantics_version", _t1919,)) + _t1930 = _make_value_int64(pp, msg.semantics_version) + push!(result, ("semantics_version", _t1930,)) for pair in sort([(k, v) for (k, v) in msg.configuration_values]) push!(result, pair) end @@ -467,37 +467,37 @@ end function deconstruct_csv_config(pp::PrettyPrinter, msg::Proto.CSVConfig)::Vector{Tuple{String, Proto.Value}} result = Tuple{String, Proto.Value}[] - _t1920 = _make_value_int32(pp, msg.header_row) - push!(result, ("csv_header_row", _t1920,)) - _t1921 = _make_value_int64(pp, msg.skip) - push!(result, ("csv_skip", _t1921,)) + _t1931 = _make_value_int32(pp, msg.header_row) + push!(result, ("csv_header_row", _t1931,)) + _t1932 = _make_value_int64(pp, msg.skip) + push!(result, ("csv_skip", _t1932,)) if msg.new_line != "" - _t1922 = _make_value_string(pp, msg.new_line) - push!(result, ("csv_new_line", _t1922,)) - end - _t1923 = _make_value_string(pp, msg.delimiter) - push!(result, ("csv_delimiter", _t1923,)) - _t1924 = _make_value_string(pp, msg.quotechar) - push!(result, ("csv_quotechar", _t1924,)) - _t1925 = _make_value_string(pp, msg.escapechar) - push!(result, ("csv_escapechar", _t1925,)) + _t1933 = _make_value_string(pp, msg.new_line) + push!(result, ("csv_new_line", _t1933,)) + end + _t1934 = _make_value_string(pp, msg.delimiter) + push!(result, ("csv_delimiter", _t1934,)) + _t1935 = _make_value_string(pp, msg.quotechar) + push!(result, ("csv_quotechar", _t1935,)) + _t1936 = _make_value_string(pp, msg.escapechar) + push!(result, ("csv_escapechar", _t1936,)) if msg.comment != "" - _t1926 = _make_value_string(pp, msg.comment) - push!(result, ("csv_comment", _t1926,)) + _t1937 = _make_value_string(pp, msg.comment) + push!(result, ("csv_comment", _t1937,)) end for missing_string in msg.missing_strings - _t1927 = _make_value_string(pp, missing_string) - push!(result, ("csv_missing_strings", _t1927,)) - end - _t1928 = _make_value_string(pp, msg.decimal_separator) - push!(result, ("csv_decimal_separator", _t1928,)) - _t1929 = _make_value_string(pp, msg.encoding) - push!(result, ("csv_encoding", _t1929,)) - _t1930 = _make_value_string(pp, msg.compression) - push!(result, ("csv_compression", _t1930,)) + _t1938 = _make_value_string(pp, missing_string) + push!(result, ("csv_missing_strings", _t1938,)) + end + _t1939 = _make_value_string(pp, msg.decimal_separator) + push!(result, ("csv_decimal_separator", _t1939,)) + _t1940 = _make_value_string(pp, msg.encoding) + push!(result, ("csv_encoding", _t1940,)) + _t1941 = _make_value_string(pp, msg.compression) + push!(result, ("csv_compression", _t1941,)) if msg.partition_size_mb != 0 - _t1931 = _make_value_int64(pp, msg.partition_size_mb) - push!(result, ("csv_partition_size_mb", _t1931,)) + _t1942 = _make_value_int64(pp, msg.partition_size_mb) + push!(result, ("csv_partition_size_mb", _t1942,)) end return sort(result) end @@ -506,91 +506,91 @@ function deconstruct_csv_storage_integration_optional(pp::PrettyPrinter, msg::Pr if !_has_proto_field(msg, Symbol("storage_integration")) return nothing else - _t1932 = nothing + _t1943 = nothing end si = msg.storage_integration result = Tuple{String, Proto.Value}[] if si.provider != "" - _t1933 = _make_value_string(pp, si.provider) - push!(result, ("provider", _t1933,)) + _t1944 = _make_value_string(pp, si.provider) + push!(result, ("provider", _t1944,)) end if si.azure_sas_token != "" - _t1934 = _make_value_string(pp, "***") - push!(result, ("azure_sas_token", _t1934,)) + _t1945 = _make_value_string(pp, "***") + push!(result, ("azure_sas_token", _t1945,)) end if si.s3_region != "" - _t1935 = _make_value_string(pp, si.s3_region) - push!(result, ("s3_region", _t1935,)) + _t1946 = _make_value_string(pp, si.s3_region) + push!(result, ("s3_region", _t1946,)) end if si.s3_access_key_id != "" - _t1936 = _make_value_string(pp, "***") - push!(result, ("s3_access_key_id", _t1936,)) + _t1947 = _make_value_string(pp, "***") + push!(result, ("s3_access_key_id", _t1947,)) end if si.s3_secret_access_key != "" - _t1937 = _make_value_string(pp, "***") - push!(result, ("s3_secret_access_key", _t1937,)) + _t1948 = _make_value_string(pp, "***") + push!(result, ("s3_secret_access_key", _t1948,)) 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}[] - _t1938 = _make_value_float64(pp, msg.storage_config.epsilon) - push!(result, ("betree_config_epsilon", _t1938,)) - _t1939 = _make_value_int64(pp, msg.storage_config.max_pivots) - push!(result, ("betree_config_max_pivots", _t1939,)) - _t1940 = _make_value_int64(pp, msg.storage_config.max_deltas) - push!(result, ("betree_config_max_deltas", _t1940,)) - _t1941 = _make_value_int64(pp, msg.storage_config.max_leaf) - push!(result, ("betree_config_max_leaf", _t1941,)) + _t1949 = _make_value_float64(pp, msg.storage_config.epsilon) + push!(result, ("betree_config_epsilon", _t1949,)) + _t1950 = _make_value_int64(pp, msg.storage_config.max_pivots) + push!(result, ("betree_config_max_pivots", _t1950,)) + _t1951 = _make_value_int64(pp, msg.storage_config.max_deltas) + push!(result, ("betree_config_max_deltas", _t1951,)) + _t1952 = _make_value_int64(pp, msg.storage_config.max_leaf) + push!(result, ("betree_config_max_leaf", _t1952,)) if _has_proto_field(msg.relation_locator, Symbol("root_pageid")) if !isnothing(_get_oneof_field(msg.relation_locator, :root_pageid)) - _t1942 = _make_value_uint128(pp, _get_oneof_field(msg.relation_locator, :root_pageid)) - push!(result, ("betree_locator_root_pageid", _t1942,)) + _t1953 = _make_value_uint128(pp, _get_oneof_field(msg.relation_locator, :root_pageid)) + push!(result, ("betree_locator_root_pageid", _t1953,)) end end if _has_proto_field(msg.relation_locator, Symbol("inline_data")) if !isnothing(_get_oneof_field(msg.relation_locator, :inline_data)) - _t1943 = _make_value_string(pp, String(copy(_get_oneof_field(msg.relation_locator, :inline_data)))) - push!(result, ("betree_locator_inline_data", _t1943,)) + _t1954 = _make_value_string(pp, String(copy(_get_oneof_field(msg.relation_locator, :inline_data)))) + push!(result, ("betree_locator_inline_data", _t1954,)) end end - _t1944 = _make_value_int64(pp, msg.relation_locator.element_count) - push!(result, ("betree_locator_element_count", _t1944,)) - _t1945 = _make_value_int64(pp, msg.relation_locator.tree_height) - push!(result, ("betree_locator_tree_height", _t1945,)) + _t1955 = _make_value_int64(pp, msg.relation_locator.element_count) + push!(result, ("betree_locator_element_count", _t1955,)) + _t1956 = _make_value_int64(pp, msg.relation_locator.tree_height) + push!(result, ("betree_locator_tree_height", _t1956,)) 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) - _t1946 = _make_value_int64(pp, msg.partition_size) - push!(result, ("partition_size", _t1946,)) + _t1957 = _make_value_int64(pp, msg.partition_size) + push!(result, ("partition_size", _t1957,)) end if !isnothing(msg.compression) - _t1947 = _make_value_string(pp, msg.compression) - push!(result, ("compression", _t1947,)) + _t1958 = _make_value_string(pp, msg.compression) + push!(result, ("compression", _t1958,)) end if !isnothing(msg.syntax_header_row) - _t1948 = _make_value_boolean(pp, msg.syntax_header_row) - push!(result, ("syntax_header_row", _t1948,)) + _t1959 = _make_value_boolean(pp, msg.syntax_header_row) + push!(result, ("syntax_header_row", _t1959,)) end if !isnothing(msg.syntax_missing_string) - _t1949 = _make_value_string(pp, msg.syntax_missing_string) - push!(result, ("syntax_missing_string", _t1949,)) + _t1960 = _make_value_string(pp, msg.syntax_missing_string) + push!(result, ("syntax_missing_string", _t1960,)) end if !isnothing(msg.syntax_delim) - _t1950 = _make_value_string(pp, msg.syntax_delim) - push!(result, ("syntax_delim", _t1950,)) + _t1961 = _make_value_string(pp, msg.syntax_delim) + push!(result, ("syntax_delim", _t1961,)) end if !isnothing(msg.syntax_quotechar) - _t1951 = _make_value_string(pp, msg.syntax_quotechar) - push!(result, ("syntax_quotechar", _t1951,)) + _t1962 = _make_value_string(pp, msg.syntax_quotechar) + push!(result, ("syntax_quotechar", _t1962,)) end if !isnothing(msg.syntax_escapechar) - _t1952 = _make_value_string(pp, msg.syntax_escapechar) - push!(result, ("syntax_escapechar", _t1952,)) + _t1963 = _make_value_string(pp, msg.syntax_escapechar) + push!(result, ("syntax_escapechar", _t1963,)) end return sort(result) end @@ -603,7 +603,7 @@ function deconstruct_iceberg_catalog_config_scope_optional(pp::PrettyPrinter, ms if msg.scope != "" return msg.scope else - _t1953 = nothing + _t1964 = nothing end return nothing end @@ -612,7 +612,7 @@ function deconstruct_iceberg_data_from_snapshot_optional(pp::PrettyPrinter, msg: if msg.from_snapshot != "" return msg.from_snapshot else - _t1954 = nothing + _t1965 = nothing end return nothing end @@ -621,7 +621,7 @@ function deconstruct_iceberg_data_to_snapshot_optional(pp::PrettyPrinter, msg::P if msg.to_snapshot != "" return msg.to_snapshot else - _t1955 = nothing + _t1966 = nothing end return nothing end @@ -629,21 +629,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 != "" - _t1956 = _make_value_string(pp, msg.prefix) - push!(result, ("prefix", _t1956,)) + _t1967 = _make_value_string(pp, msg.prefix) + push!(result, ("prefix", _t1967,)) end if msg.target_file_size_bytes != 0 - _t1957 = _make_value_int64(pp, msg.target_file_size_bytes) - push!(result, ("target_file_size_bytes", _t1957,)) + _t1968 = _make_value_int64(pp, msg.target_file_size_bytes) + push!(result, ("target_file_size_bytes", _t1968,)) end if msg.compression != "" - _t1958 = _make_value_string(pp, msg.compression) - push!(result, ("compression", _t1958,)) + _t1969 = _make_value_string(pp, msg.compression) + push!(result, ("compression", _t1969,)) end if length(result) == 0 return nothing else - _t1959 = nothing + _t1970 = nothing end return sort(result) end @@ -658,7 +658,7 @@ function deconstruct_relation_id_uint128(pp::PrettyPrinter, msg::Proto.RelationI if isnothing(name) return relation_id_to_uint128(pp, msg) else - _t1960 = nothing + _t1971 = nothing end return nothing end @@ -677,47 +677,47 @@ end # --- Pretty-print functions --- function pretty_transaction(pp::PrettyPrinter, msg::Proto.Transaction) - flat863 = try_flat(pp, msg, pretty_transaction) - if !isnothing(flat863) - write(pp, flat863) + flat868 = try_flat(pp, msg, pretty_transaction) + if !isnothing(flat868) + write(pp, flat868) return nothing else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("configure")) - _t1708 = _dollar_dollar.configure + _t1718 = _dollar_dollar.configure else - _t1708 = nothing + _t1718 = nothing end if _has_proto_field(_dollar_dollar, Symbol("sync")) - _t1709 = _dollar_dollar.sync + _t1719 = _dollar_dollar.sync else - _t1709 = nothing + _t1719 = nothing end - fields854 = (_t1708, _t1709, _dollar_dollar.epochs,) - unwrapped_fields855 = fields854 + fields859 = (_t1718, _t1719, _dollar_dollar.epochs,) + unwrapped_fields860 = fields859 write(pp, "(transaction") indent_sexp!(pp) - field856 = unwrapped_fields855[1] - if !isnothing(field856) + field861 = unwrapped_fields860[1] + if !isnothing(field861) newline(pp) - opt_val857 = field856 - pretty_configure(pp, opt_val857) + opt_val862 = field861 + pretty_configure(pp, opt_val862) end - field858 = unwrapped_fields855[2] - if !isnothing(field858) + field863 = unwrapped_fields860[2] + if !isnothing(field863) newline(pp) - opt_val859 = field858 - pretty_sync(pp, opt_val859) + opt_val864 = field863 + pretty_sync(pp, opt_val864) end - field860 = unwrapped_fields855[3] - if !isempty(field860) + field865 = unwrapped_fields860[3] + if !isempty(field865) newline(pp) - for (i1710, elem861) in enumerate(field860) - i862 = i1710 - 1 - if (i862 > 0) + for (i1720, elem866) in enumerate(field865) + i867 = i1720 - 1 + if (i867 > 0) newline(pp) end - pretty_epoch(pp, elem861) + pretty_epoch(pp, elem866) end end dedent!(pp) @@ -727,19 +727,19 @@ function pretty_transaction(pp::PrettyPrinter, msg::Proto.Transaction) end function pretty_configure(pp::PrettyPrinter, msg::Proto.Configure) - flat866 = try_flat(pp, msg, pretty_configure) - if !isnothing(flat866) - write(pp, flat866) + flat871 = try_flat(pp, msg, pretty_configure) + if !isnothing(flat871) + write(pp, flat871) return nothing else _dollar_dollar = msg - _t1711 = deconstruct_configure(pp, _dollar_dollar) - fields864 = _t1711 - unwrapped_fields865 = fields864 + _t1721 = deconstruct_configure(pp, _dollar_dollar) + fields869 = _t1721 + unwrapped_fields870 = fields869 write(pp, "(configure") indent_sexp!(pp) newline(pp) - pretty_config_dict(pp, unwrapped_fields865) + pretty_config_dict(pp, unwrapped_fields870) dedent!(pp) write(pp, ")") end @@ -747,22 +747,22 @@ function pretty_configure(pp::PrettyPrinter, msg::Proto.Configure) end function pretty_config_dict(pp::PrettyPrinter, msg::Vector{Tuple{String, Proto.Value}}) - flat870 = try_flat(pp, msg, pretty_config_dict) - if !isnothing(flat870) - write(pp, flat870) + flat875 = try_flat(pp, msg, pretty_config_dict) + if !isnothing(flat875) + write(pp, flat875) return nothing else - fields867 = msg + fields872 = msg write(pp, "{") indent!(pp) - if !isempty(fields867) + if !isempty(fields872) newline(pp) - for (i1712, elem868) in enumerate(fields867) - i869 = i1712 - 1 - if (i869 > 0) + for (i1722, elem873) in enumerate(fields872) + i874 = i1722 - 1 + if (i874 > 0) newline(pp) end - pretty_config_key_value(pp, elem868) + pretty_config_key_value(pp, elem873) end end dedent!(pp) @@ -772,163 +772,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}) - flat875 = try_flat(pp, msg, pretty_config_key_value) - if !isnothing(flat875) - write(pp, flat875) + flat880 = try_flat(pp, msg, pretty_config_key_value) + if !isnothing(flat880) + write(pp, flat880) return nothing else _dollar_dollar = msg - fields871 = (_dollar_dollar[1], _dollar_dollar[2],) - unwrapped_fields872 = fields871 + fields876 = (_dollar_dollar[1], _dollar_dollar[2],) + unwrapped_fields877 = fields876 write(pp, ":") - field873 = unwrapped_fields872[1] - write(pp, field873) + field878 = unwrapped_fields877[1] + write(pp, field878) write(pp, " ") - field874 = unwrapped_fields872[2] - pretty_raw_value(pp, field874) + field879 = unwrapped_fields877[2] + pretty_raw_value(pp, field879) end return nothing end function pretty_raw_value(pp::PrettyPrinter, msg::Proto.Value) - flat901 = try_flat(pp, msg, pretty_raw_value) - if !isnothing(flat901) - write(pp, flat901) + flat906 = try_flat(pp, msg, pretty_raw_value) + if !isnothing(flat906) + write(pp, flat906) return nothing else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("date_value")) - _t1713 = _get_oneof_field(_dollar_dollar, :date_value) + _t1723 = _get_oneof_field(_dollar_dollar, :date_value) else - _t1713 = nothing + _t1723 = nothing end - deconstruct_result899 = _t1713 - if !isnothing(deconstruct_result899) - unwrapped900 = deconstruct_result899 - pretty_raw_date(pp, unwrapped900) + deconstruct_result904 = _t1723 + if !isnothing(deconstruct_result904) + unwrapped905 = deconstruct_result904 + pretty_raw_date(pp, unwrapped905) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("datetime_value")) - _t1714 = _get_oneof_field(_dollar_dollar, :datetime_value) + _t1724 = _get_oneof_field(_dollar_dollar, :datetime_value) else - _t1714 = nothing + _t1724 = nothing end - deconstruct_result897 = _t1714 - if !isnothing(deconstruct_result897) - unwrapped898 = deconstruct_result897 - pretty_raw_datetime(pp, unwrapped898) + deconstruct_result902 = _t1724 + if !isnothing(deconstruct_result902) + unwrapped903 = deconstruct_result902 + pretty_raw_datetime(pp, unwrapped903) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("string_value")) - _t1715 = _get_oneof_field(_dollar_dollar, :string_value) + _t1725 = _get_oneof_field(_dollar_dollar, :string_value) else - _t1715 = nothing + _t1725 = nothing end - deconstruct_result895 = _t1715 - if !isnothing(deconstruct_result895) - unwrapped896 = deconstruct_result895 - write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, unwrapped896)) + deconstruct_result900 = _t1725 + if !isnothing(deconstruct_result900) + unwrapped901 = deconstruct_result900 + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, unwrapped901)) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("int32_value")) - _t1716 = _get_oneof_field(_dollar_dollar, :int32_value) + _t1726 = _get_oneof_field(_dollar_dollar, :int32_value) else - _t1716 = nothing + _t1726 = nothing end - deconstruct_result893 = _t1716 - if !isnothing(deconstruct_result893) - unwrapped894 = deconstruct_result893 - write(pp, (string(Int64(unwrapped894)) * "i32")) + deconstruct_result898 = _t1726 + if !isnothing(deconstruct_result898) + unwrapped899 = deconstruct_result898 + write(pp, (string(Int64(unwrapped899)) * "i32")) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("int_value")) - _t1717 = _get_oneof_field(_dollar_dollar, :int_value) + _t1727 = _get_oneof_field(_dollar_dollar, :int_value) else - _t1717 = nothing + _t1727 = nothing end - deconstruct_result891 = _t1717 - if !isnothing(deconstruct_result891) - unwrapped892 = deconstruct_result891 - write(pp, string(unwrapped892)) + deconstruct_result896 = _t1727 + if !isnothing(deconstruct_result896) + unwrapped897 = deconstruct_result896 + write(pp, string(unwrapped897)) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("float32_value")) - _t1718 = _get_oneof_field(_dollar_dollar, :float32_value) + _t1728 = _get_oneof_field(_dollar_dollar, :float32_value) else - _t1718 = nothing + _t1728 = nothing end - deconstruct_result889 = _t1718 - if !isnothing(deconstruct_result889) - unwrapped890 = deconstruct_result889 - write(pp, format_float32_literal(unwrapped890)) + deconstruct_result894 = _t1728 + if !isnothing(deconstruct_result894) + unwrapped895 = deconstruct_result894 + write(pp, format_float32_literal(unwrapped895)) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("float_value")) - _t1719 = _get_oneof_field(_dollar_dollar, :float_value) + _t1729 = _get_oneof_field(_dollar_dollar, :float_value) else - _t1719 = nothing + _t1729 = nothing end - deconstruct_result887 = _t1719 - if !isnothing(deconstruct_result887) - unwrapped888 = deconstruct_result887 - write(pp, lowercase(string(unwrapped888))) + deconstruct_result892 = _t1729 + if !isnothing(deconstruct_result892) + unwrapped893 = deconstruct_result892 + write(pp, lowercase(string(unwrapped893))) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("uint32_value")) - _t1720 = _get_oneof_field(_dollar_dollar, :uint32_value) + _t1730 = _get_oneof_field(_dollar_dollar, :uint32_value) else - _t1720 = nothing + _t1730 = nothing end - deconstruct_result885 = _t1720 - if !isnothing(deconstruct_result885) - unwrapped886 = deconstruct_result885 - write(pp, (string(Int64(unwrapped886)) * "u32")) + deconstruct_result890 = _t1730 + if !isnothing(deconstruct_result890) + unwrapped891 = deconstruct_result890 + write(pp, (string(Int64(unwrapped891)) * "u32")) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("uint128_value")) - _t1721 = _get_oneof_field(_dollar_dollar, :uint128_value) + _t1731 = _get_oneof_field(_dollar_dollar, :uint128_value) else - _t1721 = nothing + _t1731 = nothing end - deconstruct_result883 = _t1721 - if !isnothing(deconstruct_result883) - unwrapped884 = deconstruct_result883 - write(pp, format_uint128(DEFAULT_CONSTANT_FORMATTER, pp, unwrapped884)) + deconstruct_result888 = _t1731 + if !isnothing(deconstruct_result888) + unwrapped889 = deconstruct_result888 + write(pp, format_uint128(DEFAULT_CONSTANT_FORMATTER, pp, unwrapped889)) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("int128_value")) - _t1722 = _get_oneof_field(_dollar_dollar, :int128_value) + _t1732 = _get_oneof_field(_dollar_dollar, :int128_value) else - _t1722 = nothing + _t1732 = nothing end - deconstruct_result881 = _t1722 - if !isnothing(deconstruct_result881) - unwrapped882 = deconstruct_result881 - write(pp, format_int128(DEFAULT_CONSTANT_FORMATTER, pp, unwrapped882)) + deconstruct_result886 = _t1732 + if !isnothing(deconstruct_result886) + unwrapped887 = deconstruct_result886 + write(pp, format_int128(DEFAULT_CONSTANT_FORMATTER, pp, unwrapped887)) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("decimal_value")) - _t1723 = _get_oneof_field(_dollar_dollar, :decimal_value) + _t1733 = _get_oneof_field(_dollar_dollar, :decimal_value) else - _t1723 = nothing + _t1733 = nothing end - deconstruct_result879 = _t1723 - if !isnothing(deconstruct_result879) - unwrapped880 = deconstruct_result879 - write(pp, format_decimal(DEFAULT_CONSTANT_FORMATTER, pp, unwrapped880)) + deconstruct_result884 = _t1733 + if !isnothing(deconstruct_result884) + unwrapped885 = deconstruct_result884 + write(pp, format_decimal(DEFAULT_CONSTANT_FORMATTER, pp, unwrapped885)) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("boolean_value")) - _t1724 = _get_oneof_field(_dollar_dollar, :boolean_value) + _t1734 = _get_oneof_field(_dollar_dollar, :boolean_value) else - _t1724 = nothing + _t1734 = nothing end - deconstruct_result877 = _t1724 - if !isnothing(deconstruct_result877) - unwrapped878 = deconstruct_result877 - pretty_boolean_value(pp, unwrapped878) + deconstruct_result882 = _t1734 + if !isnothing(deconstruct_result882) + unwrapped883 = deconstruct_result882 + pretty_boolean_value(pp, unwrapped883) else - fields876 = msg + fields881 = msg write(pp, "missing") end end @@ -947,25 +947,25 @@ function pretty_raw_value(pp::PrettyPrinter, msg::Proto.Value) end function pretty_raw_date(pp::PrettyPrinter, msg::Proto.DateValue) - flat907 = try_flat(pp, msg, pretty_raw_date) - if !isnothing(flat907) - write(pp, flat907) + flat912 = try_flat(pp, msg, pretty_raw_date) + if !isnothing(flat912) + write(pp, flat912) return nothing else _dollar_dollar = msg - fields902 = (Int64(_dollar_dollar.year), Int64(_dollar_dollar.month), Int64(_dollar_dollar.day),) - unwrapped_fields903 = fields902 + fields907 = (Int64(_dollar_dollar.year), Int64(_dollar_dollar.month), Int64(_dollar_dollar.day),) + unwrapped_fields908 = fields907 write(pp, "(date") indent_sexp!(pp) newline(pp) - field904 = unwrapped_fields903[1] - write(pp, string(field904)) + field909 = unwrapped_fields908[1] + write(pp, string(field909)) newline(pp) - field905 = unwrapped_fields903[2] - write(pp, string(field905)) + field910 = unwrapped_fields908[2] + write(pp, string(field910)) newline(pp) - field906 = unwrapped_fields903[3] - write(pp, string(field906)) + field911 = unwrapped_fields908[3] + write(pp, string(field911)) dedent!(pp) write(pp, ")") end @@ -973,39 +973,39 @@ function pretty_raw_date(pp::PrettyPrinter, msg::Proto.DateValue) end function pretty_raw_datetime(pp::PrettyPrinter, msg::Proto.DateTimeValue) - flat918 = try_flat(pp, msg, pretty_raw_datetime) - if !isnothing(flat918) - write(pp, flat918) + flat923 = try_flat(pp, msg, pretty_raw_datetime) + if !isnothing(flat923) + write(pp, flat923) return nothing else _dollar_dollar = msg - fields908 = (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_fields909 = fields908 + fields913 = (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_fields914 = fields913 write(pp, "(datetime") indent_sexp!(pp) newline(pp) - field910 = unwrapped_fields909[1] - write(pp, string(field910)) + field915 = unwrapped_fields914[1] + write(pp, string(field915)) newline(pp) - field911 = unwrapped_fields909[2] - write(pp, string(field911)) + field916 = unwrapped_fields914[2] + write(pp, string(field916)) newline(pp) - field912 = unwrapped_fields909[3] - write(pp, string(field912)) + field917 = unwrapped_fields914[3] + write(pp, string(field917)) newline(pp) - field913 = unwrapped_fields909[4] - write(pp, string(field913)) + field918 = unwrapped_fields914[4] + write(pp, string(field918)) newline(pp) - field914 = unwrapped_fields909[5] - write(pp, string(field914)) + field919 = unwrapped_fields914[5] + write(pp, string(field919)) newline(pp) - field915 = unwrapped_fields909[6] - write(pp, string(field915)) - field916 = unwrapped_fields909[7] - if !isnothing(field916) + field920 = unwrapped_fields914[6] + write(pp, string(field920)) + field921 = unwrapped_fields914[7] + if !isnothing(field921) newline(pp) - opt_val917 = field916 - write(pp, string(opt_val917)) + opt_val922 = field921 + write(pp, string(opt_val922)) end dedent!(pp) write(pp, ")") @@ -1016,24 +1016,24 @@ end function pretty_boolean_value(pp::PrettyPrinter, msg::Bool) _dollar_dollar = msg if _dollar_dollar - _t1725 = () + _t1735 = () else - _t1725 = nothing + _t1735 = nothing end - deconstruct_result921 = _t1725 - if !isnothing(deconstruct_result921) - unwrapped922 = deconstruct_result921 + deconstruct_result926 = _t1735 + if !isnothing(deconstruct_result926) + unwrapped927 = deconstruct_result926 write(pp, "true") else _dollar_dollar = msg if !_dollar_dollar - _t1726 = () + _t1736 = () else - _t1726 = nothing + _t1736 = nothing end - deconstruct_result919 = _t1726 - if !isnothing(deconstruct_result919) - unwrapped920 = deconstruct_result919 + deconstruct_result924 = _t1736 + if !isnothing(deconstruct_result924) + unwrapped925 = deconstruct_result924 write(pp, "false") else throw(ParseError("No matching rule for boolean_value")) @@ -1043,24 +1043,24 @@ function pretty_boolean_value(pp::PrettyPrinter, msg::Bool) end function pretty_sync(pp::PrettyPrinter, msg::Proto.Sync) - flat927 = try_flat(pp, msg, pretty_sync) - if !isnothing(flat927) - write(pp, flat927) + flat932 = try_flat(pp, msg, pretty_sync) + if !isnothing(flat932) + write(pp, flat932) return nothing else _dollar_dollar = msg - fields923 = _dollar_dollar.fragments - unwrapped_fields924 = fields923 + fields928 = _dollar_dollar.fragments + unwrapped_fields929 = fields928 write(pp, "(sync") indent_sexp!(pp) - if !isempty(unwrapped_fields924) + if !isempty(unwrapped_fields929) newline(pp) - for (i1727, elem925) in enumerate(unwrapped_fields924) - i926 = i1727 - 1 - if (i926 > 0) + for (i1737, elem930) in enumerate(unwrapped_fields929) + i931 = i1737 - 1 + if (i931 > 0) newline(pp) end - pretty_fragment_id(pp, elem925) + pretty_fragment_id(pp, elem930) end end dedent!(pp) @@ -1070,52 +1070,52 @@ function pretty_sync(pp::PrettyPrinter, msg::Proto.Sync) end function pretty_fragment_id(pp::PrettyPrinter, msg::Proto.FragmentId) - flat930 = try_flat(pp, msg, pretty_fragment_id) - if !isnothing(flat930) - write(pp, flat930) + flat935 = try_flat(pp, msg, pretty_fragment_id) + if !isnothing(flat935) + write(pp, flat935) return nothing else _dollar_dollar = msg - fields928 = fragment_id_to_string(pp, _dollar_dollar) - unwrapped_fields929 = fields928 + fields933 = fragment_id_to_string(pp, _dollar_dollar) + unwrapped_fields934 = fields933 write(pp, ":") - write(pp, unwrapped_fields929) + write(pp, unwrapped_fields934) end return nothing end function pretty_epoch(pp::PrettyPrinter, msg::Proto.Epoch) - flat937 = try_flat(pp, msg, pretty_epoch) - if !isnothing(flat937) - write(pp, flat937) + flat942 = try_flat(pp, msg, pretty_epoch) + if !isnothing(flat942) + write(pp, flat942) return nothing else _dollar_dollar = msg if !isempty(_dollar_dollar.writes) - _t1728 = _dollar_dollar.writes + _t1738 = _dollar_dollar.writes else - _t1728 = nothing + _t1738 = nothing end if !isempty(_dollar_dollar.reads) - _t1729 = _dollar_dollar.reads + _t1739 = _dollar_dollar.reads else - _t1729 = nothing + _t1739 = nothing end - fields931 = (_t1728, _t1729,) - unwrapped_fields932 = fields931 + fields936 = (_t1738, _t1739,) + unwrapped_fields937 = fields936 write(pp, "(epoch") indent_sexp!(pp) - field933 = unwrapped_fields932[1] - if !isnothing(field933) + field938 = unwrapped_fields937[1] + if !isnothing(field938) newline(pp) - opt_val934 = field933 - pretty_epoch_writes(pp, opt_val934) + opt_val939 = field938 + pretty_epoch_writes(pp, opt_val939) end - field935 = unwrapped_fields932[2] - if !isnothing(field935) + field940 = unwrapped_fields937[2] + if !isnothing(field940) newline(pp) - opt_val936 = field935 - pretty_epoch_reads(pp, opt_val936) + opt_val941 = field940 + pretty_epoch_reads(pp, opt_val941) end dedent!(pp) write(pp, ")") @@ -1124,22 +1124,22 @@ function pretty_epoch(pp::PrettyPrinter, msg::Proto.Epoch) end function pretty_epoch_writes(pp::PrettyPrinter, msg::Vector{Proto.Write}) - flat941 = try_flat(pp, msg, pretty_epoch_writes) - if !isnothing(flat941) - write(pp, flat941) + flat946 = try_flat(pp, msg, pretty_epoch_writes) + if !isnothing(flat946) + write(pp, flat946) return nothing else - fields938 = msg + fields943 = msg write(pp, "(writes") indent_sexp!(pp) - if !isempty(fields938) + if !isempty(fields943) newline(pp) - for (i1730, elem939) in enumerate(fields938) - i940 = i1730 - 1 - if (i940 > 0) + for (i1740, elem944) in enumerate(fields943) + i945 = i1740 - 1 + if (i945 > 0) newline(pp) end - pretty_write(pp, elem939) + pretty_write(pp, elem944) end end dedent!(pp) @@ -1149,54 +1149,54 @@ function pretty_epoch_writes(pp::PrettyPrinter, msg::Vector{Proto.Write}) end function pretty_write(pp::PrettyPrinter, msg::Proto.Write) - flat950 = try_flat(pp, msg, pretty_write) - if !isnothing(flat950) - write(pp, flat950) + flat955 = try_flat(pp, msg, pretty_write) + if !isnothing(flat955) + write(pp, flat955) return nothing else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("define")) - _t1731 = _get_oneof_field(_dollar_dollar, :define) + _t1741 = _get_oneof_field(_dollar_dollar, :define) else - _t1731 = nothing + _t1741 = nothing end - deconstruct_result948 = _t1731 - if !isnothing(deconstruct_result948) - unwrapped949 = deconstruct_result948 - pretty_define(pp, unwrapped949) + deconstruct_result953 = _t1741 + if !isnothing(deconstruct_result953) + unwrapped954 = deconstruct_result953 + pretty_define(pp, unwrapped954) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("undefine")) - _t1732 = _get_oneof_field(_dollar_dollar, :undefine) + _t1742 = _get_oneof_field(_dollar_dollar, :undefine) else - _t1732 = nothing + _t1742 = nothing end - deconstruct_result946 = _t1732 - if !isnothing(deconstruct_result946) - unwrapped947 = deconstruct_result946 - pretty_undefine(pp, unwrapped947) + deconstruct_result951 = _t1742 + if !isnothing(deconstruct_result951) + unwrapped952 = deconstruct_result951 + pretty_undefine(pp, unwrapped952) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("context")) - _t1733 = _get_oneof_field(_dollar_dollar, :context) + _t1743 = _get_oneof_field(_dollar_dollar, :context) else - _t1733 = nothing + _t1743 = nothing end - deconstruct_result944 = _t1733 - if !isnothing(deconstruct_result944) - unwrapped945 = deconstruct_result944 - pretty_context(pp, unwrapped945) + deconstruct_result949 = _t1743 + if !isnothing(deconstruct_result949) + unwrapped950 = deconstruct_result949 + pretty_context(pp, unwrapped950) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("snapshot")) - _t1734 = _get_oneof_field(_dollar_dollar, :snapshot) + _t1744 = _get_oneof_field(_dollar_dollar, :snapshot) else - _t1734 = nothing + _t1744 = nothing end - deconstruct_result942 = _t1734 - if !isnothing(deconstruct_result942) - unwrapped943 = deconstruct_result942 - pretty_snapshot(pp, unwrapped943) + deconstruct_result947 = _t1744 + if !isnothing(deconstruct_result947) + unwrapped948 = deconstruct_result947 + pretty_snapshot(pp, unwrapped948) else throw(ParseError("No matching rule for write")) end @@ -1208,18 +1208,18 @@ function pretty_write(pp::PrettyPrinter, msg::Proto.Write) end function pretty_define(pp::PrettyPrinter, msg::Proto.Define) - flat953 = try_flat(pp, msg, pretty_define) - if !isnothing(flat953) - write(pp, flat953) + flat958 = try_flat(pp, msg, pretty_define) + if !isnothing(flat958) + write(pp, flat958) return nothing else _dollar_dollar = msg - fields951 = _dollar_dollar.fragment - unwrapped_fields952 = fields951 + fields956 = _dollar_dollar.fragment + unwrapped_fields957 = fields956 write(pp, "(define") indent_sexp!(pp) newline(pp) - pretty_fragment(pp, unwrapped_fields952) + pretty_fragment(pp, unwrapped_fields957) dedent!(pp) write(pp, ")") end @@ -1227,29 +1227,29 @@ function pretty_define(pp::PrettyPrinter, msg::Proto.Define) end function pretty_fragment(pp::PrettyPrinter, msg::Proto.Fragment) - flat960 = try_flat(pp, msg, pretty_fragment) - if !isnothing(flat960) - write(pp, flat960) + flat965 = try_flat(pp, msg, pretty_fragment) + if !isnothing(flat965) + write(pp, flat965) return nothing else _dollar_dollar = msg start_pretty_fragment(pp, _dollar_dollar) - fields954 = (_dollar_dollar.id, _dollar_dollar.declarations,) - unwrapped_fields955 = fields954 + fields959 = (_dollar_dollar.id, _dollar_dollar.declarations,) + unwrapped_fields960 = fields959 write(pp, "(fragment") indent_sexp!(pp) newline(pp) - field956 = unwrapped_fields955[1] - pretty_new_fragment_id(pp, field956) - field957 = unwrapped_fields955[2] - if !isempty(field957) + field961 = unwrapped_fields960[1] + pretty_new_fragment_id(pp, field961) + field962 = unwrapped_fields960[2] + if !isempty(field962) newline(pp) - for (i1735, elem958) in enumerate(field957) - i959 = i1735 - 1 - if (i959 > 0) + for (i1745, elem963) in enumerate(field962) + i964 = i1745 - 1 + if (i964 > 0) newline(pp) end - pretty_declaration(pp, elem958) + pretty_declaration(pp, elem963) end end dedent!(pp) @@ -1259,66 +1259,66 @@ function pretty_fragment(pp::PrettyPrinter, msg::Proto.Fragment) end function pretty_new_fragment_id(pp::PrettyPrinter, msg::Proto.FragmentId) - flat962 = try_flat(pp, msg, pretty_new_fragment_id) - if !isnothing(flat962) - write(pp, flat962) + flat967 = try_flat(pp, msg, pretty_new_fragment_id) + if !isnothing(flat967) + write(pp, flat967) return nothing else - fields961 = msg - pretty_fragment_id(pp, fields961) + fields966 = msg + pretty_fragment_id(pp, fields966) end return nothing end function pretty_declaration(pp::PrettyPrinter, msg::Proto.Declaration) - flat971 = try_flat(pp, msg, pretty_declaration) - if !isnothing(flat971) - write(pp, flat971) + flat976 = try_flat(pp, msg, pretty_declaration) + if !isnothing(flat976) + write(pp, flat976) return nothing else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("def")) - _t1736 = _get_oneof_field(_dollar_dollar, :def) + _t1746 = _get_oneof_field(_dollar_dollar, :def) else - _t1736 = nothing + _t1746 = nothing end - deconstruct_result969 = _t1736 - if !isnothing(deconstruct_result969) - unwrapped970 = deconstruct_result969 - pretty_def(pp, unwrapped970) + deconstruct_result974 = _t1746 + if !isnothing(deconstruct_result974) + unwrapped975 = deconstruct_result974 + pretty_def(pp, unwrapped975) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("algorithm")) - _t1737 = _get_oneof_field(_dollar_dollar, :algorithm) + _t1747 = _get_oneof_field(_dollar_dollar, :algorithm) else - _t1737 = nothing + _t1747 = nothing end - deconstruct_result967 = _t1737 - if !isnothing(deconstruct_result967) - unwrapped968 = deconstruct_result967 - pretty_algorithm(pp, unwrapped968) + deconstruct_result972 = _t1747 + if !isnothing(deconstruct_result972) + unwrapped973 = deconstruct_result972 + pretty_algorithm(pp, unwrapped973) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("constraint")) - _t1738 = _get_oneof_field(_dollar_dollar, :constraint) + _t1748 = _get_oneof_field(_dollar_dollar, :constraint) else - _t1738 = nothing + _t1748 = nothing end - deconstruct_result965 = _t1738 - if !isnothing(deconstruct_result965) - unwrapped966 = deconstruct_result965 - pretty_constraint(pp, unwrapped966) + deconstruct_result970 = _t1748 + if !isnothing(deconstruct_result970) + unwrapped971 = deconstruct_result970 + pretty_constraint(pp, unwrapped971) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("data")) - _t1739 = _get_oneof_field(_dollar_dollar, :data) + _t1749 = _get_oneof_field(_dollar_dollar, :data) else - _t1739 = nothing + _t1749 = nothing end - deconstruct_result963 = _t1739 - if !isnothing(deconstruct_result963) - unwrapped964 = deconstruct_result963 - pretty_data(pp, unwrapped964) + deconstruct_result968 = _t1749 + if !isnothing(deconstruct_result968) + unwrapped969 = deconstruct_result968 + pretty_data(pp, unwrapped969) else throw(ParseError("No matching rule for declaration")) end @@ -1330,32 +1330,32 @@ function pretty_declaration(pp::PrettyPrinter, msg::Proto.Declaration) end function pretty_def(pp::PrettyPrinter, msg::Proto.Def) - flat978 = try_flat(pp, msg, pretty_def) - if !isnothing(flat978) - write(pp, flat978) + flat983 = try_flat(pp, msg, pretty_def) + if !isnothing(flat983) + write(pp, flat983) return nothing else _dollar_dollar = msg if !isempty(_dollar_dollar.attrs) - _t1740 = _dollar_dollar.attrs + _t1750 = _dollar_dollar.attrs else - _t1740 = nothing + _t1750 = nothing end - fields972 = (_dollar_dollar.name, _dollar_dollar.body, _t1740,) - unwrapped_fields973 = fields972 + fields977 = (_dollar_dollar.name, _dollar_dollar.body, _t1750,) + unwrapped_fields978 = fields977 write(pp, "(def") indent_sexp!(pp) newline(pp) - field974 = unwrapped_fields973[1] - pretty_relation_id(pp, field974) + field979 = unwrapped_fields978[1] + pretty_relation_id(pp, field979) newline(pp) - field975 = unwrapped_fields973[2] - pretty_abstraction(pp, field975) - field976 = unwrapped_fields973[3] - if !isnothing(field976) + field980 = unwrapped_fields978[2] + pretty_abstraction(pp, field980) + field981 = unwrapped_fields978[3] + if !isnothing(field981) newline(pp) - opt_val977 = field976 - pretty_attrs(pp, opt_val977) + opt_val982 = field981 + pretty_attrs(pp, opt_val982) end dedent!(pp) write(pp, ")") @@ -1364,30 +1364,30 @@ function pretty_def(pp::PrettyPrinter, msg::Proto.Def) end function pretty_relation_id(pp::PrettyPrinter, msg::Proto.RelationId) - flat983 = try_flat(pp, msg, pretty_relation_id) - if !isnothing(flat983) - write(pp, flat983) + flat988 = try_flat(pp, msg, pretty_relation_id) + if !isnothing(flat988) + write(pp, flat988) return nothing else _dollar_dollar = msg if !isnothing(relation_id_to_string(pp, _dollar_dollar)) - _t1742 = deconstruct_relation_id_string(pp, _dollar_dollar) - _t1741 = _t1742 + _t1752 = deconstruct_relation_id_string(pp, _dollar_dollar) + _t1751 = _t1752 else - _t1741 = nothing + _t1751 = nothing end - deconstruct_result981 = _t1741 - if !isnothing(deconstruct_result981) - unwrapped982 = deconstruct_result981 + deconstruct_result986 = _t1751 + if !isnothing(deconstruct_result986) + unwrapped987 = deconstruct_result986 write(pp, ":") - write(pp, unwrapped982) + write(pp, unwrapped987) else _dollar_dollar = msg - _t1743 = deconstruct_relation_id_uint128(pp, _dollar_dollar) - deconstruct_result979 = _t1743 - if !isnothing(deconstruct_result979) - unwrapped980 = deconstruct_result979 - write(pp, format_uint128(DEFAULT_CONSTANT_FORMATTER, pp, unwrapped980)) + _t1753 = deconstruct_relation_id_uint128(pp, _dollar_dollar) + deconstruct_result984 = _t1753 + if !isnothing(deconstruct_result984) + unwrapped985 = deconstruct_result984 + write(pp, format_uint128(DEFAULT_CONSTANT_FORMATTER, pp, unwrapped985)) else throw(ParseError("No matching rule for relation_id")) end @@ -1397,22 +1397,22 @@ function pretty_relation_id(pp::PrettyPrinter, msg::Proto.RelationId) end function pretty_abstraction(pp::PrettyPrinter, msg::Proto.Abstraction) - flat988 = try_flat(pp, msg, pretty_abstraction) - if !isnothing(flat988) - write(pp, flat988) + flat993 = try_flat(pp, msg, pretty_abstraction) + if !isnothing(flat993) + write(pp, flat993) return nothing else _dollar_dollar = msg - _t1744 = deconstruct_bindings(pp, _dollar_dollar) - fields984 = (_t1744, _dollar_dollar.value,) - unwrapped_fields985 = fields984 + _t1754 = deconstruct_bindings(pp, _dollar_dollar) + fields989 = (_t1754, _dollar_dollar.value,) + unwrapped_fields990 = fields989 write(pp, "(") indent!(pp) - field986 = unwrapped_fields985[1] - pretty_bindings(pp, field986) + field991 = unwrapped_fields990[1] + pretty_bindings(pp, field991) newline(pp) - field987 = unwrapped_fields985[2] - pretty_formula(pp, field987) + field992 = unwrapped_fields990[2] + pretty_formula(pp, field992) dedent!(pp) write(pp, ")") end @@ -1420,34 +1420,34 @@ function pretty_abstraction(pp::PrettyPrinter, msg::Proto.Abstraction) end function pretty_bindings(pp::PrettyPrinter, msg::Tuple{Vector{Proto.Binding}, Vector{Proto.Binding}}) - flat996 = try_flat(pp, msg, pretty_bindings) - if !isnothing(flat996) - write(pp, flat996) + flat1001 = try_flat(pp, msg, pretty_bindings) + if !isnothing(flat1001) + write(pp, flat1001) return nothing else _dollar_dollar = msg if !isempty(_dollar_dollar[2]) - _t1745 = _dollar_dollar[2] + _t1755 = _dollar_dollar[2] else - _t1745 = nothing + _t1755 = nothing end - fields989 = (_dollar_dollar[1], _t1745,) - unwrapped_fields990 = fields989 + fields994 = (_dollar_dollar[1], _t1755,) + unwrapped_fields995 = fields994 write(pp, "[") indent!(pp) - field991 = unwrapped_fields990[1] - for (i1746, elem992) in enumerate(field991) - i993 = i1746 - 1 - if (i993 > 0) + field996 = unwrapped_fields995[1] + for (i1756, elem997) in enumerate(field996) + i998 = i1756 - 1 + if (i998 > 0) newline(pp) end - pretty_binding(pp, elem992) + pretty_binding(pp, elem997) end - field994 = unwrapped_fields990[2] - if !isnothing(field994) + field999 = unwrapped_fields995[2] + if !isnothing(field999) newline(pp) - opt_val995 = field994 - pretty_value_bindings(pp, opt_val995) + opt_val1000 = field999 + pretty_value_bindings(pp, opt_val1000) end dedent!(pp) write(pp, "]") @@ -1456,184 +1456,196 @@ function pretty_bindings(pp::PrettyPrinter, msg::Tuple{Vector{Proto.Binding}, Ve end function pretty_binding(pp::PrettyPrinter, msg::Proto.Binding) - flat1001 = try_flat(pp, msg, pretty_binding) - if !isnothing(flat1001) - write(pp, flat1001) + flat1006 = try_flat(pp, msg, pretty_binding) + if !isnothing(flat1006) + write(pp, flat1006) return nothing else _dollar_dollar = msg - fields997 = (_dollar_dollar.var.name, _dollar_dollar.var"#type",) - unwrapped_fields998 = fields997 - field999 = unwrapped_fields998[1] - write(pp, field999) + fields1002 = (_dollar_dollar.var.name, _dollar_dollar.var"#type",) + unwrapped_fields1003 = fields1002 + field1004 = unwrapped_fields1003[1] + write(pp, field1004) write(pp, "::") - field1000 = unwrapped_fields998[2] - pretty_type(pp, field1000) + field1005 = unwrapped_fields1003[2] + pretty_type(pp, field1005) end return nothing end function pretty_type(pp::PrettyPrinter, msg::Proto.var"#Type") - flat1030 = try_flat(pp, msg, pretty_type) - if !isnothing(flat1030) - write(pp, flat1030) + flat1037 = try_flat(pp, msg, pretty_type) + if !isnothing(flat1037) + write(pp, flat1037) return nothing else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("unspecified_type")) - _t1747 = _get_oneof_field(_dollar_dollar, :unspecified_type) + _t1757 = _get_oneof_field(_dollar_dollar, :unspecified_type) else - _t1747 = nothing + _t1757 = nothing end - deconstruct_result1028 = _t1747 - if !isnothing(deconstruct_result1028) - unwrapped1029 = deconstruct_result1028 - pretty_unspecified_type(pp, unwrapped1029) + deconstruct_result1035 = _t1757 + if !isnothing(deconstruct_result1035) + unwrapped1036 = deconstruct_result1035 + pretty_unspecified_type(pp, unwrapped1036) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("string_type")) - _t1748 = _get_oneof_field(_dollar_dollar, :string_type) + _t1758 = _get_oneof_field(_dollar_dollar, :string_type) else - _t1748 = nothing + _t1758 = nothing end - deconstruct_result1026 = _t1748 - if !isnothing(deconstruct_result1026) - unwrapped1027 = deconstruct_result1026 - pretty_string_type(pp, unwrapped1027) + deconstruct_result1033 = _t1758 + if !isnothing(deconstruct_result1033) + unwrapped1034 = deconstruct_result1033 + pretty_string_type(pp, unwrapped1034) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("int_type")) - _t1749 = _get_oneof_field(_dollar_dollar, :int_type) + _t1759 = _get_oneof_field(_dollar_dollar, :int_type) else - _t1749 = nothing + _t1759 = nothing end - deconstruct_result1024 = _t1749 - if !isnothing(deconstruct_result1024) - unwrapped1025 = deconstruct_result1024 - pretty_int_type(pp, unwrapped1025) + deconstruct_result1031 = _t1759 + if !isnothing(deconstruct_result1031) + unwrapped1032 = deconstruct_result1031 + pretty_int_type(pp, unwrapped1032) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("float_type")) - _t1750 = _get_oneof_field(_dollar_dollar, :float_type) + _t1760 = _get_oneof_field(_dollar_dollar, :float_type) else - _t1750 = nothing + _t1760 = nothing end - deconstruct_result1022 = _t1750 - if !isnothing(deconstruct_result1022) - unwrapped1023 = deconstruct_result1022 - pretty_float_type(pp, unwrapped1023) + deconstruct_result1029 = _t1760 + if !isnothing(deconstruct_result1029) + unwrapped1030 = deconstruct_result1029 + pretty_float_type(pp, unwrapped1030) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("uint128_type")) - _t1751 = _get_oneof_field(_dollar_dollar, :uint128_type) + _t1761 = _get_oneof_field(_dollar_dollar, :uint128_type) else - _t1751 = nothing + _t1761 = nothing end - deconstruct_result1020 = _t1751 - if !isnothing(deconstruct_result1020) - unwrapped1021 = deconstruct_result1020 - pretty_uint128_type(pp, unwrapped1021) + deconstruct_result1027 = _t1761 + if !isnothing(deconstruct_result1027) + unwrapped1028 = deconstruct_result1027 + pretty_uint128_type(pp, unwrapped1028) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("int128_type")) - _t1752 = _get_oneof_field(_dollar_dollar, :int128_type) + _t1762 = _get_oneof_field(_dollar_dollar, :int128_type) else - _t1752 = nothing + _t1762 = nothing end - deconstruct_result1018 = _t1752 - if !isnothing(deconstruct_result1018) - unwrapped1019 = deconstruct_result1018 - pretty_int128_type(pp, unwrapped1019) + deconstruct_result1025 = _t1762 + if !isnothing(deconstruct_result1025) + unwrapped1026 = deconstruct_result1025 + pretty_int128_type(pp, unwrapped1026) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("date_type")) - _t1753 = _get_oneof_field(_dollar_dollar, :date_type) + _t1763 = _get_oneof_field(_dollar_dollar, :date_type) else - _t1753 = nothing + _t1763 = nothing end - deconstruct_result1016 = _t1753 - if !isnothing(deconstruct_result1016) - unwrapped1017 = deconstruct_result1016 - pretty_date_type(pp, unwrapped1017) + deconstruct_result1023 = _t1763 + if !isnothing(deconstruct_result1023) + unwrapped1024 = deconstruct_result1023 + pretty_date_type(pp, unwrapped1024) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("datetime_type")) - _t1754 = _get_oneof_field(_dollar_dollar, :datetime_type) + _t1764 = _get_oneof_field(_dollar_dollar, :datetime_type) else - _t1754 = nothing + _t1764 = nothing end - deconstruct_result1014 = _t1754 - if !isnothing(deconstruct_result1014) - unwrapped1015 = deconstruct_result1014 - pretty_datetime_type(pp, unwrapped1015) + deconstruct_result1021 = _t1764 + if !isnothing(deconstruct_result1021) + unwrapped1022 = deconstruct_result1021 + pretty_datetime_type(pp, unwrapped1022) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("missing_type")) - _t1755 = _get_oneof_field(_dollar_dollar, :missing_type) + _t1765 = _get_oneof_field(_dollar_dollar, :missing_type) else - _t1755 = nothing + _t1765 = nothing end - deconstruct_result1012 = _t1755 - if !isnothing(deconstruct_result1012) - unwrapped1013 = deconstruct_result1012 - pretty_missing_type(pp, unwrapped1013) + deconstruct_result1019 = _t1765 + if !isnothing(deconstruct_result1019) + unwrapped1020 = deconstruct_result1019 + pretty_missing_type(pp, unwrapped1020) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("decimal_type")) - _t1756 = _get_oneof_field(_dollar_dollar, :decimal_type) + _t1766 = _get_oneof_field(_dollar_dollar, :decimal_type) else - _t1756 = nothing + _t1766 = nothing end - deconstruct_result1010 = _t1756 - if !isnothing(deconstruct_result1010) - unwrapped1011 = deconstruct_result1010 - pretty_decimal_type(pp, unwrapped1011) + deconstruct_result1017 = _t1766 + if !isnothing(deconstruct_result1017) + unwrapped1018 = deconstruct_result1017 + pretty_decimal_type(pp, unwrapped1018) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("boolean_type")) - _t1757 = _get_oneof_field(_dollar_dollar, :boolean_type) + _t1767 = _get_oneof_field(_dollar_dollar, :boolean_type) else - _t1757 = nothing + _t1767 = nothing end - deconstruct_result1008 = _t1757 - if !isnothing(deconstruct_result1008) - unwrapped1009 = deconstruct_result1008 - pretty_boolean_type(pp, unwrapped1009) + deconstruct_result1015 = _t1767 + if !isnothing(deconstruct_result1015) + unwrapped1016 = deconstruct_result1015 + pretty_boolean_type(pp, unwrapped1016) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("int32_type")) - _t1758 = _get_oneof_field(_dollar_dollar, :int32_type) + _t1768 = _get_oneof_field(_dollar_dollar, :int32_type) else - _t1758 = nothing + _t1768 = nothing end - deconstruct_result1006 = _t1758 - if !isnothing(deconstruct_result1006) - unwrapped1007 = deconstruct_result1006 - pretty_int32_type(pp, unwrapped1007) + deconstruct_result1013 = _t1768 + if !isnothing(deconstruct_result1013) + unwrapped1014 = deconstruct_result1013 + pretty_int32_type(pp, unwrapped1014) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("float32_type")) - _t1759 = _get_oneof_field(_dollar_dollar, :float32_type) + _t1769 = _get_oneof_field(_dollar_dollar, :float32_type) else - _t1759 = nothing + _t1769 = nothing end - deconstruct_result1004 = _t1759 - if !isnothing(deconstruct_result1004) - unwrapped1005 = deconstruct_result1004 - pretty_float32_type(pp, unwrapped1005) + deconstruct_result1011 = _t1769 + if !isnothing(deconstruct_result1011) + unwrapped1012 = deconstruct_result1011 + pretty_float32_type(pp, unwrapped1012) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("uint32_type")) - _t1760 = _get_oneof_field(_dollar_dollar, :uint32_type) + _t1770 = _get_oneof_field(_dollar_dollar, :uint32_type) else - _t1760 = nothing + _t1770 = nothing end - deconstruct_result1002 = _t1760 - if !isnothing(deconstruct_result1002) - unwrapped1003 = deconstruct_result1002 - pretty_uint32_type(pp, unwrapped1003) + deconstruct_result1009 = _t1770 + if !isnothing(deconstruct_result1009) + unwrapped1010 = deconstruct_result1009 + pretty_uint32_type(pp, unwrapped1010) else - throw(ParseError("No matching rule for type")) + _dollar_dollar = msg + if _has_proto_field(_dollar_dollar, Symbol("fixed_type")) + _t1771 = _get_oneof_field(_dollar_dollar, :fixed_type) + else + _t1771 = nothing + end + deconstruct_result1007 = _t1771 + if !isnothing(deconstruct_result1007) + unwrapped1008 = deconstruct_result1007 + pretty_fixed_type(pp, unwrapped1008) + else + throw(ParseError("No matching rule for type")) + end end end end @@ -1653,76 +1665,76 @@ function pretty_type(pp::PrettyPrinter, msg::Proto.var"#Type") end function pretty_unspecified_type(pp::PrettyPrinter, msg::Proto.UnspecifiedType) - fields1031 = msg + fields1038 = msg write(pp, "UNKNOWN") return nothing end function pretty_string_type(pp::PrettyPrinter, msg::Proto.StringType) - fields1032 = msg + fields1039 = msg write(pp, "STRING") return nothing end function pretty_int_type(pp::PrettyPrinter, msg::Proto.IntType) - fields1033 = msg + fields1040 = msg write(pp, "INT") return nothing end function pretty_float_type(pp::PrettyPrinter, msg::Proto.FloatType) - fields1034 = msg + fields1041 = msg write(pp, "FLOAT") return nothing end function pretty_uint128_type(pp::PrettyPrinter, msg::Proto.UInt128Type) - fields1035 = msg + fields1042 = msg write(pp, "UINT128") return nothing end function pretty_int128_type(pp::PrettyPrinter, msg::Proto.Int128Type) - fields1036 = msg + fields1043 = msg write(pp, "INT128") return nothing end function pretty_date_type(pp::PrettyPrinter, msg::Proto.DateType) - fields1037 = msg + fields1044 = msg write(pp, "DATE") return nothing end function pretty_datetime_type(pp::PrettyPrinter, msg::Proto.DateTimeType) - fields1038 = msg + fields1045 = msg write(pp, "DATETIME") return nothing end function pretty_missing_type(pp::PrettyPrinter, msg::Proto.MissingType) - fields1039 = msg + fields1046 = msg write(pp, "MISSING") return nothing end function pretty_decimal_type(pp::PrettyPrinter, msg::Proto.DecimalType) - flat1044 = try_flat(pp, msg, pretty_decimal_type) - if !isnothing(flat1044) - write(pp, flat1044) + flat1051 = try_flat(pp, msg, pretty_decimal_type) + if !isnothing(flat1051) + write(pp, flat1051) return nothing else _dollar_dollar = msg - fields1040 = (Int64(_dollar_dollar.precision), Int64(_dollar_dollar.scale),) - unwrapped_fields1041 = fields1040 + fields1047 = (Int64(_dollar_dollar.precision), Int64(_dollar_dollar.scale),) + unwrapped_fields1048 = fields1047 write(pp, "(DECIMAL") indent_sexp!(pp) newline(pp) - field1042 = unwrapped_fields1041[1] - write(pp, string(field1042)) + field1049 = unwrapped_fields1048[1] + write(pp, string(field1049)) newline(pp) - field1043 = unwrapped_fields1041[2] - write(pp, string(field1043)) + field1050 = unwrapped_fields1048[2] + write(pp, string(field1050)) dedent!(pp) write(pp, ")") end @@ -1730,45 +1742,64 @@ function pretty_decimal_type(pp::PrettyPrinter, msg::Proto.DecimalType) end function pretty_boolean_type(pp::PrettyPrinter, msg::Proto.BooleanType) - fields1045 = msg + fields1052 = msg write(pp, "BOOLEAN") return nothing end function pretty_int32_type(pp::PrettyPrinter, msg::Proto.Int32Type) - fields1046 = msg + fields1053 = msg write(pp, "INT32") return nothing end function pretty_float32_type(pp::PrettyPrinter, msg::Proto.Float32Type) - fields1047 = msg + fields1054 = msg write(pp, "FLOAT32") return nothing end function pretty_uint32_type(pp::PrettyPrinter, msg::Proto.UInt32Type) - fields1048 = msg + fields1055 = msg write(pp, "UINT32") return nothing end +function pretty_fixed_type(pp::PrettyPrinter, msg::Proto.FixedType) + flat1058 = try_flat(pp, msg, pretty_fixed_type) + if !isnothing(flat1058) + write(pp, flat1058) + return nothing + else + _dollar_dollar = msg + fields1056 = Int64(_dollar_dollar.length) + unwrapped_fields1057 = fields1056 + write(pp, "(FIXED") + indent_sexp!(pp) + newline(pp) + write(pp, string(unwrapped_fields1057)) + dedent!(pp) + write(pp, ")") + end + return nothing +end + function pretty_value_bindings(pp::PrettyPrinter, msg::Vector{Proto.Binding}) - flat1052 = try_flat(pp, msg, pretty_value_bindings) - if !isnothing(flat1052) - write(pp, flat1052) + flat1062 = try_flat(pp, msg, pretty_value_bindings) + if !isnothing(flat1062) + write(pp, flat1062) return nothing else - fields1049 = msg + fields1059 = msg write(pp, "|") - if !isempty(fields1049) + if !isempty(fields1059) write(pp, " ") - for (i1761, elem1050) in enumerate(fields1049) - i1051 = i1761 - 1 - if (i1051 > 0) + for (i1772, elem1060) in enumerate(fields1059) + i1061 = i1772 - 1 + if (i1061 > 0) newline(pp) end - pretty_binding(pp, elem1050) + pretty_binding(pp, elem1060) end end end @@ -1776,153 +1807,153 @@ function pretty_value_bindings(pp::PrettyPrinter, msg::Vector{Proto.Binding}) end function pretty_formula(pp::PrettyPrinter, msg::Proto.Formula) - flat1079 = try_flat(pp, msg, pretty_formula) - if !isnothing(flat1079) - write(pp, flat1079) + flat1089 = try_flat(pp, msg, pretty_formula) + if !isnothing(flat1089) + write(pp, flat1089) return nothing else _dollar_dollar = msg if (_has_proto_field(_dollar_dollar, Symbol("conjunction")) && isempty(_get_oneof_field(_dollar_dollar, :conjunction).args)) - _t1762 = _get_oneof_field(_dollar_dollar, :conjunction) + _t1773 = _get_oneof_field(_dollar_dollar, :conjunction) else - _t1762 = nothing + _t1773 = nothing end - deconstruct_result1077 = _t1762 - if !isnothing(deconstruct_result1077) - unwrapped1078 = deconstruct_result1077 - pretty_true(pp, unwrapped1078) + deconstruct_result1087 = _t1773 + if !isnothing(deconstruct_result1087) + unwrapped1088 = deconstruct_result1087 + pretty_true(pp, unwrapped1088) else _dollar_dollar = msg if (_has_proto_field(_dollar_dollar, Symbol("disjunction")) && isempty(_get_oneof_field(_dollar_dollar, :disjunction).args)) - _t1763 = _get_oneof_field(_dollar_dollar, :disjunction) + _t1774 = _get_oneof_field(_dollar_dollar, :disjunction) else - _t1763 = nothing + _t1774 = nothing end - deconstruct_result1075 = _t1763 - if !isnothing(deconstruct_result1075) - unwrapped1076 = deconstruct_result1075 - pretty_false(pp, unwrapped1076) + deconstruct_result1085 = _t1774 + if !isnothing(deconstruct_result1085) + unwrapped1086 = deconstruct_result1085 + pretty_false(pp, unwrapped1086) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("exists")) - _t1764 = _get_oneof_field(_dollar_dollar, :exists) + _t1775 = _get_oneof_field(_dollar_dollar, :exists) else - _t1764 = nothing + _t1775 = nothing end - deconstruct_result1073 = _t1764 - if !isnothing(deconstruct_result1073) - unwrapped1074 = deconstruct_result1073 - pretty_exists(pp, unwrapped1074) + deconstruct_result1083 = _t1775 + if !isnothing(deconstruct_result1083) + unwrapped1084 = deconstruct_result1083 + pretty_exists(pp, unwrapped1084) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("reduce")) - _t1765 = _get_oneof_field(_dollar_dollar, :reduce) + _t1776 = _get_oneof_field(_dollar_dollar, :reduce) else - _t1765 = nothing + _t1776 = nothing end - deconstruct_result1071 = _t1765 - if !isnothing(deconstruct_result1071) - unwrapped1072 = deconstruct_result1071 - pretty_reduce(pp, unwrapped1072) + deconstruct_result1081 = _t1776 + if !isnothing(deconstruct_result1081) + unwrapped1082 = deconstruct_result1081 + pretty_reduce(pp, unwrapped1082) else _dollar_dollar = msg if (_has_proto_field(_dollar_dollar, Symbol("conjunction")) && !isempty(_get_oneof_field(_dollar_dollar, :conjunction).args)) - _t1766 = _get_oneof_field(_dollar_dollar, :conjunction) + _t1777 = _get_oneof_field(_dollar_dollar, :conjunction) else - _t1766 = nothing + _t1777 = nothing end - deconstruct_result1069 = _t1766 - if !isnothing(deconstruct_result1069) - unwrapped1070 = deconstruct_result1069 - pretty_conjunction(pp, unwrapped1070) + deconstruct_result1079 = _t1777 + if !isnothing(deconstruct_result1079) + unwrapped1080 = deconstruct_result1079 + pretty_conjunction(pp, unwrapped1080) else _dollar_dollar = msg if (_has_proto_field(_dollar_dollar, Symbol("disjunction")) && !isempty(_get_oneof_field(_dollar_dollar, :disjunction).args)) - _t1767 = _get_oneof_field(_dollar_dollar, :disjunction) + _t1778 = _get_oneof_field(_dollar_dollar, :disjunction) else - _t1767 = nothing + _t1778 = nothing end - deconstruct_result1067 = _t1767 - if !isnothing(deconstruct_result1067) - unwrapped1068 = deconstruct_result1067 - pretty_disjunction(pp, unwrapped1068) + deconstruct_result1077 = _t1778 + if !isnothing(deconstruct_result1077) + unwrapped1078 = deconstruct_result1077 + pretty_disjunction(pp, unwrapped1078) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("not")) - _t1768 = _get_oneof_field(_dollar_dollar, :not) + _t1779 = _get_oneof_field(_dollar_dollar, :not) else - _t1768 = nothing + _t1779 = nothing end - deconstruct_result1065 = _t1768 - if !isnothing(deconstruct_result1065) - unwrapped1066 = deconstruct_result1065 - pretty_not(pp, unwrapped1066) + deconstruct_result1075 = _t1779 + if !isnothing(deconstruct_result1075) + unwrapped1076 = deconstruct_result1075 + pretty_not(pp, unwrapped1076) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("ffi")) - _t1769 = _get_oneof_field(_dollar_dollar, :ffi) + _t1780 = _get_oneof_field(_dollar_dollar, :ffi) else - _t1769 = nothing + _t1780 = nothing end - deconstruct_result1063 = _t1769 - if !isnothing(deconstruct_result1063) - unwrapped1064 = deconstruct_result1063 - pretty_ffi(pp, unwrapped1064) + deconstruct_result1073 = _t1780 + if !isnothing(deconstruct_result1073) + unwrapped1074 = deconstruct_result1073 + pretty_ffi(pp, unwrapped1074) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("atom")) - _t1770 = _get_oneof_field(_dollar_dollar, :atom) + _t1781 = _get_oneof_field(_dollar_dollar, :atom) else - _t1770 = nothing + _t1781 = nothing end - deconstruct_result1061 = _t1770 - if !isnothing(deconstruct_result1061) - unwrapped1062 = deconstruct_result1061 - pretty_atom(pp, unwrapped1062) + deconstruct_result1071 = _t1781 + if !isnothing(deconstruct_result1071) + unwrapped1072 = deconstruct_result1071 + pretty_atom(pp, unwrapped1072) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("pragma")) - _t1771 = _get_oneof_field(_dollar_dollar, :pragma) + _t1782 = _get_oneof_field(_dollar_dollar, :pragma) else - _t1771 = nothing + _t1782 = nothing end - deconstruct_result1059 = _t1771 - if !isnothing(deconstruct_result1059) - unwrapped1060 = deconstruct_result1059 - pretty_pragma(pp, unwrapped1060) + deconstruct_result1069 = _t1782 + if !isnothing(deconstruct_result1069) + unwrapped1070 = deconstruct_result1069 + pretty_pragma(pp, unwrapped1070) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("primitive")) - _t1772 = _get_oneof_field(_dollar_dollar, :primitive) + _t1783 = _get_oneof_field(_dollar_dollar, :primitive) else - _t1772 = nothing + _t1783 = nothing end - deconstruct_result1057 = _t1772 - if !isnothing(deconstruct_result1057) - unwrapped1058 = deconstruct_result1057 - pretty_primitive(pp, unwrapped1058) + deconstruct_result1067 = _t1783 + if !isnothing(deconstruct_result1067) + unwrapped1068 = deconstruct_result1067 + pretty_primitive(pp, unwrapped1068) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("rel_atom")) - _t1773 = _get_oneof_field(_dollar_dollar, :rel_atom) + _t1784 = _get_oneof_field(_dollar_dollar, :rel_atom) else - _t1773 = nothing + _t1784 = nothing end - deconstruct_result1055 = _t1773 - if !isnothing(deconstruct_result1055) - unwrapped1056 = deconstruct_result1055 - pretty_rel_atom(pp, unwrapped1056) + deconstruct_result1065 = _t1784 + if !isnothing(deconstruct_result1065) + unwrapped1066 = deconstruct_result1065 + pretty_rel_atom(pp, unwrapped1066) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("cast")) - _t1774 = _get_oneof_field(_dollar_dollar, :cast) + _t1785 = _get_oneof_field(_dollar_dollar, :cast) else - _t1774 = nothing + _t1785 = nothing end - deconstruct_result1053 = _t1774 - if !isnothing(deconstruct_result1053) - unwrapped1054 = deconstruct_result1053 - pretty_cast(pp, unwrapped1054) + deconstruct_result1063 = _t1785 + if !isnothing(deconstruct_result1063) + unwrapped1064 = deconstruct_result1063 + pretty_cast(pp, unwrapped1064) else throw(ParseError("No matching rule for formula")) end @@ -1943,35 +1974,35 @@ function pretty_formula(pp::PrettyPrinter, msg::Proto.Formula) end function pretty_true(pp::PrettyPrinter, msg::Proto.Conjunction) - fields1080 = msg + fields1090 = msg write(pp, "(true)") return nothing end function pretty_false(pp::PrettyPrinter, msg::Proto.Disjunction) - fields1081 = msg + fields1091 = msg write(pp, "(false)") return nothing end function pretty_exists(pp::PrettyPrinter, msg::Proto.Exists) - flat1086 = try_flat(pp, msg, pretty_exists) - if !isnothing(flat1086) - write(pp, flat1086) + flat1096 = try_flat(pp, msg, pretty_exists) + if !isnothing(flat1096) + write(pp, flat1096) return nothing else _dollar_dollar = msg - _t1775 = deconstruct_bindings(pp, _dollar_dollar.body) - fields1082 = (_t1775, _dollar_dollar.body.value,) - unwrapped_fields1083 = fields1082 + _t1786 = deconstruct_bindings(pp, _dollar_dollar.body) + fields1092 = (_t1786, _dollar_dollar.body.value,) + unwrapped_fields1093 = fields1092 write(pp, "(exists") indent_sexp!(pp) newline(pp) - field1084 = unwrapped_fields1083[1] - pretty_bindings(pp, field1084) + field1094 = unwrapped_fields1093[1] + pretty_bindings(pp, field1094) newline(pp) - field1085 = unwrapped_fields1083[2] - pretty_formula(pp, field1085) + field1095 = unwrapped_fields1093[2] + pretty_formula(pp, field1095) dedent!(pp) write(pp, ")") end @@ -1979,25 +2010,25 @@ function pretty_exists(pp::PrettyPrinter, msg::Proto.Exists) end function pretty_reduce(pp::PrettyPrinter, msg::Proto.Reduce) - flat1092 = try_flat(pp, msg, pretty_reduce) - if !isnothing(flat1092) - write(pp, flat1092) + flat1102 = try_flat(pp, msg, pretty_reduce) + if !isnothing(flat1102) + write(pp, flat1102) return nothing else _dollar_dollar = msg - fields1087 = (_dollar_dollar.op, _dollar_dollar.body, _dollar_dollar.terms,) - unwrapped_fields1088 = fields1087 + fields1097 = (_dollar_dollar.op, _dollar_dollar.body, _dollar_dollar.terms,) + unwrapped_fields1098 = fields1097 write(pp, "(reduce") indent_sexp!(pp) newline(pp) - field1089 = unwrapped_fields1088[1] - pretty_abstraction(pp, field1089) + field1099 = unwrapped_fields1098[1] + pretty_abstraction(pp, field1099) newline(pp) - field1090 = unwrapped_fields1088[2] - pretty_abstraction(pp, field1090) + field1100 = unwrapped_fields1098[2] + pretty_abstraction(pp, field1100) newline(pp) - field1091 = unwrapped_fields1088[3] - pretty_terms(pp, field1091) + field1101 = unwrapped_fields1098[3] + pretty_terms(pp, field1101) dedent!(pp) write(pp, ")") end @@ -2005,22 +2036,22 @@ function pretty_reduce(pp::PrettyPrinter, msg::Proto.Reduce) end function pretty_terms(pp::PrettyPrinter, msg::Vector{Proto.Term}) - flat1096 = try_flat(pp, msg, pretty_terms) - if !isnothing(flat1096) - write(pp, flat1096) + flat1106 = try_flat(pp, msg, pretty_terms) + if !isnothing(flat1106) + write(pp, flat1106) return nothing else - fields1093 = msg + fields1103 = msg write(pp, "(terms") indent_sexp!(pp) - if !isempty(fields1093) + if !isempty(fields1103) newline(pp) - for (i1776, elem1094) in enumerate(fields1093) - i1095 = i1776 - 1 - if (i1095 > 0) + for (i1787, elem1104) in enumerate(fields1103) + i1105 = i1787 - 1 + if (i1105 > 0) newline(pp) end - pretty_term(pp, elem1094) + pretty_term(pp, elem1104) end end dedent!(pp) @@ -2030,32 +2061,32 @@ function pretty_terms(pp::PrettyPrinter, msg::Vector{Proto.Term}) end function pretty_term(pp::PrettyPrinter, msg::Proto.Term) - flat1101 = try_flat(pp, msg, pretty_term) - if !isnothing(flat1101) - write(pp, flat1101) + flat1111 = try_flat(pp, msg, pretty_term) + if !isnothing(flat1111) + write(pp, flat1111) return nothing else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("var")) - _t1777 = _get_oneof_field(_dollar_dollar, :var) + _t1788 = _get_oneof_field(_dollar_dollar, :var) else - _t1777 = nothing + _t1788 = nothing end - deconstruct_result1099 = _t1777 - if !isnothing(deconstruct_result1099) - unwrapped1100 = deconstruct_result1099 - pretty_var(pp, unwrapped1100) + deconstruct_result1109 = _t1788 + if !isnothing(deconstruct_result1109) + unwrapped1110 = deconstruct_result1109 + pretty_var(pp, unwrapped1110) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("constant")) - _t1778 = _get_oneof_field(_dollar_dollar, :constant) + _t1789 = _get_oneof_field(_dollar_dollar, :constant) else - _t1778 = nothing + _t1789 = nothing end - deconstruct_result1097 = _t1778 - if !isnothing(deconstruct_result1097) - unwrapped1098 = deconstruct_result1097 - pretty_value(pp, unwrapped1098) + deconstruct_result1107 = _t1789 + if !isnothing(deconstruct_result1107) + unwrapped1108 = deconstruct_result1107 + pretty_value(pp, unwrapped1108) else throw(ParseError("No matching rule for term")) end @@ -2065,158 +2096,158 @@ function pretty_term(pp::PrettyPrinter, msg::Proto.Term) end function pretty_var(pp::PrettyPrinter, msg::Proto.Var) - flat1104 = try_flat(pp, msg, pretty_var) - if !isnothing(flat1104) - write(pp, flat1104) + flat1114 = try_flat(pp, msg, pretty_var) + if !isnothing(flat1114) + write(pp, flat1114) return nothing else _dollar_dollar = msg - fields1102 = _dollar_dollar.name - unwrapped_fields1103 = fields1102 - write(pp, unwrapped_fields1103) + fields1112 = _dollar_dollar.name + unwrapped_fields1113 = fields1112 + write(pp, unwrapped_fields1113) end return nothing end function pretty_value(pp::PrettyPrinter, msg::Proto.Value) - flat1130 = try_flat(pp, msg, pretty_value) - if !isnothing(flat1130) - write(pp, flat1130) + flat1140 = try_flat(pp, msg, pretty_value) + if !isnothing(flat1140) + write(pp, flat1140) return nothing else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("date_value")) - _t1779 = _get_oneof_field(_dollar_dollar, :date_value) + _t1790 = _get_oneof_field(_dollar_dollar, :date_value) else - _t1779 = nothing + _t1790 = nothing end - deconstruct_result1128 = _t1779 - if !isnothing(deconstruct_result1128) - unwrapped1129 = deconstruct_result1128 - pretty_date(pp, unwrapped1129) + deconstruct_result1138 = _t1790 + if !isnothing(deconstruct_result1138) + unwrapped1139 = deconstruct_result1138 + pretty_date(pp, unwrapped1139) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("datetime_value")) - _t1780 = _get_oneof_field(_dollar_dollar, :datetime_value) + _t1791 = _get_oneof_field(_dollar_dollar, :datetime_value) else - _t1780 = nothing + _t1791 = nothing end - deconstruct_result1126 = _t1780 - if !isnothing(deconstruct_result1126) - unwrapped1127 = deconstruct_result1126 - pretty_datetime(pp, unwrapped1127) + deconstruct_result1136 = _t1791 + if !isnothing(deconstruct_result1136) + unwrapped1137 = deconstruct_result1136 + pretty_datetime(pp, unwrapped1137) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("string_value")) - _t1781 = _get_oneof_field(_dollar_dollar, :string_value) + _t1792 = _get_oneof_field(_dollar_dollar, :string_value) else - _t1781 = nothing + _t1792 = nothing end - deconstruct_result1124 = _t1781 - if !isnothing(deconstruct_result1124) - unwrapped1125 = deconstruct_result1124 - write(pp, format_string(pp, unwrapped1125)) + deconstruct_result1134 = _t1792 + if !isnothing(deconstruct_result1134) + unwrapped1135 = deconstruct_result1134 + write(pp, format_string(pp, unwrapped1135)) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("int32_value")) - _t1782 = _get_oneof_field(_dollar_dollar, :int32_value) + _t1793 = _get_oneof_field(_dollar_dollar, :int32_value) else - _t1782 = nothing + _t1793 = nothing end - deconstruct_result1122 = _t1782 - if !isnothing(deconstruct_result1122) - unwrapped1123 = deconstruct_result1122 - write(pp, format_int32(pp, unwrapped1123)) + deconstruct_result1132 = _t1793 + if !isnothing(deconstruct_result1132) + unwrapped1133 = deconstruct_result1132 + write(pp, format_int32(pp, unwrapped1133)) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("int_value")) - _t1783 = _get_oneof_field(_dollar_dollar, :int_value) + _t1794 = _get_oneof_field(_dollar_dollar, :int_value) else - _t1783 = nothing + _t1794 = nothing end - deconstruct_result1120 = _t1783 - if !isnothing(deconstruct_result1120) - unwrapped1121 = deconstruct_result1120 - write(pp, format_int(pp, unwrapped1121)) + deconstruct_result1130 = _t1794 + if !isnothing(deconstruct_result1130) + unwrapped1131 = deconstruct_result1130 + write(pp, format_int(pp, unwrapped1131)) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("float32_value")) - _t1784 = _get_oneof_field(_dollar_dollar, :float32_value) + _t1795 = _get_oneof_field(_dollar_dollar, :float32_value) else - _t1784 = nothing + _t1795 = nothing end - deconstruct_result1118 = _t1784 - if !isnothing(deconstruct_result1118) - unwrapped1119 = deconstruct_result1118 - write(pp, format_float32(pp, unwrapped1119)) + deconstruct_result1128 = _t1795 + if !isnothing(deconstruct_result1128) + unwrapped1129 = deconstruct_result1128 + write(pp, format_float32(pp, unwrapped1129)) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("float_value")) - _t1785 = _get_oneof_field(_dollar_dollar, :float_value) + _t1796 = _get_oneof_field(_dollar_dollar, :float_value) else - _t1785 = nothing + _t1796 = nothing end - deconstruct_result1116 = _t1785 - if !isnothing(deconstruct_result1116) - unwrapped1117 = deconstruct_result1116 - write(pp, format_float(pp, unwrapped1117)) + deconstruct_result1126 = _t1796 + if !isnothing(deconstruct_result1126) + unwrapped1127 = deconstruct_result1126 + write(pp, format_float(pp, unwrapped1127)) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("uint32_value")) - _t1786 = _get_oneof_field(_dollar_dollar, :uint32_value) + _t1797 = _get_oneof_field(_dollar_dollar, :uint32_value) else - _t1786 = nothing + _t1797 = nothing end - deconstruct_result1114 = _t1786 - if !isnothing(deconstruct_result1114) - unwrapped1115 = deconstruct_result1114 - write(pp, format_uint32(pp, unwrapped1115)) + deconstruct_result1124 = _t1797 + if !isnothing(deconstruct_result1124) + unwrapped1125 = deconstruct_result1124 + write(pp, format_uint32(pp, unwrapped1125)) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("uint128_value")) - _t1787 = _get_oneof_field(_dollar_dollar, :uint128_value) + _t1798 = _get_oneof_field(_dollar_dollar, :uint128_value) else - _t1787 = nothing + _t1798 = nothing end - deconstruct_result1112 = _t1787 - if !isnothing(deconstruct_result1112) - unwrapped1113 = deconstruct_result1112 - write(pp, format_uint128(pp, unwrapped1113)) + deconstruct_result1122 = _t1798 + if !isnothing(deconstruct_result1122) + unwrapped1123 = deconstruct_result1122 + write(pp, format_uint128(pp, unwrapped1123)) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("int128_value")) - _t1788 = _get_oneof_field(_dollar_dollar, :int128_value) + _t1799 = _get_oneof_field(_dollar_dollar, :int128_value) else - _t1788 = nothing + _t1799 = nothing end - deconstruct_result1110 = _t1788 - if !isnothing(deconstruct_result1110) - unwrapped1111 = deconstruct_result1110 - write(pp, format_int128(pp, unwrapped1111)) + deconstruct_result1120 = _t1799 + if !isnothing(deconstruct_result1120) + unwrapped1121 = deconstruct_result1120 + write(pp, format_int128(pp, unwrapped1121)) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("decimal_value")) - _t1789 = _get_oneof_field(_dollar_dollar, :decimal_value) + _t1800 = _get_oneof_field(_dollar_dollar, :decimal_value) else - _t1789 = nothing + _t1800 = nothing end - deconstruct_result1108 = _t1789 - if !isnothing(deconstruct_result1108) - unwrapped1109 = deconstruct_result1108 - write(pp, format_decimal(pp, unwrapped1109)) + deconstruct_result1118 = _t1800 + if !isnothing(deconstruct_result1118) + unwrapped1119 = deconstruct_result1118 + write(pp, format_decimal(pp, unwrapped1119)) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("boolean_value")) - _t1790 = _get_oneof_field(_dollar_dollar, :boolean_value) + _t1801 = _get_oneof_field(_dollar_dollar, :boolean_value) else - _t1790 = nothing + _t1801 = nothing end - deconstruct_result1106 = _t1790 - if !isnothing(deconstruct_result1106) - unwrapped1107 = deconstruct_result1106 - pretty_boolean_value(pp, unwrapped1107) + deconstruct_result1116 = _t1801 + if !isnothing(deconstruct_result1116) + unwrapped1117 = deconstruct_result1116 + pretty_boolean_value(pp, unwrapped1117) else - fields1105 = msg + fields1115 = msg write(pp, "missing") end end @@ -2235,25 +2266,25 @@ function pretty_value(pp::PrettyPrinter, msg::Proto.Value) end function pretty_date(pp::PrettyPrinter, msg::Proto.DateValue) - flat1136 = try_flat(pp, msg, pretty_date) - if !isnothing(flat1136) - write(pp, flat1136) + flat1146 = try_flat(pp, msg, pretty_date) + if !isnothing(flat1146) + write(pp, flat1146) return nothing else _dollar_dollar = msg - fields1131 = (Int64(_dollar_dollar.year), Int64(_dollar_dollar.month), Int64(_dollar_dollar.day),) - unwrapped_fields1132 = fields1131 + fields1141 = (Int64(_dollar_dollar.year), Int64(_dollar_dollar.month), Int64(_dollar_dollar.day),) + unwrapped_fields1142 = fields1141 write(pp, "(date") indent_sexp!(pp) newline(pp) - field1133 = unwrapped_fields1132[1] - write(pp, format_int(pp, field1133)) + field1143 = unwrapped_fields1142[1] + write(pp, format_int(pp, field1143)) newline(pp) - field1134 = unwrapped_fields1132[2] - write(pp, format_int(pp, field1134)) + field1144 = unwrapped_fields1142[2] + write(pp, format_int(pp, field1144)) newline(pp) - field1135 = unwrapped_fields1132[3] - write(pp, format_int(pp, field1135)) + field1145 = unwrapped_fields1142[3] + write(pp, format_int(pp, field1145)) dedent!(pp) write(pp, ")") end @@ -2261,39 +2292,39 @@ function pretty_date(pp::PrettyPrinter, msg::Proto.DateValue) end function pretty_datetime(pp::PrettyPrinter, msg::Proto.DateTimeValue) - flat1147 = try_flat(pp, msg, pretty_datetime) - if !isnothing(flat1147) - write(pp, flat1147) + flat1157 = try_flat(pp, msg, pretty_datetime) + if !isnothing(flat1157) + write(pp, flat1157) return nothing else _dollar_dollar = msg - fields1137 = (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_fields1138 = fields1137 + fields1147 = (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_fields1148 = fields1147 write(pp, "(datetime") indent_sexp!(pp) newline(pp) - field1139 = unwrapped_fields1138[1] - write(pp, format_int(pp, field1139)) + field1149 = unwrapped_fields1148[1] + write(pp, format_int(pp, field1149)) newline(pp) - field1140 = unwrapped_fields1138[2] - write(pp, format_int(pp, field1140)) + field1150 = unwrapped_fields1148[2] + write(pp, format_int(pp, field1150)) newline(pp) - field1141 = unwrapped_fields1138[3] - write(pp, format_int(pp, field1141)) + field1151 = unwrapped_fields1148[3] + write(pp, format_int(pp, field1151)) newline(pp) - field1142 = unwrapped_fields1138[4] - write(pp, format_int(pp, field1142)) + field1152 = unwrapped_fields1148[4] + write(pp, format_int(pp, field1152)) newline(pp) - field1143 = unwrapped_fields1138[5] - write(pp, format_int(pp, field1143)) + field1153 = unwrapped_fields1148[5] + write(pp, format_int(pp, field1153)) newline(pp) - field1144 = unwrapped_fields1138[6] - write(pp, format_int(pp, field1144)) - field1145 = unwrapped_fields1138[7] - if !isnothing(field1145) + field1154 = unwrapped_fields1148[6] + write(pp, format_int(pp, field1154)) + field1155 = unwrapped_fields1148[7] + if !isnothing(field1155) newline(pp) - opt_val1146 = field1145 - write(pp, format_int(pp, opt_val1146)) + opt_val1156 = field1155 + write(pp, format_int(pp, opt_val1156)) end dedent!(pp) write(pp, ")") @@ -2302,24 +2333,24 @@ function pretty_datetime(pp::PrettyPrinter, msg::Proto.DateTimeValue) end function pretty_conjunction(pp::PrettyPrinter, msg::Proto.Conjunction) - flat1152 = try_flat(pp, msg, pretty_conjunction) - if !isnothing(flat1152) - write(pp, flat1152) + flat1162 = try_flat(pp, msg, pretty_conjunction) + if !isnothing(flat1162) + write(pp, flat1162) return nothing else _dollar_dollar = msg - fields1148 = _dollar_dollar.args - unwrapped_fields1149 = fields1148 + fields1158 = _dollar_dollar.args + unwrapped_fields1159 = fields1158 write(pp, "(and") indent_sexp!(pp) - if !isempty(unwrapped_fields1149) + if !isempty(unwrapped_fields1159) newline(pp) - for (i1791, elem1150) in enumerate(unwrapped_fields1149) - i1151 = i1791 - 1 - if (i1151 > 0) + for (i1802, elem1160) in enumerate(unwrapped_fields1159) + i1161 = i1802 - 1 + if (i1161 > 0) newline(pp) end - pretty_formula(pp, elem1150) + pretty_formula(pp, elem1160) end end dedent!(pp) @@ -2329,24 +2360,24 @@ function pretty_conjunction(pp::PrettyPrinter, msg::Proto.Conjunction) end function pretty_disjunction(pp::PrettyPrinter, msg::Proto.Disjunction) - flat1157 = try_flat(pp, msg, pretty_disjunction) - if !isnothing(flat1157) - write(pp, flat1157) + flat1167 = try_flat(pp, msg, pretty_disjunction) + if !isnothing(flat1167) + write(pp, flat1167) return nothing else _dollar_dollar = msg - fields1153 = _dollar_dollar.args - unwrapped_fields1154 = fields1153 + fields1163 = _dollar_dollar.args + unwrapped_fields1164 = fields1163 write(pp, "(or") indent_sexp!(pp) - if !isempty(unwrapped_fields1154) + if !isempty(unwrapped_fields1164) newline(pp) - for (i1792, elem1155) in enumerate(unwrapped_fields1154) - i1156 = i1792 - 1 - if (i1156 > 0) + for (i1803, elem1165) in enumerate(unwrapped_fields1164) + i1166 = i1803 - 1 + if (i1166 > 0) newline(pp) end - pretty_formula(pp, elem1155) + pretty_formula(pp, elem1165) end end dedent!(pp) @@ -2356,18 +2387,18 @@ function pretty_disjunction(pp::PrettyPrinter, msg::Proto.Disjunction) end function pretty_not(pp::PrettyPrinter, msg::Proto.Not) - flat1160 = try_flat(pp, msg, pretty_not) - if !isnothing(flat1160) - write(pp, flat1160) + flat1170 = try_flat(pp, msg, pretty_not) + if !isnothing(flat1170) + write(pp, flat1170) return nothing else _dollar_dollar = msg - fields1158 = _dollar_dollar.arg - unwrapped_fields1159 = fields1158 + fields1168 = _dollar_dollar.arg + unwrapped_fields1169 = fields1168 write(pp, "(not") indent_sexp!(pp) newline(pp) - pretty_formula(pp, unwrapped_fields1159) + pretty_formula(pp, unwrapped_fields1169) dedent!(pp) write(pp, ")") end @@ -2375,25 +2406,25 @@ function pretty_not(pp::PrettyPrinter, msg::Proto.Not) end function pretty_ffi(pp::PrettyPrinter, msg::Proto.FFI) - flat1166 = try_flat(pp, msg, pretty_ffi) - if !isnothing(flat1166) - write(pp, flat1166) + flat1176 = try_flat(pp, msg, pretty_ffi) + if !isnothing(flat1176) + write(pp, flat1176) return nothing else _dollar_dollar = msg - fields1161 = (_dollar_dollar.name, _dollar_dollar.args, _dollar_dollar.terms,) - unwrapped_fields1162 = fields1161 + fields1171 = (_dollar_dollar.name, _dollar_dollar.args, _dollar_dollar.terms,) + unwrapped_fields1172 = fields1171 write(pp, "(ffi") indent_sexp!(pp) newline(pp) - field1163 = unwrapped_fields1162[1] - pretty_name(pp, field1163) + field1173 = unwrapped_fields1172[1] + pretty_name(pp, field1173) newline(pp) - field1164 = unwrapped_fields1162[2] - pretty_ffi_args(pp, field1164) + field1174 = unwrapped_fields1172[2] + pretty_ffi_args(pp, field1174) newline(pp) - field1165 = unwrapped_fields1162[3] - pretty_terms(pp, field1165) + field1175 = unwrapped_fields1172[3] + pretty_terms(pp, field1175) dedent!(pp) write(pp, ")") end @@ -2401,35 +2432,35 @@ function pretty_ffi(pp::PrettyPrinter, msg::Proto.FFI) end function pretty_name(pp::PrettyPrinter, msg::String) - flat1168 = try_flat(pp, msg, pretty_name) - if !isnothing(flat1168) - write(pp, flat1168) + flat1178 = try_flat(pp, msg, pretty_name) + if !isnothing(flat1178) + write(pp, flat1178) return nothing else - fields1167 = msg + fields1177 = msg write(pp, ":") - write(pp, fields1167) + write(pp, fields1177) end return nothing end function pretty_ffi_args(pp::PrettyPrinter, msg::Vector{Proto.Abstraction}) - flat1172 = try_flat(pp, msg, pretty_ffi_args) - if !isnothing(flat1172) - write(pp, flat1172) + flat1182 = try_flat(pp, msg, pretty_ffi_args) + if !isnothing(flat1182) + write(pp, flat1182) return nothing else - fields1169 = msg + fields1179 = msg write(pp, "(args") indent_sexp!(pp) - if !isempty(fields1169) + if !isempty(fields1179) newline(pp) - for (i1793, elem1170) in enumerate(fields1169) - i1171 = i1793 - 1 - if (i1171 > 0) + for (i1804, elem1180) in enumerate(fields1179) + i1181 = i1804 - 1 + if (i1181 > 0) newline(pp) end - pretty_abstraction(pp, elem1170) + pretty_abstraction(pp, elem1180) end end dedent!(pp) @@ -2439,28 +2470,28 @@ function pretty_ffi_args(pp::PrettyPrinter, msg::Vector{Proto.Abstraction}) end function pretty_atom(pp::PrettyPrinter, msg::Proto.Atom) - flat1179 = try_flat(pp, msg, pretty_atom) - if !isnothing(flat1179) - write(pp, flat1179) + flat1189 = try_flat(pp, msg, pretty_atom) + if !isnothing(flat1189) + write(pp, flat1189) return nothing else _dollar_dollar = msg - fields1173 = (_dollar_dollar.name, _dollar_dollar.terms,) - unwrapped_fields1174 = fields1173 + fields1183 = (_dollar_dollar.name, _dollar_dollar.terms,) + unwrapped_fields1184 = fields1183 write(pp, "(atom") indent_sexp!(pp) newline(pp) - field1175 = unwrapped_fields1174[1] - pretty_relation_id(pp, field1175) - field1176 = unwrapped_fields1174[2] - if !isempty(field1176) + field1185 = unwrapped_fields1184[1] + pretty_relation_id(pp, field1185) + field1186 = unwrapped_fields1184[2] + if !isempty(field1186) newline(pp) - for (i1794, elem1177) in enumerate(field1176) - i1178 = i1794 - 1 - if (i1178 > 0) + for (i1805, elem1187) in enumerate(field1186) + i1188 = i1805 - 1 + if (i1188 > 0) newline(pp) end - pretty_term(pp, elem1177) + pretty_term(pp, elem1187) end end dedent!(pp) @@ -2470,28 +2501,28 @@ function pretty_atom(pp::PrettyPrinter, msg::Proto.Atom) end function pretty_pragma(pp::PrettyPrinter, msg::Proto.Pragma) - flat1186 = try_flat(pp, msg, pretty_pragma) - if !isnothing(flat1186) - write(pp, flat1186) + flat1196 = try_flat(pp, msg, pretty_pragma) + if !isnothing(flat1196) + write(pp, flat1196) return nothing else _dollar_dollar = msg - fields1180 = (_dollar_dollar.name, _dollar_dollar.terms,) - unwrapped_fields1181 = fields1180 + fields1190 = (_dollar_dollar.name, _dollar_dollar.terms,) + unwrapped_fields1191 = fields1190 write(pp, "(pragma") indent_sexp!(pp) newline(pp) - field1182 = unwrapped_fields1181[1] - pretty_name(pp, field1182) - field1183 = unwrapped_fields1181[2] - if !isempty(field1183) + field1192 = unwrapped_fields1191[1] + pretty_name(pp, field1192) + field1193 = unwrapped_fields1191[2] + if !isempty(field1193) newline(pp) - for (i1795, elem1184) in enumerate(field1183) - i1185 = i1795 - 1 - if (i1185 > 0) + for (i1806, elem1194) in enumerate(field1193) + i1195 = i1806 - 1 + if (i1195 > 0) newline(pp) end - pretty_term(pp, elem1184) + pretty_term(pp, elem1194) end end dedent!(pp) @@ -2501,118 +2532,118 @@ function pretty_pragma(pp::PrettyPrinter, msg::Proto.Pragma) end function pretty_primitive(pp::PrettyPrinter, msg::Proto.Primitive) - flat1202 = try_flat(pp, msg, pretty_primitive) - if !isnothing(flat1202) - write(pp, flat1202) + flat1212 = try_flat(pp, msg, pretty_primitive) + if !isnothing(flat1212) + write(pp, flat1212) return nothing else _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_eq" - _t1796 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) + _t1807 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) else - _t1796 = nothing + _t1807 = nothing end - guard_result1201 = _t1796 - if !isnothing(guard_result1201) + guard_result1211 = _t1807 + if !isnothing(guard_result1211) pretty_eq(pp, msg) else _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_lt_monotype" - _t1797 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) + _t1808 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) else - _t1797 = nothing + _t1808 = nothing end - guard_result1200 = _t1797 - if !isnothing(guard_result1200) + guard_result1210 = _t1808 + if !isnothing(guard_result1210) pretty_lt(pp, msg) else _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_lt_eq_monotype" - _t1798 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) + _t1809 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) else - _t1798 = nothing + _t1809 = nothing end - guard_result1199 = _t1798 - if !isnothing(guard_result1199) + guard_result1209 = _t1809 + if !isnothing(guard_result1209) pretty_lt_eq(pp, msg) else _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_gt_monotype" - _t1799 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) + _t1810 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) else - _t1799 = nothing + _t1810 = nothing end - guard_result1198 = _t1799 - if !isnothing(guard_result1198) + guard_result1208 = _t1810 + if !isnothing(guard_result1208) pretty_gt(pp, msg) else _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_gt_eq_monotype" - _t1800 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) + _t1811 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) else - _t1800 = nothing + _t1811 = nothing end - guard_result1197 = _t1800 - if !isnothing(guard_result1197) + guard_result1207 = _t1811 + if !isnothing(guard_result1207) pretty_gt_eq(pp, msg) else _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_add_monotype" - _t1801 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term), _get_oneof_field(_dollar_dollar.terms[3], :term),) + _t1812 = (_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 - _t1801 = nothing + _t1812 = nothing end - guard_result1196 = _t1801 - if !isnothing(guard_result1196) + guard_result1206 = _t1812 + if !isnothing(guard_result1206) pretty_add(pp, msg) else _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_subtract_monotype" - _t1802 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term), _get_oneof_field(_dollar_dollar.terms[3], :term),) + _t1813 = (_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 - _t1802 = nothing + _t1813 = nothing end - guard_result1195 = _t1802 - if !isnothing(guard_result1195) + guard_result1205 = _t1813 + if !isnothing(guard_result1205) pretty_minus(pp, msg) else _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_multiply_monotype" - _t1803 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term), _get_oneof_field(_dollar_dollar.terms[3], :term),) + _t1814 = (_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 - _t1803 = nothing + _t1814 = nothing end - guard_result1194 = _t1803 - if !isnothing(guard_result1194) + guard_result1204 = _t1814 + if !isnothing(guard_result1204) pretty_multiply(pp, msg) else _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_divide_monotype" - _t1804 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term), _get_oneof_field(_dollar_dollar.terms[3], :term),) + _t1815 = (_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 - _t1804 = nothing + _t1815 = nothing end - guard_result1193 = _t1804 - if !isnothing(guard_result1193) + guard_result1203 = _t1815 + if !isnothing(guard_result1203) pretty_divide(pp, msg) else _dollar_dollar = msg - fields1187 = (_dollar_dollar.name, _dollar_dollar.terms,) - unwrapped_fields1188 = fields1187 + fields1197 = (_dollar_dollar.name, _dollar_dollar.terms,) + unwrapped_fields1198 = fields1197 write(pp, "(primitive") indent_sexp!(pp) newline(pp) - field1189 = unwrapped_fields1188[1] - pretty_name(pp, field1189) - field1190 = unwrapped_fields1188[2] - if !isempty(field1190) + field1199 = unwrapped_fields1198[1] + pretty_name(pp, field1199) + field1200 = unwrapped_fields1198[2] + if !isempty(field1200) newline(pp) - for (i1805, elem1191) in enumerate(field1190) - i1192 = i1805 - 1 - if (i1192 > 0) + for (i1816, elem1201) in enumerate(field1200) + i1202 = i1816 - 1 + if (i1202 > 0) newline(pp) end - pretty_rel_term(pp, elem1191) + pretty_rel_term(pp, elem1201) end end dedent!(pp) @@ -2631,27 +2662,27 @@ function pretty_primitive(pp::PrettyPrinter, msg::Proto.Primitive) end function pretty_eq(pp::PrettyPrinter, msg::Proto.Primitive) - flat1207 = try_flat(pp, msg, pretty_eq) - if !isnothing(flat1207) - write(pp, flat1207) + flat1217 = try_flat(pp, msg, pretty_eq) + if !isnothing(flat1217) + write(pp, flat1217) return nothing else _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_eq" - _t1806 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) + _t1817 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) else - _t1806 = nothing + _t1817 = nothing end - fields1203 = _t1806 - unwrapped_fields1204 = fields1203 + fields1213 = _t1817 + unwrapped_fields1214 = fields1213 write(pp, "(=") indent_sexp!(pp) newline(pp) - field1205 = unwrapped_fields1204[1] - pretty_term(pp, field1205) + field1215 = unwrapped_fields1214[1] + pretty_term(pp, field1215) newline(pp) - field1206 = unwrapped_fields1204[2] - pretty_term(pp, field1206) + field1216 = unwrapped_fields1214[2] + pretty_term(pp, field1216) dedent!(pp) write(pp, ")") end @@ -2659,27 +2690,27 @@ function pretty_eq(pp::PrettyPrinter, msg::Proto.Primitive) end function pretty_lt(pp::PrettyPrinter, msg::Proto.Primitive) - flat1212 = try_flat(pp, msg, pretty_lt) - if !isnothing(flat1212) - write(pp, flat1212) + flat1222 = try_flat(pp, msg, pretty_lt) + if !isnothing(flat1222) + write(pp, flat1222) return nothing else _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_lt_monotype" - _t1807 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) + _t1818 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) else - _t1807 = nothing + _t1818 = nothing end - fields1208 = _t1807 - unwrapped_fields1209 = fields1208 + fields1218 = _t1818 + unwrapped_fields1219 = fields1218 write(pp, "(<") indent_sexp!(pp) newline(pp) - field1210 = unwrapped_fields1209[1] - pretty_term(pp, field1210) + field1220 = unwrapped_fields1219[1] + pretty_term(pp, field1220) newline(pp) - field1211 = unwrapped_fields1209[2] - pretty_term(pp, field1211) + field1221 = unwrapped_fields1219[2] + pretty_term(pp, field1221) dedent!(pp) write(pp, ")") end @@ -2687,27 +2718,27 @@ function pretty_lt(pp::PrettyPrinter, msg::Proto.Primitive) end function pretty_lt_eq(pp::PrettyPrinter, msg::Proto.Primitive) - flat1217 = try_flat(pp, msg, pretty_lt_eq) - if !isnothing(flat1217) - write(pp, flat1217) + flat1227 = try_flat(pp, msg, pretty_lt_eq) + if !isnothing(flat1227) + write(pp, flat1227) return nothing else _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_lt_eq_monotype" - _t1808 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) + _t1819 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) else - _t1808 = nothing + _t1819 = nothing end - fields1213 = _t1808 - unwrapped_fields1214 = fields1213 + fields1223 = _t1819 + unwrapped_fields1224 = fields1223 write(pp, "(<=") indent_sexp!(pp) newline(pp) - field1215 = unwrapped_fields1214[1] - pretty_term(pp, field1215) + field1225 = unwrapped_fields1224[1] + pretty_term(pp, field1225) newline(pp) - field1216 = unwrapped_fields1214[2] - pretty_term(pp, field1216) + field1226 = unwrapped_fields1224[2] + pretty_term(pp, field1226) dedent!(pp) write(pp, ")") end @@ -2715,27 +2746,27 @@ function pretty_lt_eq(pp::PrettyPrinter, msg::Proto.Primitive) end function pretty_gt(pp::PrettyPrinter, msg::Proto.Primitive) - flat1222 = try_flat(pp, msg, pretty_gt) - if !isnothing(flat1222) - write(pp, flat1222) + flat1232 = try_flat(pp, msg, pretty_gt) + if !isnothing(flat1232) + write(pp, flat1232) return nothing else _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_gt_monotype" - _t1809 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) + _t1820 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) else - _t1809 = nothing + _t1820 = nothing end - fields1218 = _t1809 - unwrapped_fields1219 = fields1218 + fields1228 = _t1820 + unwrapped_fields1229 = fields1228 write(pp, "(>") indent_sexp!(pp) newline(pp) - field1220 = unwrapped_fields1219[1] - pretty_term(pp, field1220) + field1230 = unwrapped_fields1229[1] + pretty_term(pp, field1230) newline(pp) - field1221 = unwrapped_fields1219[2] - pretty_term(pp, field1221) + field1231 = unwrapped_fields1229[2] + pretty_term(pp, field1231) dedent!(pp) write(pp, ")") end @@ -2743,27 +2774,27 @@ function pretty_gt(pp::PrettyPrinter, msg::Proto.Primitive) end function pretty_gt_eq(pp::PrettyPrinter, msg::Proto.Primitive) - flat1227 = try_flat(pp, msg, pretty_gt_eq) - if !isnothing(flat1227) - write(pp, flat1227) + flat1237 = try_flat(pp, msg, pretty_gt_eq) + if !isnothing(flat1237) + write(pp, flat1237) return nothing else _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_gt_eq_monotype" - _t1810 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) + _t1821 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) else - _t1810 = nothing + _t1821 = nothing end - fields1223 = _t1810 - unwrapped_fields1224 = fields1223 + fields1233 = _t1821 + unwrapped_fields1234 = fields1233 write(pp, "(>=") indent_sexp!(pp) newline(pp) - field1225 = unwrapped_fields1224[1] - pretty_term(pp, field1225) + field1235 = unwrapped_fields1234[1] + pretty_term(pp, field1235) newline(pp) - field1226 = unwrapped_fields1224[2] - pretty_term(pp, field1226) + field1236 = unwrapped_fields1234[2] + pretty_term(pp, field1236) dedent!(pp) write(pp, ")") end @@ -2771,30 +2802,30 @@ function pretty_gt_eq(pp::PrettyPrinter, msg::Proto.Primitive) end function pretty_add(pp::PrettyPrinter, msg::Proto.Primitive) - flat1233 = try_flat(pp, msg, pretty_add) - if !isnothing(flat1233) - write(pp, flat1233) + flat1243 = try_flat(pp, msg, pretty_add) + if !isnothing(flat1243) + write(pp, flat1243) return nothing else _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_add_monotype" - _t1811 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term), _get_oneof_field(_dollar_dollar.terms[3], :term),) + _t1822 = (_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 - _t1811 = nothing + _t1822 = nothing end - fields1228 = _t1811 - unwrapped_fields1229 = fields1228 + fields1238 = _t1822 + unwrapped_fields1239 = fields1238 write(pp, "(+") indent_sexp!(pp) newline(pp) - field1230 = unwrapped_fields1229[1] - pretty_term(pp, field1230) + field1240 = unwrapped_fields1239[1] + pretty_term(pp, field1240) newline(pp) - field1231 = unwrapped_fields1229[2] - pretty_term(pp, field1231) + field1241 = unwrapped_fields1239[2] + pretty_term(pp, field1241) newline(pp) - field1232 = unwrapped_fields1229[3] - pretty_term(pp, field1232) + field1242 = unwrapped_fields1239[3] + pretty_term(pp, field1242) dedent!(pp) write(pp, ")") end @@ -2802,30 +2833,30 @@ function pretty_add(pp::PrettyPrinter, msg::Proto.Primitive) end function pretty_minus(pp::PrettyPrinter, msg::Proto.Primitive) - flat1239 = try_flat(pp, msg, pretty_minus) - if !isnothing(flat1239) - write(pp, flat1239) + flat1249 = try_flat(pp, msg, pretty_minus) + if !isnothing(flat1249) + write(pp, flat1249) return nothing else _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_subtract_monotype" - _t1812 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term), _get_oneof_field(_dollar_dollar.terms[3], :term),) + _t1823 = (_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 - _t1812 = nothing + _t1823 = nothing end - fields1234 = _t1812 - unwrapped_fields1235 = fields1234 + fields1244 = _t1823 + unwrapped_fields1245 = fields1244 write(pp, "(-") indent_sexp!(pp) newline(pp) - field1236 = unwrapped_fields1235[1] - pretty_term(pp, field1236) + field1246 = unwrapped_fields1245[1] + pretty_term(pp, field1246) newline(pp) - field1237 = unwrapped_fields1235[2] - pretty_term(pp, field1237) + field1247 = unwrapped_fields1245[2] + pretty_term(pp, field1247) newline(pp) - field1238 = unwrapped_fields1235[3] - pretty_term(pp, field1238) + field1248 = unwrapped_fields1245[3] + pretty_term(pp, field1248) dedent!(pp) write(pp, ")") end @@ -2833,30 +2864,30 @@ function pretty_minus(pp::PrettyPrinter, msg::Proto.Primitive) end function pretty_multiply(pp::PrettyPrinter, msg::Proto.Primitive) - flat1245 = try_flat(pp, msg, pretty_multiply) - if !isnothing(flat1245) - write(pp, flat1245) + flat1255 = try_flat(pp, msg, pretty_multiply) + if !isnothing(flat1255) + write(pp, flat1255) return nothing else _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_multiply_monotype" - _t1813 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term), _get_oneof_field(_dollar_dollar.terms[3], :term),) + _t1824 = (_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 - _t1813 = nothing + _t1824 = nothing end - fields1240 = _t1813 - unwrapped_fields1241 = fields1240 + fields1250 = _t1824 + unwrapped_fields1251 = fields1250 write(pp, "(*") indent_sexp!(pp) newline(pp) - field1242 = unwrapped_fields1241[1] - pretty_term(pp, field1242) + field1252 = unwrapped_fields1251[1] + pretty_term(pp, field1252) newline(pp) - field1243 = unwrapped_fields1241[2] - pretty_term(pp, field1243) + field1253 = unwrapped_fields1251[2] + pretty_term(pp, field1253) newline(pp) - field1244 = unwrapped_fields1241[3] - pretty_term(pp, field1244) + field1254 = unwrapped_fields1251[3] + pretty_term(pp, field1254) dedent!(pp) write(pp, ")") end @@ -2864,30 +2895,30 @@ function pretty_multiply(pp::PrettyPrinter, msg::Proto.Primitive) end function pretty_divide(pp::PrettyPrinter, msg::Proto.Primitive) - flat1251 = try_flat(pp, msg, pretty_divide) - if !isnothing(flat1251) - write(pp, flat1251) + flat1261 = try_flat(pp, msg, pretty_divide) + if !isnothing(flat1261) + write(pp, flat1261) return nothing else _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_divide_monotype" - _t1814 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term), _get_oneof_field(_dollar_dollar.terms[3], :term),) + _t1825 = (_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 - _t1814 = nothing + _t1825 = nothing end - fields1246 = _t1814 - unwrapped_fields1247 = fields1246 + fields1256 = _t1825 + unwrapped_fields1257 = fields1256 write(pp, "(/") indent_sexp!(pp) newline(pp) - field1248 = unwrapped_fields1247[1] - pretty_term(pp, field1248) + field1258 = unwrapped_fields1257[1] + pretty_term(pp, field1258) newline(pp) - field1249 = unwrapped_fields1247[2] - pretty_term(pp, field1249) + field1259 = unwrapped_fields1257[2] + pretty_term(pp, field1259) newline(pp) - field1250 = unwrapped_fields1247[3] - pretty_term(pp, field1250) + field1260 = unwrapped_fields1257[3] + pretty_term(pp, field1260) dedent!(pp) write(pp, ")") end @@ -2895,32 +2926,32 @@ function pretty_divide(pp::PrettyPrinter, msg::Proto.Primitive) end function pretty_rel_term(pp::PrettyPrinter, msg::Proto.RelTerm) - flat1256 = try_flat(pp, msg, pretty_rel_term) - if !isnothing(flat1256) - write(pp, flat1256) + flat1266 = try_flat(pp, msg, pretty_rel_term) + if !isnothing(flat1266) + write(pp, flat1266) return nothing else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("specialized_value")) - _t1815 = _get_oneof_field(_dollar_dollar, :specialized_value) + _t1826 = _get_oneof_field(_dollar_dollar, :specialized_value) else - _t1815 = nothing + _t1826 = nothing end - deconstruct_result1254 = _t1815 - if !isnothing(deconstruct_result1254) - unwrapped1255 = deconstruct_result1254 - pretty_specialized_value(pp, unwrapped1255) + deconstruct_result1264 = _t1826 + if !isnothing(deconstruct_result1264) + unwrapped1265 = deconstruct_result1264 + pretty_specialized_value(pp, unwrapped1265) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("term")) - _t1816 = _get_oneof_field(_dollar_dollar, :term) + _t1827 = _get_oneof_field(_dollar_dollar, :term) else - _t1816 = nothing + _t1827 = nothing end - deconstruct_result1252 = _t1816 - if !isnothing(deconstruct_result1252) - unwrapped1253 = deconstruct_result1252 - pretty_term(pp, unwrapped1253) + deconstruct_result1262 = _t1827 + if !isnothing(deconstruct_result1262) + unwrapped1263 = deconstruct_result1262 + pretty_term(pp, unwrapped1263) else throw(ParseError("No matching rule for rel_term")) end @@ -2930,41 +2961,41 @@ function pretty_rel_term(pp::PrettyPrinter, msg::Proto.RelTerm) end function pretty_specialized_value(pp::PrettyPrinter, msg::Proto.Value) - flat1258 = try_flat(pp, msg, pretty_specialized_value) - if !isnothing(flat1258) - write(pp, flat1258) + flat1268 = try_flat(pp, msg, pretty_specialized_value) + if !isnothing(flat1268) + write(pp, flat1268) return nothing else - fields1257 = msg + fields1267 = msg write(pp, "#") - pretty_raw_value(pp, fields1257) + pretty_raw_value(pp, fields1267) end return nothing end function pretty_rel_atom(pp::PrettyPrinter, msg::Proto.RelAtom) - flat1265 = try_flat(pp, msg, pretty_rel_atom) - if !isnothing(flat1265) - write(pp, flat1265) + flat1275 = try_flat(pp, msg, pretty_rel_atom) + if !isnothing(flat1275) + write(pp, flat1275) return nothing else _dollar_dollar = msg - fields1259 = (_dollar_dollar.name, _dollar_dollar.terms,) - unwrapped_fields1260 = fields1259 + fields1269 = (_dollar_dollar.name, _dollar_dollar.terms,) + unwrapped_fields1270 = fields1269 write(pp, "(relatom") indent_sexp!(pp) newline(pp) - field1261 = unwrapped_fields1260[1] - pretty_name(pp, field1261) - field1262 = unwrapped_fields1260[2] - if !isempty(field1262) + field1271 = unwrapped_fields1270[1] + pretty_name(pp, field1271) + field1272 = unwrapped_fields1270[2] + if !isempty(field1272) newline(pp) - for (i1817, elem1263) in enumerate(field1262) - i1264 = i1817 - 1 - if (i1264 > 0) + for (i1828, elem1273) in enumerate(field1272) + i1274 = i1828 - 1 + if (i1274 > 0) newline(pp) end - pretty_rel_term(pp, elem1263) + pretty_rel_term(pp, elem1273) end end dedent!(pp) @@ -2974,22 +3005,22 @@ function pretty_rel_atom(pp::PrettyPrinter, msg::Proto.RelAtom) end function pretty_cast(pp::PrettyPrinter, msg::Proto.Cast) - flat1270 = try_flat(pp, msg, pretty_cast) - if !isnothing(flat1270) - write(pp, flat1270) + flat1280 = try_flat(pp, msg, pretty_cast) + if !isnothing(flat1280) + write(pp, flat1280) return nothing else _dollar_dollar = msg - fields1266 = (_dollar_dollar.input, _dollar_dollar.result,) - unwrapped_fields1267 = fields1266 + fields1276 = (_dollar_dollar.input, _dollar_dollar.result,) + unwrapped_fields1277 = fields1276 write(pp, "(cast") indent_sexp!(pp) newline(pp) - field1268 = unwrapped_fields1267[1] - pretty_term(pp, field1268) + field1278 = unwrapped_fields1277[1] + pretty_term(pp, field1278) newline(pp) - field1269 = unwrapped_fields1267[2] - pretty_term(pp, field1269) + field1279 = unwrapped_fields1277[2] + pretty_term(pp, field1279) dedent!(pp) write(pp, ")") end @@ -2997,22 +3028,22 @@ function pretty_cast(pp::PrettyPrinter, msg::Proto.Cast) end function pretty_attrs(pp::PrettyPrinter, msg::Vector{Proto.Attribute}) - flat1274 = try_flat(pp, msg, pretty_attrs) - if !isnothing(flat1274) - write(pp, flat1274) + flat1284 = try_flat(pp, msg, pretty_attrs) + if !isnothing(flat1284) + write(pp, flat1284) return nothing else - fields1271 = msg + fields1281 = msg write(pp, "(attrs") indent_sexp!(pp) - if !isempty(fields1271) + if !isempty(fields1281) newline(pp) - for (i1818, elem1272) in enumerate(fields1271) - i1273 = i1818 - 1 - if (i1273 > 0) + for (i1829, elem1282) in enumerate(fields1281) + i1283 = i1829 - 1 + if (i1283 > 0) newline(pp) end - pretty_attribute(pp, elem1272) + pretty_attribute(pp, elem1282) end end dedent!(pp) @@ -3022,28 +3053,28 @@ function pretty_attrs(pp::PrettyPrinter, msg::Vector{Proto.Attribute}) end function pretty_attribute(pp::PrettyPrinter, msg::Proto.Attribute) - flat1281 = try_flat(pp, msg, pretty_attribute) - if !isnothing(flat1281) - write(pp, flat1281) + flat1291 = try_flat(pp, msg, pretty_attribute) + if !isnothing(flat1291) + write(pp, flat1291) return nothing else _dollar_dollar = msg - fields1275 = (_dollar_dollar.name, _dollar_dollar.args,) - unwrapped_fields1276 = fields1275 + fields1285 = (_dollar_dollar.name, _dollar_dollar.args,) + unwrapped_fields1286 = fields1285 write(pp, "(attribute") indent_sexp!(pp) newline(pp) - field1277 = unwrapped_fields1276[1] - pretty_name(pp, field1277) - field1278 = unwrapped_fields1276[2] - if !isempty(field1278) + field1287 = unwrapped_fields1286[1] + pretty_name(pp, field1287) + field1288 = unwrapped_fields1286[2] + if !isempty(field1288) newline(pp) - for (i1819, elem1279) in enumerate(field1278) - i1280 = i1819 - 1 - if (i1280 > 0) + for (i1830, elem1289) in enumerate(field1288) + i1290 = i1830 - 1 + if (i1290 > 0) newline(pp) end - pretty_raw_value(pp, elem1279) + pretty_raw_value(pp, elem1289) end end dedent!(pp) @@ -3053,40 +3084,40 @@ function pretty_attribute(pp::PrettyPrinter, msg::Proto.Attribute) end function pretty_algorithm(pp::PrettyPrinter, msg::Proto.Algorithm) - flat1290 = try_flat(pp, msg, pretty_algorithm) - if !isnothing(flat1290) - write(pp, flat1290) + flat1300 = try_flat(pp, msg, pretty_algorithm) + if !isnothing(flat1300) + write(pp, flat1300) return nothing else _dollar_dollar = msg if !isempty(_dollar_dollar.attrs) - _t1820 = _dollar_dollar.attrs + _t1831 = _dollar_dollar.attrs else - _t1820 = nothing + _t1831 = nothing end - fields1282 = (_dollar_dollar.var"#global", _dollar_dollar.body, _t1820,) - unwrapped_fields1283 = fields1282 + fields1292 = (_dollar_dollar.var"#global", _dollar_dollar.body, _t1831,) + unwrapped_fields1293 = fields1292 write(pp, "(algorithm") indent_sexp!(pp) - field1284 = unwrapped_fields1283[1] - if !isempty(field1284) + field1294 = unwrapped_fields1293[1] + if !isempty(field1294) newline(pp) - for (i1821, elem1285) in enumerate(field1284) - i1286 = i1821 - 1 - if (i1286 > 0) + for (i1832, elem1295) in enumerate(field1294) + i1296 = i1832 - 1 + if (i1296 > 0) newline(pp) end - pretty_relation_id(pp, elem1285) + pretty_relation_id(pp, elem1295) end end newline(pp) - field1287 = unwrapped_fields1283[2] - pretty_script(pp, field1287) - field1288 = unwrapped_fields1283[3] - if !isnothing(field1288) + field1297 = unwrapped_fields1293[2] + pretty_script(pp, field1297) + field1298 = unwrapped_fields1293[3] + if !isnothing(field1298) newline(pp) - opt_val1289 = field1288 - pretty_attrs(pp, opt_val1289) + opt_val1299 = field1298 + pretty_attrs(pp, opt_val1299) end dedent!(pp) write(pp, ")") @@ -3095,24 +3126,24 @@ function pretty_algorithm(pp::PrettyPrinter, msg::Proto.Algorithm) end function pretty_script(pp::PrettyPrinter, msg::Proto.Script) - flat1295 = try_flat(pp, msg, pretty_script) - if !isnothing(flat1295) - write(pp, flat1295) + flat1305 = try_flat(pp, msg, pretty_script) + if !isnothing(flat1305) + write(pp, flat1305) return nothing else _dollar_dollar = msg - fields1291 = _dollar_dollar.constructs - unwrapped_fields1292 = fields1291 + fields1301 = _dollar_dollar.constructs + unwrapped_fields1302 = fields1301 write(pp, "(script") indent_sexp!(pp) - if !isempty(unwrapped_fields1292) + if !isempty(unwrapped_fields1302) newline(pp) - for (i1822, elem1293) in enumerate(unwrapped_fields1292) - i1294 = i1822 - 1 - if (i1294 > 0) + for (i1833, elem1303) in enumerate(unwrapped_fields1302) + i1304 = i1833 - 1 + if (i1304 > 0) newline(pp) end - pretty_construct(pp, elem1293) + pretty_construct(pp, elem1303) end end dedent!(pp) @@ -3122,32 +3153,32 @@ function pretty_script(pp::PrettyPrinter, msg::Proto.Script) end function pretty_construct(pp::PrettyPrinter, msg::Proto.Construct) - flat1300 = try_flat(pp, msg, pretty_construct) - if !isnothing(flat1300) - write(pp, flat1300) + flat1310 = try_flat(pp, msg, pretty_construct) + if !isnothing(flat1310) + write(pp, flat1310) return nothing else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("loop")) - _t1823 = _get_oneof_field(_dollar_dollar, :loop) + _t1834 = _get_oneof_field(_dollar_dollar, :loop) else - _t1823 = nothing + _t1834 = nothing end - deconstruct_result1298 = _t1823 - if !isnothing(deconstruct_result1298) - unwrapped1299 = deconstruct_result1298 - pretty_loop(pp, unwrapped1299) + deconstruct_result1308 = _t1834 + if !isnothing(deconstruct_result1308) + unwrapped1309 = deconstruct_result1308 + pretty_loop(pp, unwrapped1309) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("instruction")) - _t1824 = _get_oneof_field(_dollar_dollar, :instruction) + _t1835 = _get_oneof_field(_dollar_dollar, :instruction) else - _t1824 = nothing + _t1835 = nothing end - deconstruct_result1296 = _t1824 - if !isnothing(deconstruct_result1296) - unwrapped1297 = deconstruct_result1296 - pretty_instruction(pp, unwrapped1297) + deconstruct_result1306 = _t1835 + if !isnothing(deconstruct_result1306) + unwrapped1307 = deconstruct_result1306 + pretty_instruction(pp, unwrapped1307) else throw(ParseError("No matching rule for construct")) end @@ -3157,32 +3188,32 @@ function pretty_construct(pp::PrettyPrinter, msg::Proto.Construct) end function pretty_loop(pp::PrettyPrinter, msg::Proto.Loop) - flat1307 = try_flat(pp, msg, pretty_loop) - if !isnothing(flat1307) - write(pp, flat1307) + flat1317 = try_flat(pp, msg, pretty_loop) + if !isnothing(flat1317) + write(pp, flat1317) return nothing else _dollar_dollar = msg if !isempty(_dollar_dollar.attrs) - _t1825 = _dollar_dollar.attrs + _t1836 = _dollar_dollar.attrs else - _t1825 = nothing + _t1836 = nothing end - fields1301 = (_dollar_dollar.init, _dollar_dollar.body, _t1825,) - unwrapped_fields1302 = fields1301 + fields1311 = (_dollar_dollar.init, _dollar_dollar.body, _t1836,) + unwrapped_fields1312 = fields1311 write(pp, "(loop") indent_sexp!(pp) newline(pp) - field1303 = unwrapped_fields1302[1] - pretty_init(pp, field1303) + field1313 = unwrapped_fields1312[1] + pretty_init(pp, field1313) newline(pp) - field1304 = unwrapped_fields1302[2] - pretty_script(pp, field1304) - field1305 = unwrapped_fields1302[3] - if !isnothing(field1305) + field1314 = unwrapped_fields1312[2] + pretty_script(pp, field1314) + field1315 = unwrapped_fields1312[3] + if !isnothing(field1315) newline(pp) - opt_val1306 = field1305 - pretty_attrs(pp, opt_val1306) + opt_val1316 = field1315 + pretty_attrs(pp, opt_val1316) end dedent!(pp) write(pp, ")") @@ -3191,22 +3222,22 @@ function pretty_loop(pp::PrettyPrinter, msg::Proto.Loop) end function pretty_init(pp::PrettyPrinter, msg::Vector{Proto.Instruction}) - flat1311 = try_flat(pp, msg, pretty_init) - if !isnothing(flat1311) - write(pp, flat1311) + flat1321 = try_flat(pp, msg, pretty_init) + if !isnothing(flat1321) + write(pp, flat1321) return nothing else - fields1308 = msg + fields1318 = msg write(pp, "(init") indent_sexp!(pp) - if !isempty(fields1308) + if !isempty(fields1318) newline(pp) - for (i1826, elem1309) in enumerate(fields1308) - i1310 = i1826 - 1 - if (i1310 > 0) + for (i1837, elem1319) in enumerate(fields1318) + i1320 = i1837 - 1 + if (i1320 > 0) newline(pp) end - pretty_instruction(pp, elem1309) + pretty_instruction(pp, elem1319) end end dedent!(pp) @@ -3216,65 +3247,65 @@ function pretty_init(pp::PrettyPrinter, msg::Vector{Proto.Instruction}) end function pretty_instruction(pp::PrettyPrinter, msg::Proto.Instruction) - flat1322 = try_flat(pp, msg, pretty_instruction) - if !isnothing(flat1322) - write(pp, flat1322) + flat1332 = try_flat(pp, msg, pretty_instruction) + if !isnothing(flat1332) + write(pp, flat1332) return nothing else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("assign")) - _t1827 = _get_oneof_field(_dollar_dollar, :assign) + _t1838 = _get_oneof_field(_dollar_dollar, :assign) else - _t1827 = nothing + _t1838 = nothing end - deconstruct_result1320 = _t1827 - if !isnothing(deconstruct_result1320) - unwrapped1321 = deconstruct_result1320 - pretty_assign(pp, unwrapped1321) + deconstruct_result1330 = _t1838 + if !isnothing(deconstruct_result1330) + unwrapped1331 = deconstruct_result1330 + pretty_assign(pp, unwrapped1331) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("upsert")) - _t1828 = _get_oneof_field(_dollar_dollar, :upsert) + _t1839 = _get_oneof_field(_dollar_dollar, :upsert) else - _t1828 = nothing + _t1839 = nothing end - deconstruct_result1318 = _t1828 - if !isnothing(deconstruct_result1318) - unwrapped1319 = deconstruct_result1318 - pretty_upsert(pp, unwrapped1319) + deconstruct_result1328 = _t1839 + if !isnothing(deconstruct_result1328) + unwrapped1329 = deconstruct_result1328 + pretty_upsert(pp, unwrapped1329) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("#break")) - _t1829 = _get_oneof_field(_dollar_dollar, :var"#break") + _t1840 = _get_oneof_field(_dollar_dollar, :var"#break") else - _t1829 = nothing + _t1840 = nothing end - deconstruct_result1316 = _t1829 - if !isnothing(deconstruct_result1316) - unwrapped1317 = deconstruct_result1316 - pretty_break(pp, unwrapped1317) + deconstruct_result1326 = _t1840 + if !isnothing(deconstruct_result1326) + unwrapped1327 = deconstruct_result1326 + pretty_break(pp, unwrapped1327) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("monoid_def")) - _t1830 = _get_oneof_field(_dollar_dollar, :monoid_def) + _t1841 = _get_oneof_field(_dollar_dollar, :monoid_def) else - _t1830 = nothing + _t1841 = nothing end - deconstruct_result1314 = _t1830 - if !isnothing(deconstruct_result1314) - unwrapped1315 = deconstruct_result1314 - pretty_monoid_def(pp, unwrapped1315) + deconstruct_result1324 = _t1841 + if !isnothing(deconstruct_result1324) + unwrapped1325 = deconstruct_result1324 + pretty_monoid_def(pp, unwrapped1325) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("monus_def")) - _t1831 = _get_oneof_field(_dollar_dollar, :monus_def) + _t1842 = _get_oneof_field(_dollar_dollar, :monus_def) else - _t1831 = nothing + _t1842 = nothing end - deconstruct_result1312 = _t1831 - if !isnothing(deconstruct_result1312) - unwrapped1313 = deconstruct_result1312 - pretty_monus_def(pp, unwrapped1313) + deconstruct_result1322 = _t1842 + if !isnothing(deconstruct_result1322) + unwrapped1323 = deconstruct_result1322 + pretty_monus_def(pp, unwrapped1323) else throw(ParseError("No matching rule for instruction")) end @@ -3287,32 +3318,32 @@ function pretty_instruction(pp::PrettyPrinter, msg::Proto.Instruction) end function pretty_assign(pp::PrettyPrinter, msg::Proto.Assign) - flat1329 = try_flat(pp, msg, pretty_assign) - if !isnothing(flat1329) - write(pp, flat1329) + flat1339 = try_flat(pp, msg, pretty_assign) + if !isnothing(flat1339) + write(pp, flat1339) return nothing else _dollar_dollar = msg if !isempty(_dollar_dollar.attrs) - _t1832 = _dollar_dollar.attrs + _t1843 = _dollar_dollar.attrs else - _t1832 = nothing + _t1843 = nothing end - fields1323 = (_dollar_dollar.name, _dollar_dollar.body, _t1832,) - unwrapped_fields1324 = fields1323 + fields1333 = (_dollar_dollar.name, _dollar_dollar.body, _t1843,) + unwrapped_fields1334 = fields1333 write(pp, "(assign") indent_sexp!(pp) newline(pp) - field1325 = unwrapped_fields1324[1] - pretty_relation_id(pp, field1325) + field1335 = unwrapped_fields1334[1] + pretty_relation_id(pp, field1335) newline(pp) - field1326 = unwrapped_fields1324[2] - pretty_abstraction(pp, field1326) - field1327 = unwrapped_fields1324[3] - if !isnothing(field1327) + field1336 = unwrapped_fields1334[2] + pretty_abstraction(pp, field1336) + field1337 = unwrapped_fields1334[3] + if !isnothing(field1337) newline(pp) - opt_val1328 = field1327 - pretty_attrs(pp, opt_val1328) + opt_val1338 = field1337 + pretty_attrs(pp, opt_val1338) end dedent!(pp) write(pp, ")") @@ -3321,32 +3352,32 @@ function pretty_assign(pp::PrettyPrinter, msg::Proto.Assign) end function pretty_upsert(pp::PrettyPrinter, msg::Proto.Upsert) - flat1336 = try_flat(pp, msg, pretty_upsert) - if !isnothing(flat1336) - write(pp, flat1336) + flat1346 = try_flat(pp, msg, pretty_upsert) + if !isnothing(flat1346) + write(pp, flat1346) return nothing else _dollar_dollar = msg if !isempty(_dollar_dollar.attrs) - _t1833 = _dollar_dollar.attrs + _t1844 = _dollar_dollar.attrs else - _t1833 = nothing + _t1844 = nothing end - fields1330 = (_dollar_dollar.name, (_dollar_dollar.body, _dollar_dollar.value_arity,), _t1833,) - unwrapped_fields1331 = fields1330 + fields1340 = (_dollar_dollar.name, (_dollar_dollar.body, _dollar_dollar.value_arity,), _t1844,) + unwrapped_fields1341 = fields1340 write(pp, "(upsert") indent_sexp!(pp) newline(pp) - field1332 = unwrapped_fields1331[1] - pretty_relation_id(pp, field1332) + field1342 = unwrapped_fields1341[1] + pretty_relation_id(pp, field1342) newline(pp) - field1333 = unwrapped_fields1331[2] - pretty_abstraction_with_arity(pp, field1333) - field1334 = unwrapped_fields1331[3] - if !isnothing(field1334) + field1343 = unwrapped_fields1341[2] + pretty_abstraction_with_arity(pp, field1343) + field1344 = unwrapped_fields1341[3] + if !isnothing(field1344) newline(pp) - opt_val1335 = field1334 - pretty_attrs(pp, opt_val1335) + opt_val1345 = field1344 + pretty_attrs(pp, opt_val1345) end dedent!(pp) write(pp, ")") @@ -3355,22 +3386,22 @@ function pretty_upsert(pp::PrettyPrinter, msg::Proto.Upsert) end function pretty_abstraction_with_arity(pp::PrettyPrinter, msg::Tuple{Proto.Abstraction, Int64}) - flat1341 = try_flat(pp, msg, pretty_abstraction_with_arity) - if !isnothing(flat1341) - write(pp, flat1341) + flat1351 = try_flat(pp, msg, pretty_abstraction_with_arity) + if !isnothing(flat1351) + write(pp, flat1351) return nothing else _dollar_dollar = msg - _t1834 = deconstruct_bindings_with_arity(pp, _dollar_dollar[1], _dollar_dollar[2]) - fields1337 = (_t1834, _dollar_dollar[1].value,) - unwrapped_fields1338 = fields1337 + _t1845 = deconstruct_bindings_with_arity(pp, _dollar_dollar[1], _dollar_dollar[2]) + fields1347 = (_t1845, _dollar_dollar[1].value,) + unwrapped_fields1348 = fields1347 write(pp, "(") indent!(pp) - field1339 = unwrapped_fields1338[1] - pretty_bindings(pp, field1339) + field1349 = unwrapped_fields1348[1] + pretty_bindings(pp, field1349) newline(pp) - field1340 = unwrapped_fields1338[2] - pretty_formula(pp, field1340) + field1350 = unwrapped_fields1348[2] + pretty_formula(pp, field1350) dedent!(pp) write(pp, ")") end @@ -3378,32 +3409,32 @@ function pretty_abstraction_with_arity(pp::PrettyPrinter, msg::Tuple{Proto.Abstr end function pretty_break(pp::PrettyPrinter, msg::Proto.Break) - flat1348 = try_flat(pp, msg, pretty_break) - if !isnothing(flat1348) - write(pp, flat1348) + flat1358 = try_flat(pp, msg, pretty_break) + if !isnothing(flat1358) + write(pp, flat1358) return nothing else _dollar_dollar = msg if !isempty(_dollar_dollar.attrs) - _t1835 = _dollar_dollar.attrs + _t1846 = _dollar_dollar.attrs else - _t1835 = nothing + _t1846 = nothing end - fields1342 = (_dollar_dollar.name, _dollar_dollar.body, _t1835,) - unwrapped_fields1343 = fields1342 + fields1352 = (_dollar_dollar.name, _dollar_dollar.body, _t1846,) + unwrapped_fields1353 = fields1352 write(pp, "(break") indent_sexp!(pp) newline(pp) - field1344 = unwrapped_fields1343[1] - pretty_relation_id(pp, field1344) + field1354 = unwrapped_fields1353[1] + pretty_relation_id(pp, field1354) newline(pp) - field1345 = unwrapped_fields1343[2] - pretty_abstraction(pp, field1345) - field1346 = unwrapped_fields1343[3] - if !isnothing(field1346) + field1355 = unwrapped_fields1353[2] + pretty_abstraction(pp, field1355) + field1356 = unwrapped_fields1353[3] + if !isnothing(field1356) newline(pp) - opt_val1347 = field1346 - pretty_attrs(pp, opt_val1347) + opt_val1357 = field1356 + pretty_attrs(pp, opt_val1357) end dedent!(pp) write(pp, ")") @@ -3412,35 +3443,35 @@ function pretty_break(pp::PrettyPrinter, msg::Proto.Break) end function pretty_monoid_def(pp::PrettyPrinter, msg::Proto.MonoidDef) - flat1356 = try_flat(pp, msg, pretty_monoid_def) - if !isnothing(flat1356) - write(pp, flat1356) + flat1366 = try_flat(pp, msg, pretty_monoid_def) + if !isnothing(flat1366) + write(pp, flat1366) return nothing else _dollar_dollar = msg if !isempty(_dollar_dollar.attrs) - _t1836 = _dollar_dollar.attrs + _t1847 = _dollar_dollar.attrs else - _t1836 = nothing + _t1847 = nothing end - fields1349 = (_dollar_dollar.monoid, _dollar_dollar.name, (_dollar_dollar.body, _dollar_dollar.value_arity,), _t1836,) - unwrapped_fields1350 = fields1349 + fields1359 = (_dollar_dollar.monoid, _dollar_dollar.name, (_dollar_dollar.body, _dollar_dollar.value_arity,), _t1847,) + unwrapped_fields1360 = fields1359 write(pp, "(monoid") indent_sexp!(pp) newline(pp) - field1351 = unwrapped_fields1350[1] - pretty_monoid(pp, field1351) + field1361 = unwrapped_fields1360[1] + pretty_monoid(pp, field1361) newline(pp) - field1352 = unwrapped_fields1350[2] - pretty_relation_id(pp, field1352) + field1362 = unwrapped_fields1360[2] + pretty_relation_id(pp, field1362) newline(pp) - field1353 = unwrapped_fields1350[3] - pretty_abstraction_with_arity(pp, field1353) - field1354 = unwrapped_fields1350[4] - if !isnothing(field1354) + field1363 = unwrapped_fields1360[3] + pretty_abstraction_with_arity(pp, field1363) + field1364 = unwrapped_fields1360[4] + if !isnothing(field1364) newline(pp) - opt_val1355 = field1354 - pretty_attrs(pp, opt_val1355) + opt_val1365 = field1364 + pretty_attrs(pp, opt_val1365) end dedent!(pp) write(pp, ")") @@ -3449,54 +3480,54 @@ function pretty_monoid_def(pp::PrettyPrinter, msg::Proto.MonoidDef) end function pretty_monoid(pp::PrettyPrinter, msg::Proto.Monoid) - flat1365 = try_flat(pp, msg, pretty_monoid) - if !isnothing(flat1365) - write(pp, flat1365) + flat1375 = try_flat(pp, msg, pretty_monoid) + if !isnothing(flat1375) + write(pp, flat1375) return nothing else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("or_monoid")) - _t1837 = _get_oneof_field(_dollar_dollar, :or_monoid) + _t1848 = _get_oneof_field(_dollar_dollar, :or_monoid) else - _t1837 = nothing + _t1848 = nothing end - deconstruct_result1363 = _t1837 - if !isnothing(deconstruct_result1363) - unwrapped1364 = deconstruct_result1363 - pretty_or_monoid(pp, unwrapped1364) + deconstruct_result1373 = _t1848 + if !isnothing(deconstruct_result1373) + unwrapped1374 = deconstruct_result1373 + pretty_or_monoid(pp, unwrapped1374) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("min_monoid")) - _t1838 = _get_oneof_field(_dollar_dollar, :min_monoid) + _t1849 = _get_oneof_field(_dollar_dollar, :min_monoid) else - _t1838 = nothing + _t1849 = nothing end - deconstruct_result1361 = _t1838 - if !isnothing(deconstruct_result1361) - unwrapped1362 = deconstruct_result1361 - pretty_min_monoid(pp, unwrapped1362) + deconstruct_result1371 = _t1849 + if !isnothing(deconstruct_result1371) + unwrapped1372 = deconstruct_result1371 + pretty_min_monoid(pp, unwrapped1372) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("max_monoid")) - _t1839 = _get_oneof_field(_dollar_dollar, :max_monoid) + _t1850 = _get_oneof_field(_dollar_dollar, :max_monoid) else - _t1839 = nothing + _t1850 = nothing end - deconstruct_result1359 = _t1839 - if !isnothing(deconstruct_result1359) - unwrapped1360 = deconstruct_result1359 - pretty_max_monoid(pp, unwrapped1360) + deconstruct_result1369 = _t1850 + if !isnothing(deconstruct_result1369) + unwrapped1370 = deconstruct_result1369 + pretty_max_monoid(pp, unwrapped1370) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("sum_monoid")) - _t1840 = _get_oneof_field(_dollar_dollar, :sum_monoid) + _t1851 = _get_oneof_field(_dollar_dollar, :sum_monoid) else - _t1840 = nothing + _t1851 = nothing end - deconstruct_result1357 = _t1840 - if !isnothing(deconstruct_result1357) - unwrapped1358 = deconstruct_result1357 - pretty_sum_monoid(pp, unwrapped1358) + deconstruct_result1367 = _t1851 + if !isnothing(deconstruct_result1367) + unwrapped1368 = deconstruct_result1367 + pretty_sum_monoid(pp, unwrapped1368) else throw(ParseError("No matching rule for monoid")) end @@ -3508,24 +3539,24 @@ function pretty_monoid(pp::PrettyPrinter, msg::Proto.Monoid) end function pretty_or_monoid(pp::PrettyPrinter, msg::Proto.OrMonoid) - fields1366 = msg + fields1376 = msg write(pp, "(or)") return nothing end function pretty_min_monoid(pp::PrettyPrinter, msg::Proto.MinMonoid) - flat1369 = try_flat(pp, msg, pretty_min_monoid) - if !isnothing(flat1369) - write(pp, flat1369) + flat1379 = try_flat(pp, msg, pretty_min_monoid) + if !isnothing(flat1379) + write(pp, flat1379) return nothing else _dollar_dollar = msg - fields1367 = _dollar_dollar.var"#type" - unwrapped_fields1368 = fields1367 + fields1377 = _dollar_dollar.var"#type" + unwrapped_fields1378 = fields1377 write(pp, "(min") indent_sexp!(pp) newline(pp) - pretty_type(pp, unwrapped_fields1368) + pretty_type(pp, unwrapped_fields1378) dedent!(pp) write(pp, ")") end @@ -3533,18 +3564,18 @@ function pretty_min_monoid(pp::PrettyPrinter, msg::Proto.MinMonoid) end function pretty_max_monoid(pp::PrettyPrinter, msg::Proto.MaxMonoid) - flat1372 = try_flat(pp, msg, pretty_max_monoid) - if !isnothing(flat1372) - write(pp, flat1372) + flat1382 = try_flat(pp, msg, pretty_max_monoid) + if !isnothing(flat1382) + write(pp, flat1382) return nothing else _dollar_dollar = msg - fields1370 = _dollar_dollar.var"#type" - unwrapped_fields1371 = fields1370 + fields1380 = _dollar_dollar.var"#type" + unwrapped_fields1381 = fields1380 write(pp, "(max") indent_sexp!(pp) newline(pp) - pretty_type(pp, unwrapped_fields1371) + pretty_type(pp, unwrapped_fields1381) dedent!(pp) write(pp, ")") end @@ -3552,18 +3583,18 @@ function pretty_max_monoid(pp::PrettyPrinter, msg::Proto.MaxMonoid) end function pretty_sum_monoid(pp::PrettyPrinter, msg::Proto.SumMonoid) - flat1375 = try_flat(pp, msg, pretty_sum_monoid) - if !isnothing(flat1375) - write(pp, flat1375) + flat1385 = try_flat(pp, msg, pretty_sum_monoid) + if !isnothing(flat1385) + write(pp, flat1385) return nothing else _dollar_dollar = msg - fields1373 = _dollar_dollar.var"#type" - unwrapped_fields1374 = fields1373 + fields1383 = _dollar_dollar.var"#type" + unwrapped_fields1384 = fields1383 write(pp, "(sum") indent_sexp!(pp) newline(pp) - pretty_type(pp, unwrapped_fields1374) + pretty_type(pp, unwrapped_fields1384) dedent!(pp) write(pp, ")") end @@ -3571,35 +3602,35 @@ function pretty_sum_monoid(pp::PrettyPrinter, msg::Proto.SumMonoid) end function pretty_monus_def(pp::PrettyPrinter, msg::Proto.MonusDef) - flat1383 = try_flat(pp, msg, pretty_monus_def) - if !isnothing(flat1383) - write(pp, flat1383) + flat1393 = try_flat(pp, msg, pretty_monus_def) + if !isnothing(flat1393) + write(pp, flat1393) return nothing else _dollar_dollar = msg if !isempty(_dollar_dollar.attrs) - _t1841 = _dollar_dollar.attrs + _t1852 = _dollar_dollar.attrs else - _t1841 = nothing + _t1852 = nothing end - fields1376 = (_dollar_dollar.monoid, _dollar_dollar.name, (_dollar_dollar.body, _dollar_dollar.value_arity,), _t1841,) - unwrapped_fields1377 = fields1376 + fields1386 = (_dollar_dollar.monoid, _dollar_dollar.name, (_dollar_dollar.body, _dollar_dollar.value_arity,), _t1852,) + unwrapped_fields1387 = fields1386 write(pp, "(monus") indent_sexp!(pp) newline(pp) - field1378 = unwrapped_fields1377[1] - pretty_monoid(pp, field1378) + field1388 = unwrapped_fields1387[1] + pretty_monoid(pp, field1388) newline(pp) - field1379 = unwrapped_fields1377[2] - pretty_relation_id(pp, field1379) + field1389 = unwrapped_fields1387[2] + pretty_relation_id(pp, field1389) newline(pp) - field1380 = unwrapped_fields1377[3] - pretty_abstraction_with_arity(pp, field1380) - field1381 = unwrapped_fields1377[4] - if !isnothing(field1381) + field1390 = unwrapped_fields1387[3] + pretty_abstraction_with_arity(pp, field1390) + field1391 = unwrapped_fields1387[4] + if !isnothing(field1391) newline(pp) - opt_val1382 = field1381 - pretty_attrs(pp, opt_val1382) + opt_val1392 = field1391 + pretty_attrs(pp, opt_val1392) end dedent!(pp) write(pp, ")") @@ -3608,28 +3639,28 @@ function pretty_monus_def(pp::PrettyPrinter, msg::Proto.MonusDef) end function pretty_constraint(pp::PrettyPrinter, msg::Proto.Constraint) - flat1390 = try_flat(pp, msg, pretty_constraint) - if !isnothing(flat1390) - write(pp, flat1390) + flat1400 = try_flat(pp, msg, pretty_constraint) + if !isnothing(flat1400) + write(pp, flat1400) return nothing else _dollar_dollar = msg - fields1384 = (_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_fields1385 = fields1384 + fields1394 = (_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_fields1395 = fields1394 write(pp, "(functional_dependency") indent_sexp!(pp) newline(pp) - field1386 = unwrapped_fields1385[1] - pretty_relation_id(pp, field1386) + field1396 = unwrapped_fields1395[1] + pretty_relation_id(pp, field1396) newline(pp) - field1387 = unwrapped_fields1385[2] - pretty_abstraction(pp, field1387) + field1397 = unwrapped_fields1395[2] + pretty_abstraction(pp, field1397) newline(pp) - field1388 = unwrapped_fields1385[3] - pretty_functional_dependency_keys(pp, field1388) + field1398 = unwrapped_fields1395[3] + pretty_functional_dependency_keys(pp, field1398) newline(pp) - field1389 = unwrapped_fields1385[4] - pretty_functional_dependency_values(pp, field1389) + field1399 = unwrapped_fields1395[4] + pretty_functional_dependency_values(pp, field1399) dedent!(pp) write(pp, ")") end @@ -3637,22 +3668,22 @@ function pretty_constraint(pp::PrettyPrinter, msg::Proto.Constraint) end function pretty_functional_dependency_keys(pp::PrettyPrinter, msg::Vector{Proto.Var}) - flat1394 = try_flat(pp, msg, pretty_functional_dependency_keys) - if !isnothing(flat1394) - write(pp, flat1394) + flat1404 = try_flat(pp, msg, pretty_functional_dependency_keys) + if !isnothing(flat1404) + write(pp, flat1404) return nothing else - fields1391 = msg + fields1401 = msg write(pp, "(keys") indent_sexp!(pp) - if !isempty(fields1391) + if !isempty(fields1401) newline(pp) - for (i1842, elem1392) in enumerate(fields1391) - i1393 = i1842 - 1 - if (i1393 > 0) + for (i1853, elem1402) in enumerate(fields1401) + i1403 = i1853 - 1 + if (i1403 > 0) newline(pp) end - pretty_var(pp, elem1392) + pretty_var(pp, elem1402) end end dedent!(pp) @@ -3662,22 +3693,22 @@ function pretty_functional_dependency_keys(pp::PrettyPrinter, msg::Vector{Proto. end function pretty_functional_dependency_values(pp::PrettyPrinter, msg::Vector{Proto.Var}) - flat1398 = try_flat(pp, msg, pretty_functional_dependency_values) - if !isnothing(flat1398) - write(pp, flat1398) + flat1408 = try_flat(pp, msg, pretty_functional_dependency_values) + if !isnothing(flat1408) + write(pp, flat1408) return nothing else - fields1395 = msg + fields1405 = msg write(pp, "(values") indent_sexp!(pp) - if !isempty(fields1395) + if !isempty(fields1405) newline(pp) - for (i1843, elem1396) in enumerate(fields1395) - i1397 = i1843 - 1 - if (i1397 > 0) + for (i1854, elem1406) in enumerate(fields1405) + i1407 = i1854 - 1 + if (i1407 > 0) newline(pp) end - pretty_var(pp, elem1396) + pretty_var(pp, elem1406) end end dedent!(pp) @@ -3687,54 +3718,54 @@ function pretty_functional_dependency_values(pp::PrettyPrinter, msg::Vector{Prot end function pretty_data(pp::PrettyPrinter, msg::Proto.Data) - flat1407 = try_flat(pp, msg, pretty_data) - if !isnothing(flat1407) - write(pp, flat1407) + flat1417 = try_flat(pp, msg, pretty_data) + if !isnothing(flat1417) + write(pp, flat1417) return nothing else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("edb")) - _t1844 = _get_oneof_field(_dollar_dollar, :edb) + _t1855 = _get_oneof_field(_dollar_dollar, :edb) else - _t1844 = nothing + _t1855 = nothing end - deconstruct_result1405 = _t1844 - if !isnothing(deconstruct_result1405) - unwrapped1406 = deconstruct_result1405 - pretty_edb(pp, unwrapped1406) + deconstruct_result1415 = _t1855 + if !isnothing(deconstruct_result1415) + unwrapped1416 = deconstruct_result1415 + pretty_edb(pp, unwrapped1416) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("betree_relation")) - _t1845 = _get_oneof_field(_dollar_dollar, :betree_relation) + _t1856 = _get_oneof_field(_dollar_dollar, :betree_relation) else - _t1845 = nothing + _t1856 = nothing end - deconstruct_result1403 = _t1845 - if !isnothing(deconstruct_result1403) - unwrapped1404 = deconstruct_result1403 - pretty_betree_relation(pp, unwrapped1404) + deconstruct_result1413 = _t1856 + if !isnothing(deconstruct_result1413) + unwrapped1414 = deconstruct_result1413 + pretty_betree_relation(pp, unwrapped1414) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("csv_data")) - _t1846 = _get_oneof_field(_dollar_dollar, :csv_data) + _t1857 = _get_oneof_field(_dollar_dollar, :csv_data) else - _t1846 = nothing + _t1857 = nothing end - deconstruct_result1401 = _t1846 - if !isnothing(deconstruct_result1401) - unwrapped1402 = deconstruct_result1401 - pretty_csv_data(pp, unwrapped1402) + deconstruct_result1411 = _t1857 + if !isnothing(deconstruct_result1411) + unwrapped1412 = deconstruct_result1411 + pretty_csv_data(pp, unwrapped1412) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("iceberg_data")) - _t1847 = _get_oneof_field(_dollar_dollar, :iceberg_data) + _t1858 = _get_oneof_field(_dollar_dollar, :iceberg_data) else - _t1847 = nothing + _t1858 = nothing end - deconstruct_result1399 = _t1847 - if !isnothing(deconstruct_result1399) - unwrapped1400 = deconstruct_result1399 - pretty_iceberg_data(pp, unwrapped1400) + deconstruct_result1409 = _t1858 + if !isnothing(deconstruct_result1409) + unwrapped1410 = deconstruct_result1409 + pretty_iceberg_data(pp, unwrapped1410) else throw(ParseError("No matching rule for data")) end @@ -3746,25 +3777,25 @@ function pretty_data(pp::PrettyPrinter, msg::Proto.Data) end function pretty_edb(pp::PrettyPrinter, msg::Proto.EDB) - flat1413 = try_flat(pp, msg, pretty_edb) - if !isnothing(flat1413) - write(pp, flat1413) + flat1423 = try_flat(pp, msg, pretty_edb) + if !isnothing(flat1423) + write(pp, flat1423) return nothing else _dollar_dollar = msg - fields1408 = (_dollar_dollar.target_id, _dollar_dollar.path, _dollar_dollar.types,) - unwrapped_fields1409 = fields1408 + fields1418 = (_dollar_dollar.target_id, _dollar_dollar.path, _dollar_dollar.types,) + unwrapped_fields1419 = fields1418 write(pp, "(edb") indent_sexp!(pp) newline(pp) - field1410 = unwrapped_fields1409[1] - pretty_relation_id(pp, field1410) + field1420 = unwrapped_fields1419[1] + pretty_relation_id(pp, field1420) newline(pp) - field1411 = unwrapped_fields1409[2] - pretty_edb_path(pp, field1411) + field1421 = unwrapped_fields1419[2] + pretty_edb_path(pp, field1421) newline(pp) - field1412 = unwrapped_fields1409[3] - pretty_edb_types(pp, field1412) + field1422 = unwrapped_fields1419[3] + pretty_edb_types(pp, field1422) dedent!(pp) write(pp, ")") end @@ -3772,20 +3803,20 @@ function pretty_edb(pp::PrettyPrinter, msg::Proto.EDB) end function pretty_edb_path(pp::PrettyPrinter, msg::Vector{String}) - flat1417 = try_flat(pp, msg, pretty_edb_path) - if !isnothing(flat1417) - write(pp, flat1417) + flat1427 = try_flat(pp, msg, pretty_edb_path) + if !isnothing(flat1427) + write(pp, flat1427) return nothing else - fields1414 = msg + fields1424 = msg write(pp, "[") indent!(pp) - for (i1848, elem1415) in enumerate(fields1414) - i1416 = i1848 - 1 - if (i1416 > 0) + for (i1859, elem1425) in enumerate(fields1424) + i1426 = i1859 - 1 + if (i1426 > 0) newline(pp) end - write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, elem1415)) + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, elem1425)) end dedent!(pp) write(pp, "]") @@ -3794,20 +3825,20 @@ function pretty_edb_path(pp::PrettyPrinter, msg::Vector{String}) end function pretty_edb_types(pp::PrettyPrinter, msg::Vector{Proto.var"#Type"}) - flat1421 = try_flat(pp, msg, pretty_edb_types) - if !isnothing(flat1421) - write(pp, flat1421) + flat1431 = try_flat(pp, msg, pretty_edb_types) + if !isnothing(flat1431) + write(pp, flat1431) return nothing else - fields1418 = msg + fields1428 = msg write(pp, "[") indent!(pp) - for (i1849, elem1419) in enumerate(fields1418) - i1420 = i1849 - 1 - if (i1420 > 0) + for (i1860, elem1429) in enumerate(fields1428) + i1430 = i1860 - 1 + if (i1430 > 0) newline(pp) end - pretty_type(pp, elem1419) + pretty_type(pp, elem1429) end dedent!(pp) write(pp, "]") @@ -3816,22 +3847,22 @@ function pretty_edb_types(pp::PrettyPrinter, msg::Vector{Proto.var"#Type"}) end function pretty_betree_relation(pp::PrettyPrinter, msg::Proto.BeTreeRelation) - flat1426 = try_flat(pp, msg, pretty_betree_relation) - if !isnothing(flat1426) - write(pp, flat1426) + flat1436 = try_flat(pp, msg, pretty_betree_relation) + if !isnothing(flat1436) + write(pp, flat1436) return nothing else _dollar_dollar = msg - fields1422 = (_dollar_dollar.name, _dollar_dollar.relation_info,) - unwrapped_fields1423 = fields1422 + fields1432 = (_dollar_dollar.name, _dollar_dollar.relation_info,) + unwrapped_fields1433 = fields1432 write(pp, "(betree_relation") indent_sexp!(pp) newline(pp) - field1424 = unwrapped_fields1423[1] - pretty_relation_id(pp, field1424) + field1434 = unwrapped_fields1433[1] + pretty_relation_id(pp, field1434) newline(pp) - field1425 = unwrapped_fields1423[2] - pretty_betree_info(pp, field1425) + field1435 = unwrapped_fields1433[2] + pretty_betree_info(pp, field1435) dedent!(pp) write(pp, ")") end @@ -3839,26 +3870,26 @@ function pretty_betree_relation(pp::PrettyPrinter, msg::Proto.BeTreeRelation) end function pretty_betree_info(pp::PrettyPrinter, msg::Proto.BeTreeInfo) - flat1432 = try_flat(pp, msg, pretty_betree_info) - if !isnothing(flat1432) - write(pp, flat1432) + flat1442 = try_flat(pp, msg, pretty_betree_info) + if !isnothing(flat1442) + write(pp, flat1442) return nothing else _dollar_dollar = msg - _t1850 = deconstruct_betree_info_config(pp, _dollar_dollar) - fields1427 = (_dollar_dollar.key_types, _dollar_dollar.value_types, _t1850,) - unwrapped_fields1428 = fields1427 + _t1861 = deconstruct_betree_info_config(pp, _dollar_dollar) + fields1437 = (_dollar_dollar.key_types, _dollar_dollar.value_types, _t1861,) + unwrapped_fields1438 = fields1437 write(pp, "(betree_info") indent_sexp!(pp) newline(pp) - field1429 = unwrapped_fields1428[1] - pretty_betree_info_key_types(pp, field1429) + field1439 = unwrapped_fields1438[1] + pretty_betree_info_key_types(pp, field1439) newline(pp) - field1430 = unwrapped_fields1428[2] - pretty_betree_info_value_types(pp, field1430) + field1440 = unwrapped_fields1438[2] + pretty_betree_info_value_types(pp, field1440) newline(pp) - field1431 = unwrapped_fields1428[3] - pretty_config_dict(pp, field1431) + field1441 = unwrapped_fields1438[3] + pretty_config_dict(pp, field1441) dedent!(pp) write(pp, ")") end @@ -3866,22 +3897,22 @@ function pretty_betree_info(pp::PrettyPrinter, msg::Proto.BeTreeInfo) end function pretty_betree_info_key_types(pp::PrettyPrinter, msg::Vector{Proto.var"#Type"}) - flat1436 = try_flat(pp, msg, pretty_betree_info_key_types) - if !isnothing(flat1436) - write(pp, flat1436) + flat1446 = try_flat(pp, msg, pretty_betree_info_key_types) + if !isnothing(flat1446) + write(pp, flat1446) return nothing else - fields1433 = msg + fields1443 = msg write(pp, "(key_types") indent_sexp!(pp) - if !isempty(fields1433) + if !isempty(fields1443) newline(pp) - for (i1851, elem1434) in enumerate(fields1433) - i1435 = i1851 - 1 - if (i1435 > 0) + for (i1862, elem1444) in enumerate(fields1443) + i1445 = i1862 - 1 + if (i1445 > 0) newline(pp) end - pretty_type(pp, elem1434) + pretty_type(pp, elem1444) end end dedent!(pp) @@ -3891,22 +3922,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"}) - flat1440 = try_flat(pp, msg, pretty_betree_info_value_types) - if !isnothing(flat1440) - write(pp, flat1440) + flat1450 = try_flat(pp, msg, pretty_betree_info_value_types) + if !isnothing(flat1450) + write(pp, flat1450) return nothing else - fields1437 = msg + fields1447 = msg write(pp, "(value_types") indent_sexp!(pp) - if !isempty(fields1437) + if !isempty(fields1447) newline(pp) - for (i1852, elem1438) in enumerate(fields1437) - i1439 = i1852 - 1 - if (i1439 > 0) + for (i1863, elem1448) in enumerate(fields1447) + i1449 = i1863 - 1 + if (i1449 > 0) newline(pp) end - pretty_type(pp, elem1438) + pretty_type(pp, elem1448) end end dedent!(pp) @@ -3916,39 +3947,39 @@ function pretty_betree_info_value_types(pp::PrettyPrinter, msg::Vector{Proto.var end function pretty_csv_data(pp::PrettyPrinter, msg::Proto.CSVData) - flat1450 = try_flat(pp, msg, pretty_csv_data) - if !isnothing(flat1450) - write(pp, flat1450) + flat1460 = try_flat(pp, msg, pretty_csv_data) + if !isnothing(flat1460) + write(pp, flat1460) return nothing else _dollar_dollar = msg - _t1853 = deconstruct_csv_data_columns_optional(pp, _dollar_dollar) - _t1854 = deconstruct_csv_data_relations_optional(pp, _dollar_dollar) - fields1441 = (_dollar_dollar.locator, _dollar_dollar.config, _t1853, _t1854, _dollar_dollar.asof,) - unwrapped_fields1442 = fields1441 + _t1864 = deconstruct_csv_data_columns_optional(pp, _dollar_dollar) + _t1865 = deconstruct_csv_data_relations_optional(pp, _dollar_dollar) + fields1451 = (_dollar_dollar.locator, _dollar_dollar.config, _t1864, _t1865, _dollar_dollar.asof,) + unwrapped_fields1452 = fields1451 write(pp, "(csv_data") indent_sexp!(pp) newline(pp) - field1443 = unwrapped_fields1442[1] - pretty_csvlocator(pp, field1443) + field1453 = unwrapped_fields1452[1] + pretty_csvlocator(pp, field1453) newline(pp) - field1444 = unwrapped_fields1442[2] - pretty_csv_config(pp, field1444) - field1445 = unwrapped_fields1442[3] - if !isnothing(field1445) + field1454 = unwrapped_fields1452[2] + pretty_csv_config(pp, field1454) + field1455 = unwrapped_fields1452[3] + if !isnothing(field1455) newline(pp) - opt_val1446 = field1445 - pretty_gnf_columns(pp, opt_val1446) + opt_val1456 = field1455 + pretty_gnf_columns(pp, opt_val1456) end - field1447 = unwrapped_fields1442[4] - if !isnothing(field1447) + field1457 = unwrapped_fields1452[4] + if !isnothing(field1457) newline(pp) - opt_val1448 = field1447 - pretty_target_relations(pp, opt_val1448) + opt_val1458 = field1457 + pretty_target_relations(pp, opt_val1458) end newline(pp) - field1449 = unwrapped_fields1442[5] - pretty_csv_asof(pp, field1449) + field1459 = unwrapped_fields1452[5] + pretty_csv_asof(pp, field1459) dedent!(pp) write(pp, ")") end @@ -3956,37 +3987,37 @@ function pretty_csv_data(pp::PrettyPrinter, msg::Proto.CSVData) end function pretty_csvlocator(pp::PrettyPrinter, msg::Proto.CSVLocator) - flat1457 = try_flat(pp, msg, pretty_csvlocator) - if !isnothing(flat1457) - write(pp, flat1457) + flat1467 = try_flat(pp, msg, pretty_csvlocator) + if !isnothing(flat1467) + write(pp, flat1467) return nothing else _dollar_dollar = msg if !isempty(_dollar_dollar.paths) - _t1855 = _dollar_dollar.paths + _t1866 = _dollar_dollar.paths else - _t1855 = nothing + _t1866 = nothing end if String(copy(_dollar_dollar.inline_data)) != "" - _t1856 = String(copy(_dollar_dollar.inline_data)) + _t1867 = String(copy(_dollar_dollar.inline_data)) else - _t1856 = nothing + _t1867 = nothing end - fields1451 = (_t1855, _t1856,) - unwrapped_fields1452 = fields1451 + fields1461 = (_t1866, _t1867,) + unwrapped_fields1462 = fields1461 write(pp, "(csv_locator") indent_sexp!(pp) - field1453 = unwrapped_fields1452[1] - if !isnothing(field1453) + field1463 = unwrapped_fields1462[1] + if !isnothing(field1463) newline(pp) - opt_val1454 = field1453 - pretty_csv_locator_paths(pp, opt_val1454) + opt_val1464 = field1463 + pretty_csv_locator_paths(pp, opt_val1464) end - field1455 = unwrapped_fields1452[2] - if !isnothing(field1455) + field1465 = unwrapped_fields1462[2] + if !isnothing(field1465) newline(pp) - opt_val1456 = field1455 - pretty_csv_locator_inline_data(pp, opt_val1456) + opt_val1466 = field1465 + pretty_csv_locator_inline_data(pp, opt_val1466) end dedent!(pp) write(pp, ")") @@ -3995,22 +4026,22 @@ function pretty_csvlocator(pp::PrettyPrinter, msg::Proto.CSVLocator) end function pretty_csv_locator_paths(pp::PrettyPrinter, msg::Vector{String}) - flat1461 = try_flat(pp, msg, pretty_csv_locator_paths) - if !isnothing(flat1461) - write(pp, flat1461) + flat1471 = try_flat(pp, msg, pretty_csv_locator_paths) + if !isnothing(flat1471) + write(pp, flat1471) return nothing else - fields1458 = msg + fields1468 = msg write(pp, "(paths") indent_sexp!(pp) - if !isempty(fields1458) + if !isempty(fields1468) newline(pp) - for (i1857, elem1459) in enumerate(fields1458) - i1460 = i1857 - 1 - if (i1460 > 0) + for (i1868, elem1469) in enumerate(fields1468) + i1470 = i1868 - 1 + if (i1470 > 0) newline(pp) end - write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, elem1459)) + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, elem1469)) end end dedent!(pp) @@ -4020,16 +4051,16 @@ function pretty_csv_locator_paths(pp::PrettyPrinter, msg::Vector{String}) end function pretty_csv_locator_inline_data(pp::PrettyPrinter, msg::String) - flat1463 = try_flat(pp, msg, pretty_csv_locator_inline_data) - if !isnothing(flat1463) - write(pp, flat1463) + flat1473 = try_flat(pp, msg, pretty_csv_locator_inline_data) + if !isnothing(flat1473) + write(pp, flat1473) return nothing else - fields1462 = msg + fields1472 = msg write(pp, "(inline_data") indent_sexp!(pp) newline(pp) - write(pp, format_string(pp, fields1462)) + write(pp, format_string(pp, fields1472)) dedent!(pp) write(pp, ")") end @@ -4037,26 +4068,26 @@ function pretty_csv_locator_inline_data(pp::PrettyPrinter, msg::String) end function pretty_csv_config(pp::PrettyPrinter, msg::Proto.CSVConfig) - flat1469 = try_flat(pp, msg, pretty_csv_config) - if !isnothing(flat1469) - write(pp, flat1469) + flat1479 = try_flat(pp, msg, pretty_csv_config) + if !isnothing(flat1479) + write(pp, flat1479) return nothing else _dollar_dollar = msg - _t1858 = deconstruct_csv_config(pp, _dollar_dollar) - _t1859 = deconstruct_csv_storage_integration_optional(pp, _dollar_dollar) - fields1464 = (_t1858, _t1859,) - unwrapped_fields1465 = fields1464 + _t1869 = deconstruct_csv_config(pp, _dollar_dollar) + _t1870 = deconstruct_csv_storage_integration_optional(pp, _dollar_dollar) + fields1474 = (_t1869, _t1870,) + unwrapped_fields1475 = fields1474 write(pp, "(csv_config") indent_sexp!(pp) newline(pp) - field1466 = unwrapped_fields1465[1] - pretty_config_dict(pp, field1466) - field1467 = unwrapped_fields1465[2] - if !isnothing(field1467) + field1476 = unwrapped_fields1475[1] + pretty_config_dict(pp, field1476) + field1477 = unwrapped_fields1475[2] + if !isnothing(field1477) newline(pp) - opt_val1468 = field1467 - pretty__storage_integration(pp, opt_val1468) + opt_val1478 = field1477 + pretty__storage_integration(pp, opt_val1478) end dedent!(pp) write(pp, ")") @@ -4065,16 +4096,16 @@ function pretty_csv_config(pp::PrettyPrinter, msg::Proto.CSVConfig) end function pretty__storage_integration(pp::PrettyPrinter, msg::Vector{Tuple{String, Proto.Value}}) - flat1471 = try_flat(pp, msg, pretty__storage_integration) - if !isnothing(flat1471) - write(pp, flat1471) + flat1481 = try_flat(pp, msg, pretty__storage_integration) + if !isnothing(flat1481) + write(pp, flat1481) return nothing else - fields1470 = msg + fields1480 = msg write(pp, "(storage_integration") indent_sexp!(pp) newline(pp) - pretty_config_dict(pp, fields1470) + pretty_config_dict(pp, fields1480) dedent!(pp) write(pp, ")") end @@ -4082,22 +4113,22 @@ function pretty__storage_integration(pp::PrettyPrinter, msg::Vector{Tuple{String end function pretty_gnf_columns(pp::PrettyPrinter, msg::Vector{Proto.GNFColumn}) - flat1475 = try_flat(pp, msg, pretty_gnf_columns) - if !isnothing(flat1475) - write(pp, flat1475) + flat1485 = try_flat(pp, msg, pretty_gnf_columns) + if !isnothing(flat1485) + write(pp, flat1485) return nothing else - fields1472 = msg + fields1482 = msg write(pp, "(columns") indent_sexp!(pp) - if !isempty(fields1472) + if !isempty(fields1482) newline(pp) - for (i1860, elem1473) in enumerate(fields1472) - i1474 = i1860 - 1 - if (i1474 > 0) + for (i1871, elem1483) in enumerate(fields1482) + i1484 = i1871 - 1 + if (i1484 > 0) newline(pp) end - pretty_gnf_column(pp, elem1473) + pretty_gnf_column(pp, elem1483) end end dedent!(pp) @@ -4107,39 +4138,39 @@ function pretty_gnf_columns(pp::PrettyPrinter, msg::Vector{Proto.GNFColumn}) end function pretty_gnf_column(pp::PrettyPrinter, msg::Proto.GNFColumn) - flat1484 = try_flat(pp, msg, pretty_gnf_column) - if !isnothing(flat1484) - write(pp, flat1484) + flat1494 = try_flat(pp, msg, pretty_gnf_column) + if !isnothing(flat1494) + write(pp, flat1494) return nothing else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("target_id")) - _t1861 = _dollar_dollar.target_id + _t1872 = _dollar_dollar.target_id else - _t1861 = nothing + _t1872 = nothing end - fields1476 = (_dollar_dollar.column_path, _t1861, _dollar_dollar.types,) - unwrapped_fields1477 = fields1476 + fields1486 = (_dollar_dollar.column_path, _t1872, _dollar_dollar.types,) + unwrapped_fields1487 = fields1486 write(pp, "(column") indent_sexp!(pp) newline(pp) - field1478 = unwrapped_fields1477[1] - pretty_gnf_column_path(pp, field1478) - field1479 = unwrapped_fields1477[2] - if !isnothing(field1479) + field1488 = unwrapped_fields1487[1] + pretty_gnf_column_path(pp, field1488) + field1489 = unwrapped_fields1487[2] + if !isnothing(field1489) newline(pp) - opt_val1480 = field1479 - pretty_relation_id(pp, opt_val1480) + opt_val1490 = field1489 + pretty_relation_id(pp, opt_val1490) end newline(pp) write(pp, "[") - field1481 = unwrapped_fields1477[3] - for (i1862, elem1482) in enumerate(field1481) - i1483 = i1862 - 1 - if (i1483 > 0) + field1491 = unwrapped_fields1487[3] + for (i1873, elem1492) in enumerate(field1491) + i1493 = i1873 - 1 + if (i1493 > 0) newline(pp) end - pretty_type(pp, elem1482) + pretty_type(pp, elem1492) end write(pp, "]") dedent!(pp) @@ -4149,39 +4180,39 @@ function pretty_gnf_column(pp::PrettyPrinter, msg::Proto.GNFColumn) end function pretty_gnf_column_path(pp::PrettyPrinter, msg::Vector{String}) - flat1491 = try_flat(pp, msg, pretty_gnf_column_path) - if !isnothing(flat1491) - write(pp, flat1491) + flat1501 = try_flat(pp, msg, pretty_gnf_column_path) + if !isnothing(flat1501) + write(pp, flat1501) return nothing else _dollar_dollar = msg if length(_dollar_dollar) == 1 - _t1863 = _dollar_dollar[1] + _t1874 = _dollar_dollar[1] else - _t1863 = nothing + _t1874 = nothing end - deconstruct_result1489 = _t1863 - if !isnothing(deconstruct_result1489) - unwrapped1490 = deconstruct_result1489 - write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, unwrapped1490)) + deconstruct_result1499 = _t1874 + if !isnothing(deconstruct_result1499) + unwrapped1500 = deconstruct_result1499 + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, unwrapped1500)) else _dollar_dollar = msg if length(_dollar_dollar) != 1 - _t1864 = _dollar_dollar + _t1875 = _dollar_dollar else - _t1864 = nothing + _t1875 = nothing end - deconstruct_result1485 = _t1864 - if !isnothing(deconstruct_result1485) - unwrapped1486 = deconstruct_result1485 + deconstruct_result1495 = _t1875 + if !isnothing(deconstruct_result1495) + unwrapped1496 = deconstruct_result1495 write(pp, "[") indent!(pp) - for (i1865, elem1487) in enumerate(unwrapped1486) - i1488 = i1865 - 1 - if (i1488 > 0) + for (i1876, elem1497) in enumerate(unwrapped1496) + i1498 = i1876 - 1 + if (i1498 > 0) newline(pp) end - write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, elem1487)) + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, elem1497)) end dedent!(pp) write(pp, "]") @@ -4194,29 +4225,29 @@ function pretty_gnf_column_path(pp::PrettyPrinter, msg::Vector{String}) end function pretty_target_relations(pp::PrettyPrinter, msg::Proto.TargetRelations) - flat1498 = try_flat(pp, msg, pretty_target_relations) - if !isnothing(flat1498) - write(pp, flat1498) + flat1508 = try_flat(pp, msg, pretty_target_relations) + if !isnothing(flat1508) + write(pp, flat1508) return nothing else _dollar_dollar = msg - _t1866 = deconstruct_relation_keys(pp, _dollar_dollar) - _t1867 = deconstruct_load_errors_optional(pp, _dollar_dollar) - fields1492 = (_t1866, _dollar_dollar, _t1867,) - unwrapped_fields1493 = fields1492 + _t1877 = deconstruct_relation_keys(pp, _dollar_dollar) + _t1878 = deconstruct_load_errors_optional(pp, _dollar_dollar) + fields1502 = (_t1877, _dollar_dollar, _t1878,) + unwrapped_fields1503 = fields1502 write(pp, "(relations") indent_sexp!(pp) newline(pp) - field1494 = unwrapped_fields1493[1] - pretty_relation_keys(pp, field1494) + field1504 = unwrapped_fields1503[1] + pretty_relation_keys(pp, field1504) newline(pp) - field1495 = unwrapped_fields1493[2] - pretty_relation_body(pp, field1495) - field1496 = unwrapped_fields1493[3] - if !isnothing(field1496) + field1505 = unwrapped_fields1503[2] + pretty_relation_body(pp, field1505) + field1506 = unwrapped_fields1503[3] + if !isnothing(field1506) newline(pp) - opt_val1497 = field1496 - pretty_load_errors(pp, opt_val1497) + opt_val1507 = field1506 + pretty_load_errors(pp, opt_val1507) end dedent!(pp) write(pp, ")") @@ -4225,30 +4256,30 @@ function pretty_target_relations(pp::PrettyPrinter, msg::Proto.TargetRelations) end function pretty_relation_keys(pp::PrettyPrinter, msg::Tuple{Vector{Proto.NamedColumn}, Bool}) - flat1505 = try_flat(pp, msg, pretty_relation_keys) - if !isnothing(flat1505) - write(pp, flat1505) + flat1515 = try_flat(pp, msg, pretty_relation_keys) + if !isnothing(flat1515) + write(pp, flat1515) return nothing else _dollar_dollar = msg if !_dollar_dollar[2] - _t1868 = _dollar_dollar[1] + _t1879 = _dollar_dollar[1] else - _t1868 = nothing + _t1879 = nothing end - deconstruct_result1501 = _t1868 - if !isnothing(deconstruct_result1501) - unwrapped1502 = deconstruct_result1501 + deconstruct_result1511 = _t1879 + if !isnothing(deconstruct_result1511) + unwrapped1512 = deconstruct_result1511 write(pp, "(keys") indent_sexp!(pp) - if !isempty(unwrapped1502) + if !isempty(unwrapped1512) newline(pp) - for (i1869, elem1503) in enumerate(unwrapped1502) - i1504 = i1869 - 1 - if (i1504 > 0) + for (i1880, elem1513) in enumerate(unwrapped1512) + i1514 = i1880 - 1 + if (i1514 > 0) newline(pp) end - pretty_named_column(pp, elem1503) + pretty_named_column(pp, elem1513) end end dedent!(pp) @@ -4256,13 +4287,13 @@ function pretty_relation_keys(pp::PrettyPrinter, msg::Tuple{Vector{Proto.NamedCo else _dollar_dollar = msg if _dollar_dollar[2] - _t1870 = () + _t1881 = () else - _t1870 = nothing + _t1881 = nothing end - deconstruct_result1499 = _t1870 - if !isnothing(deconstruct_result1499) - unwrapped1500 = deconstruct_result1499 + deconstruct_result1509 = _t1881 + if !isnothing(deconstruct_result1509) + unwrapped1510 = deconstruct_result1509 write(pp, "(keys") newline(pp) write(pp, "synthetic)") @@ -4275,22 +4306,22 @@ function pretty_relation_keys(pp::PrettyPrinter, msg::Tuple{Vector{Proto.NamedCo end function pretty_named_column(pp::PrettyPrinter, msg::Proto.NamedColumn) - flat1510 = try_flat(pp, msg, pretty_named_column) - if !isnothing(flat1510) - write(pp, flat1510) + flat1520 = try_flat(pp, msg, pretty_named_column) + if !isnothing(flat1520) + write(pp, flat1520) return nothing else _dollar_dollar = msg - fields1506 = (_dollar_dollar.name, _dollar_dollar.var"#type",) - unwrapped_fields1507 = fields1506 + fields1516 = (_dollar_dollar.name, _dollar_dollar.var"#type",) + unwrapped_fields1517 = fields1516 write(pp, "(column") indent_sexp!(pp) newline(pp) - field1508 = unwrapped_fields1507[1] - write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, field1508)) + field1518 = unwrapped_fields1517[1] + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, field1518)) newline(pp) - field1509 = unwrapped_fields1507[2] - pretty_type(pp, field1509) + field1519 = unwrapped_fields1517[2] + pretty_type(pp, field1519) dedent!(pp) write(pp, ")") end @@ -4298,36 +4329,36 @@ function pretty_named_column(pp::PrettyPrinter, msg::Proto.NamedColumn) end function pretty_relation_body(pp::PrettyPrinter, msg::Proto.TargetRelations) - flat1517 = try_flat(pp, msg, pretty_relation_body) - if !isnothing(flat1517) - write(pp, flat1517) + flat1527 = try_flat(pp, msg, pretty_relation_body) + if !isnothing(flat1527) + write(pp, flat1527) return nothing else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("plain")) - _t1871 = _get_oneof_field(_dollar_dollar, :plain).targets + _t1882 = _get_oneof_field(_dollar_dollar, :plain).targets else - _t1871 = nothing + _t1882 = nothing end - deconstruct_result1515 = _t1871 - if !isnothing(deconstruct_result1515) - unwrapped1516 = deconstruct_result1515 - pretty_non_cdc_relations(pp, unwrapped1516) + deconstruct_result1525 = _t1882 + if !isnothing(deconstruct_result1525) + unwrapped1526 = deconstruct_result1525 + pretty_non_cdc_relations(pp, unwrapped1526) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("cdc")) - _t1872 = (_get_oneof_field(_dollar_dollar, :cdc).inserts, _get_oneof_field(_dollar_dollar, :cdc).deletes,) + _t1883 = (_get_oneof_field(_dollar_dollar, :cdc).inserts, _get_oneof_field(_dollar_dollar, :cdc).deletes,) else - _t1872 = nothing + _t1883 = nothing end - deconstruct_result1511 = _t1872 - if !isnothing(deconstruct_result1511) - unwrapped1512 = deconstruct_result1511 - field1513 = unwrapped1512[1] - pretty_cdc_inserts(pp, field1513) + deconstruct_result1521 = _t1883 + if !isnothing(deconstruct_result1521) + unwrapped1522 = deconstruct_result1521 + field1523 = unwrapped1522[1] + pretty_cdc_inserts(pp, field1523) write(pp, " ") - field1514 = unwrapped1512[2] - pretty_cdc_deletes(pp, field1514) + field1524 = unwrapped1522[2] + pretty_cdc_deletes(pp, field1524) else throw(ParseError("No matching rule for relation_body")) end @@ -4337,46 +4368,46 @@ function pretty_relation_body(pp::PrettyPrinter, msg::Proto.TargetRelations) end function pretty_non_cdc_relations(pp::PrettyPrinter, msg::Vector{Proto.TargetRelation}) - flat1521 = try_flat(pp, msg, pretty_non_cdc_relations) - if !isnothing(flat1521) - write(pp, flat1521) + flat1531 = try_flat(pp, msg, pretty_non_cdc_relations) + if !isnothing(flat1531) + write(pp, flat1531) return nothing else - fields1518 = msg - for (i1873, elem1519) in enumerate(fields1518) - i1520 = i1873 - 1 - if (i1520 > 0) + fields1528 = msg + for (i1884, elem1529) in enumerate(fields1528) + i1530 = i1884 - 1 + if (i1530 > 0) newline(pp) end - pretty_target_relation(pp, elem1519) + pretty_target_relation(pp, elem1529) end end return nothing end function pretty_target_relation(pp::PrettyPrinter, msg::Proto.TargetRelation) - flat1528 = try_flat(pp, msg, pretty_target_relation) - if !isnothing(flat1528) - write(pp, flat1528) + flat1538 = try_flat(pp, msg, pretty_target_relation) + if !isnothing(flat1538) + write(pp, flat1538) return nothing else _dollar_dollar = msg - fields1522 = (_dollar_dollar.target_id, _dollar_dollar.values,) - unwrapped_fields1523 = fields1522 + fields1532 = (_dollar_dollar.target_id, _dollar_dollar.values,) + unwrapped_fields1533 = fields1532 write(pp, "(relation") indent_sexp!(pp) newline(pp) - field1524 = unwrapped_fields1523[1] - pretty_relation_id(pp, field1524) - field1525 = unwrapped_fields1523[2] - if !isempty(field1525) + field1534 = unwrapped_fields1533[1] + pretty_relation_id(pp, field1534) + field1535 = unwrapped_fields1533[2] + if !isempty(field1535) newline(pp) - for (i1874, elem1526) in enumerate(field1525) - i1527 = i1874 - 1 - if (i1527 > 0) + for (i1885, elem1536) in enumerate(field1535) + i1537 = i1885 - 1 + if (i1537 > 0) newline(pp) end - pretty_named_column(pp, elem1526) + pretty_named_column(pp, elem1536) end end dedent!(pp) @@ -4386,22 +4417,22 @@ function pretty_target_relation(pp::PrettyPrinter, msg::Proto.TargetRelation) end function pretty_cdc_inserts(pp::PrettyPrinter, msg::Vector{Proto.TargetRelation}) - flat1532 = try_flat(pp, msg, pretty_cdc_inserts) - if !isnothing(flat1532) - write(pp, flat1532) + flat1542 = try_flat(pp, msg, pretty_cdc_inserts) + if !isnothing(flat1542) + write(pp, flat1542) return nothing else - fields1529 = msg + fields1539 = msg write(pp, "(inserts") indent_sexp!(pp) - if !isempty(fields1529) + if !isempty(fields1539) newline(pp) - for (i1875, elem1530) in enumerate(fields1529) - i1531 = i1875 - 1 - if (i1531 > 0) + for (i1886, elem1540) in enumerate(fields1539) + i1541 = i1886 - 1 + if (i1541 > 0) newline(pp) end - pretty_target_relation(pp, elem1530) + pretty_target_relation(pp, elem1540) end end dedent!(pp) @@ -4411,22 +4442,22 @@ function pretty_cdc_inserts(pp::PrettyPrinter, msg::Vector{Proto.TargetRelation} end function pretty_cdc_deletes(pp::PrettyPrinter, msg::Vector{Proto.TargetRelation}) - flat1536 = try_flat(pp, msg, pretty_cdc_deletes) - if !isnothing(flat1536) - write(pp, flat1536) + flat1546 = try_flat(pp, msg, pretty_cdc_deletes) + if !isnothing(flat1546) + write(pp, flat1546) return nothing else - fields1533 = msg + fields1543 = msg write(pp, "(deletes") indent_sexp!(pp) - if !isempty(fields1533) + if !isempty(fields1543) newline(pp) - for (i1876, elem1534) in enumerate(fields1533) - i1535 = i1876 - 1 - if (i1535 > 0) + for (i1887, elem1544) in enumerate(fields1543) + i1545 = i1887 - 1 + if (i1545 > 0) newline(pp) end - pretty_target_relation(pp, elem1534) + pretty_target_relation(pp, elem1544) end end dedent!(pp) @@ -4436,16 +4467,16 @@ function pretty_cdc_deletes(pp::PrettyPrinter, msg::Vector{Proto.TargetRelation} end function pretty_load_errors(pp::PrettyPrinter, msg::Proto.RelationId) - flat1538 = try_flat(pp, msg, pretty_load_errors) - if !isnothing(flat1538) - write(pp, flat1538) + flat1548 = try_flat(pp, msg, pretty_load_errors) + if !isnothing(flat1548) + write(pp, flat1548) return nothing else - fields1537 = msg + fields1547 = msg write(pp, "(load_errors") indent_sexp!(pp) newline(pp) - pretty_relation_id(pp, fields1537) + pretty_relation_id(pp, fields1547) dedent!(pp) write(pp, ")") end @@ -4453,16 +4484,16 @@ function pretty_load_errors(pp::PrettyPrinter, msg::Proto.RelationId) end function pretty_csv_asof(pp::PrettyPrinter, msg::String) - flat1540 = try_flat(pp, msg, pretty_csv_asof) - if !isnothing(flat1540) - write(pp, flat1540) + flat1550 = try_flat(pp, msg, pretty_csv_asof) + if !isnothing(flat1550) + write(pp, flat1550) return nothing else - fields1539 = msg + fields1549 = msg write(pp, "(asof") indent_sexp!(pp) newline(pp) - write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, fields1539)) + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, fields1549)) dedent!(pp) write(pp, ")") end @@ -4470,42 +4501,42 @@ function pretty_csv_asof(pp::PrettyPrinter, msg::String) end function pretty_iceberg_data(pp::PrettyPrinter, msg::Proto.IcebergData) - flat1551 = try_flat(pp, msg, pretty_iceberg_data) - if !isnothing(flat1551) - write(pp, flat1551) + flat1561 = try_flat(pp, msg, pretty_iceberg_data) + if !isnothing(flat1561) + write(pp, flat1561) return nothing else _dollar_dollar = msg - _t1877 = deconstruct_iceberg_data_from_snapshot_optional(pp, _dollar_dollar) - _t1878 = deconstruct_iceberg_data_to_snapshot_optional(pp, _dollar_dollar) - fields1541 = (_dollar_dollar.locator, _dollar_dollar.config, _dollar_dollar.columns, _t1877, _t1878, _dollar_dollar.returns_delta,) - unwrapped_fields1542 = fields1541 + _t1888 = deconstruct_iceberg_data_from_snapshot_optional(pp, _dollar_dollar) + _t1889 = deconstruct_iceberg_data_to_snapshot_optional(pp, _dollar_dollar) + fields1551 = (_dollar_dollar.locator, _dollar_dollar.config, _dollar_dollar.columns, _t1888, _t1889, _dollar_dollar.returns_delta,) + unwrapped_fields1552 = fields1551 write(pp, "(iceberg_data") indent_sexp!(pp) newline(pp) - field1543 = unwrapped_fields1542[1] - pretty_iceberg_locator(pp, field1543) + field1553 = unwrapped_fields1552[1] + pretty_iceberg_locator(pp, field1553) newline(pp) - field1544 = unwrapped_fields1542[2] - pretty_iceberg_catalog_config(pp, field1544) + field1554 = unwrapped_fields1552[2] + pretty_iceberg_catalog_config(pp, field1554) newline(pp) - field1545 = unwrapped_fields1542[3] - pretty_gnf_columns(pp, field1545) - field1546 = unwrapped_fields1542[4] - if !isnothing(field1546) + field1555 = unwrapped_fields1552[3] + pretty_gnf_columns(pp, field1555) + field1556 = unwrapped_fields1552[4] + if !isnothing(field1556) newline(pp) - opt_val1547 = field1546 - pretty_iceberg_from_snapshot(pp, opt_val1547) + opt_val1557 = field1556 + pretty_iceberg_from_snapshot(pp, opt_val1557) end - field1548 = unwrapped_fields1542[5] - if !isnothing(field1548) + field1558 = unwrapped_fields1552[5] + if !isnothing(field1558) newline(pp) - opt_val1549 = field1548 - pretty_iceberg_to_snapshot(pp, opt_val1549) + opt_val1559 = field1558 + pretty_iceberg_to_snapshot(pp, opt_val1559) end newline(pp) - field1550 = unwrapped_fields1542[6] - pretty_boolean_value(pp, field1550) + field1560 = unwrapped_fields1552[6] + pretty_boolean_value(pp, field1560) dedent!(pp) write(pp, ")") end @@ -4513,25 +4544,25 @@ function pretty_iceberg_data(pp::PrettyPrinter, msg::Proto.IcebergData) end function pretty_iceberg_locator(pp::PrettyPrinter, msg::Proto.IcebergLocator) - flat1557 = try_flat(pp, msg, pretty_iceberg_locator) - if !isnothing(flat1557) - write(pp, flat1557) + flat1567 = try_flat(pp, msg, pretty_iceberg_locator) + if !isnothing(flat1567) + write(pp, flat1567) return nothing else _dollar_dollar = msg - fields1552 = (_dollar_dollar.table_name, _dollar_dollar.namespace, _dollar_dollar.warehouse,) - unwrapped_fields1553 = fields1552 + fields1562 = (_dollar_dollar.table_name, _dollar_dollar.namespace, _dollar_dollar.warehouse,) + unwrapped_fields1563 = fields1562 write(pp, "(iceberg_locator") indent_sexp!(pp) newline(pp) - field1554 = unwrapped_fields1553[1] - pretty_iceberg_locator_table_name(pp, field1554) + field1564 = unwrapped_fields1563[1] + pretty_iceberg_locator_table_name(pp, field1564) newline(pp) - field1555 = unwrapped_fields1553[2] - pretty_iceberg_locator_namespace(pp, field1555) + field1565 = unwrapped_fields1563[2] + pretty_iceberg_locator_namespace(pp, field1565) newline(pp) - field1556 = unwrapped_fields1553[3] - pretty_iceberg_locator_warehouse(pp, field1556) + field1566 = unwrapped_fields1563[3] + pretty_iceberg_locator_warehouse(pp, field1566) dedent!(pp) write(pp, ")") end @@ -4539,16 +4570,16 @@ function pretty_iceberg_locator(pp::PrettyPrinter, msg::Proto.IcebergLocator) end function pretty_iceberg_locator_table_name(pp::PrettyPrinter, msg::String) - flat1559 = try_flat(pp, msg, pretty_iceberg_locator_table_name) - if !isnothing(flat1559) - write(pp, flat1559) + flat1569 = try_flat(pp, msg, pretty_iceberg_locator_table_name) + if !isnothing(flat1569) + write(pp, flat1569) return nothing else - fields1558 = msg + fields1568 = msg write(pp, "(table_name") indent_sexp!(pp) newline(pp) - write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, fields1558)) + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, fields1568)) dedent!(pp) write(pp, ")") end @@ -4556,22 +4587,22 @@ function pretty_iceberg_locator_table_name(pp::PrettyPrinter, msg::String) end function pretty_iceberg_locator_namespace(pp::PrettyPrinter, msg::Vector{String}) - flat1563 = try_flat(pp, msg, pretty_iceberg_locator_namespace) - if !isnothing(flat1563) - write(pp, flat1563) + flat1573 = try_flat(pp, msg, pretty_iceberg_locator_namespace) + if !isnothing(flat1573) + write(pp, flat1573) return nothing else - fields1560 = msg + fields1570 = msg write(pp, "(namespace") indent_sexp!(pp) - if !isempty(fields1560) + if !isempty(fields1570) newline(pp) - for (i1879, elem1561) in enumerate(fields1560) - i1562 = i1879 - 1 - if (i1562 > 0) + for (i1890, elem1571) in enumerate(fields1570) + i1572 = i1890 - 1 + if (i1572 > 0) newline(pp) end - write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, elem1561)) + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, elem1571)) end end dedent!(pp) @@ -4581,16 +4612,16 @@ function pretty_iceberg_locator_namespace(pp::PrettyPrinter, msg::Vector{String} end function pretty_iceberg_locator_warehouse(pp::PrettyPrinter, msg::String) - flat1565 = try_flat(pp, msg, pretty_iceberg_locator_warehouse) - if !isnothing(flat1565) - write(pp, flat1565) + flat1575 = try_flat(pp, msg, pretty_iceberg_locator_warehouse) + if !isnothing(flat1575) + write(pp, flat1575) return nothing else - fields1564 = msg + fields1574 = msg write(pp, "(warehouse") indent_sexp!(pp) newline(pp) - write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, fields1564)) + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, fields1574)) dedent!(pp) write(pp, ")") end @@ -4598,32 +4629,32 @@ function pretty_iceberg_locator_warehouse(pp::PrettyPrinter, msg::String) end function pretty_iceberg_catalog_config(pp::PrettyPrinter, msg::Proto.IcebergCatalogConfig) - flat1573 = try_flat(pp, msg, pretty_iceberg_catalog_config) - if !isnothing(flat1573) - write(pp, flat1573) + flat1583 = try_flat(pp, msg, pretty_iceberg_catalog_config) + if !isnothing(flat1583) + write(pp, flat1583) return nothing else _dollar_dollar = msg - _t1880 = deconstruct_iceberg_catalog_config_scope_optional(pp, _dollar_dollar) - fields1566 = (_dollar_dollar.catalog_uri, _t1880, sort([(k, v) for (k, v) in _dollar_dollar.properties]), sort([(k, v) for (k, v) in _dollar_dollar.auth_properties]),) - unwrapped_fields1567 = fields1566 + _t1891 = deconstruct_iceberg_catalog_config_scope_optional(pp, _dollar_dollar) + fields1576 = (_dollar_dollar.catalog_uri, _t1891, sort([(k, v) for (k, v) in _dollar_dollar.properties]), sort([(k, v) for (k, v) in _dollar_dollar.auth_properties]),) + unwrapped_fields1577 = fields1576 write(pp, "(iceberg_catalog_config") indent_sexp!(pp) newline(pp) - field1568 = unwrapped_fields1567[1] - pretty_iceberg_catalog_uri(pp, field1568) - field1569 = unwrapped_fields1567[2] - if !isnothing(field1569) + field1578 = unwrapped_fields1577[1] + pretty_iceberg_catalog_uri(pp, field1578) + field1579 = unwrapped_fields1577[2] + if !isnothing(field1579) newline(pp) - opt_val1570 = field1569 - pretty_iceberg_catalog_config_scope(pp, opt_val1570) + opt_val1580 = field1579 + pretty_iceberg_catalog_config_scope(pp, opt_val1580) end newline(pp) - field1571 = unwrapped_fields1567[3] - pretty_iceberg_properties(pp, field1571) + field1581 = unwrapped_fields1577[3] + pretty_iceberg_properties(pp, field1581) newline(pp) - field1572 = unwrapped_fields1567[4] - pretty_iceberg_auth_properties(pp, field1572) + field1582 = unwrapped_fields1577[4] + pretty_iceberg_auth_properties(pp, field1582) dedent!(pp) write(pp, ")") end @@ -4631,16 +4662,16 @@ function pretty_iceberg_catalog_config(pp::PrettyPrinter, msg::Proto.IcebergCata end function pretty_iceberg_catalog_uri(pp::PrettyPrinter, msg::String) - flat1575 = try_flat(pp, msg, pretty_iceberg_catalog_uri) - if !isnothing(flat1575) - write(pp, flat1575) + flat1585 = try_flat(pp, msg, pretty_iceberg_catalog_uri) + if !isnothing(flat1585) + write(pp, flat1585) return nothing else - fields1574 = msg + fields1584 = msg write(pp, "(catalog_uri") indent_sexp!(pp) newline(pp) - write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, fields1574)) + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, fields1584)) dedent!(pp) write(pp, ")") end @@ -4648,16 +4679,16 @@ function pretty_iceberg_catalog_uri(pp::PrettyPrinter, msg::String) end function pretty_iceberg_catalog_config_scope(pp::PrettyPrinter, msg::String) - flat1577 = try_flat(pp, msg, pretty_iceberg_catalog_config_scope) - if !isnothing(flat1577) - write(pp, flat1577) + flat1587 = try_flat(pp, msg, pretty_iceberg_catalog_config_scope) + if !isnothing(flat1587) + write(pp, flat1587) return nothing else - fields1576 = msg + fields1586 = msg write(pp, "(scope") indent_sexp!(pp) newline(pp) - write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, fields1576)) + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, fields1586)) dedent!(pp) write(pp, ")") end @@ -4665,22 +4696,22 @@ function pretty_iceberg_catalog_config_scope(pp::PrettyPrinter, msg::String) end function pretty_iceberg_properties(pp::PrettyPrinter, msg::Vector{Tuple{String, String}}) - flat1581 = try_flat(pp, msg, pretty_iceberg_properties) - if !isnothing(flat1581) - write(pp, flat1581) + flat1591 = try_flat(pp, msg, pretty_iceberg_properties) + if !isnothing(flat1591) + write(pp, flat1591) return nothing else - fields1578 = msg + fields1588 = msg write(pp, "(properties") indent_sexp!(pp) - if !isempty(fields1578) + if !isempty(fields1588) newline(pp) - for (i1881, elem1579) in enumerate(fields1578) - i1580 = i1881 - 1 - if (i1580 > 0) + for (i1892, elem1589) in enumerate(fields1588) + i1590 = i1892 - 1 + if (i1590 > 0) newline(pp) end - pretty_iceberg_property_entry(pp, elem1579) + pretty_iceberg_property_entry(pp, elem1589) end end dedent!(pp) @@ -4690,22 +4721,22 @@ function pretty_iceberg_properties(pp::PrettyPrinter, msg::Vector{Tuple{String, end function pretty_iceberg_property_entry(pp::PrettyPrinter, msg::Tuple{String, String}) - flat1586 = try_flat(pp, msg, pretty_iceberg_property_entry) - if !isnothing(flat1586) - write(pp, flat1586) + flat1596 = try_flat(pp, msg, pretty_iceberg_property_entry) + if !isnothing(flat1596) + write(pp, flat1596) return nothing else _dollar_dollar = msg - fields1582 = (_dollar_dollar[1], _dollar_dollar[2],) - unwrapped_fields1583 = fields1582 + fields1592 = (_dollar_dollar[1], _dollar_dollar[2],) + unwrapped_fields1593 = fields1592 write(pp, "(prop") indent_sexp!(pp) newline(pp) - field1584 = unwrapped_fields1583[1] - write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, field1584)) + field1594 = unwrapped_fields1593[1] + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, field1594)) newline(pp) - field1585 = unwrapped_fields1583[2] - write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, field1585)) + field1595 = unwrapped_fields1593[2] + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, field1595)) dedent!(pp) write(pp, ")") end @@ -4713,22 +4744,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}}) - flat1590 = try_flat(pp, msg, pretty_iceberg_auth_properties) - if !isnothing(flat1590) - write(pp, flat1590) + flat1600 = try_flat(pp, msg, pretty_iceberg_auth_properties) + if !isnothing(flat1600) + write(pp, flat1600) return nothing else - fields1587 = msg + fields1597 = msg write(pp, "(auth_properties") indent_sexp!(pp) - if !isempty(fields1587) + if !isempty(fields1597) newline(pp) - for (i1882, elem1588) in enumerate(fields1587) - i1589 = i1882 - 1 - if (i1589 > 0) + for (i1893, elem1598) in enumerate(fields1597) + i1599 = i1893 - 1 + if (i1599 > 0) newline(pp) end - pretty_iceberg_masked_property_entry(pp, elem1588) + pretty_iceberg_masked_property_entry(pp, elem1598) end end dedent!(pp) @@ -4738,23 +4769,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}) - flat1595 = try_flat(pp, msg, pretty_iceberg_masked_property_entry) - if !isnothing(flat1595) - write(pp, flat1595) + flat1605 = try_flat(pp, msg, pretty_iceberg_masked_property_entry) + if !isnothing(flat1605) + write(pp, flat1605) return nothing else _dollar_dollar = msg - _t1883 = mask_secret_value(pp, _dollar_dollar) - fields1591 = (_dollar_dollar[1], _t1883,) - unwrapped_fields1592 = fields1591 + _t1894 = mask_secret_value(pp, _dollar_dollar) + fields1601 = (_dollar_dollar[1], _t1894,) + unwrapped_fields1602 = fields1601 write(pp, "(prop") indent_sexp!(pp) newline(pp) - field1593 = unwrapped_fields1592[1] - write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, field1593)) + field1603 = unwrapped_fields1602[1] + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, field1603)) newline(pp) - field1594 = unwrapped_fields1592[2] - write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, field1594)) + field1604 = unwrapped_fields1602[2] + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, field1604)) dedent!(pp) write(pp, ")") end @@ -4762,16 +4793,16 @@ function pretty_iceberg_masked_property_entry(pp::PrettyPrinter, msg::Tuple{Stri end function pretty_iceberg_from_snapshot(pp::PrettyPrinter, msg::String) - flat1597 = try_flat(pp, msg, pretty_iceberg_from_snapshot) - if !isnothing(flat1597) - write(pp, flat1597) + flat1607 = try_flat(pp, msg, pretty_iceberg_from_snapshot) + if !isnothing(flat1607) + write(pp, flat1607) return nothing else - fields1596 = msg + fields1606 = msg write(pp, "(from_snapshot") indent_sexp!(pp) newline(pp) - write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, fields1596)) + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, fields1606)) dedent!(pp) write(pp, ")") end @@ -4779,16 +4810,16 @@ function pretty_iceberg_from_snapshot(pp::PrettyPrinter, msg::String) end function pretty_iceberg_to_snapshot(pp::PrettyPrinter, msg::String) - flat1599 = try_flat(pp, msg, pretty_iceberg_to_snapshot) - if !isnothing(flat1599) - write(pp, flat1599) + flat1609 = try_flat(pp, msg, pretty_iceberg_to_snapshot) + if !isnothing(flat1609) + write(pp, flat1609) return nothing else - fields1598 = msg + fields1608 = msg write(pp, "(to_snapshot") indent_sexp!(pp) newline(pp) - write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, fields1598)) + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, fields1608)) dedent!(pp) write(pp, ")") end @@ -4796,18 +4827,18 @@ function pretty_iceberg_to_snapshot(pp::PrettyPrinter, msg::String) end function pretty_undefine(pp::PrettyPrinter, msg::Proto.Undefine) - flat1602 = try_flat(pp, msg, pretty_undefine) - if !isnothing(flat1602) - write(pp, flat1602) + flat1612 = try_flat(pp, msg, pretty_undefine) + if !isnothing(flat1612) + write(pp, flat1612) return nothing else _dollar_dollar = msg - fields1600 = _dollar_dollar.fragment_id - unwrapped_fields1601 = fields1600 + fields1610 = _dollar_dollar.fragment_id + unwrapped_fields1611 = fields1610 write(pp, "(undefine") indent_sexp!(pp) newline(pp) - pretty_fragment_id(pp, unwrapped_fields1601) + pretty_fragment_id(pp, unwrapped_fields1611) dedent!(pp) write(pp, ")") end @@ -4815,24 +4846,24 @@ function pretty_undefine(pp::PrettyPrinter, msg::Proto.Undefine) end function pretty_context(pp::PrettyPrinter, msg::Proto.Context) - flat1607 = try_flat(pp, msg, pretty_context) - if !isnothing(flat1607) - write(pp, flat1607) + flat1617 = try_flat(pp, msg, pretty_context) + if !isnothing(flat1617) + write(pp, flat1617) return nothing else _dollar_dollar = msg - fields1603 = _dollar_dollar.relations - unwrapped_fields1604 = fields1603 + fields1613 = _dollar_dollar.relations + unwrapped_fields1614 = fields1613 write(pp, "(context") indent_sexp!(pp) - if !isempty(unwrapped_fields1604) + if !isempty(unwrapped_fields1614) newline(pp) - for (i1884, elem1605) in enumerate(unwrapped_fields1604) - i1606 = i1884 - 1 - if (i1606 > 0) + for (i1895, elem1615) in enumerate(unwrapped_fields1614) + i1616 = i1895 - 1 + if (i1616 > 0) newline(pp) end - pretty_relation_id(pp, elem1605) + pretty_relation_id(pp, elem1615) end end dedent!(pp) @@ -4842,28 +4873,28 @@ function pretty_context(pp::PrettyPrinter, msg::Proto.Context) end function pretty_snapshot(pp::PrettyPrinter, msg::Proto.Snapshot) - flat1614 = try_flat(pp, msg, pretty_snapshot) - if !isnothing(flat1614) - write(pp, flat1614) + flat1624 = try_flat(pp, msg, pretty_snapshot) + if !isnothing(flat1624) + write(pp, flat1624) return nothing else _dollar_dollar = msg - fields1608 = (_dollar_dollar.prefix, _dollar_dollar.mappings,) - unwrapped_fields1609 = fields1608 + fields1618 = (_dollar_dollar.prefix, _dollar_dollar.mappings,) + unwrapped_fields1619 = fields1618 write(pp, "(snapshot") indent_sexp!(pp) newline(pp) - field1610 = unwrapped_fields1609[1] - pretty_edb_path(pp, field1610) - field1611 = unwrapped_fields1609[2] - if !isempty(field1611) + field1620 = unwrapped_fields1619[1] + pretty_edb_path(pp, field1620) + field1621 = unwrapped_fields1619[2] + if !isempty(field1621) newline(pp) - for (i1885, elem1612) in enumerate(field1611) - i1613 = i1885 - 1 - if (i1613 > 0) + for (i1896, elem1622) in enumerate(field1621) + i1623 = i1896 - 1 + if (i1623 > 0) newline(pp) end - pretty_snapshot_mapping(pp, elem1612) + pretty_snapshot_mapping(pp, elem1622) end end dedent!(pp) @@ -4873,40 +4904,40 @@ function pretty_snapshot(pp::PrettyPrinter, msg::Proto.Snapshot) end function pretty_snapshot_mapping(pp::PrettyPrinter, msg::Proto.SnapshotMapping) - flat1619 = try_flat(pp, msg, pretty_snapshot_mapping) - if !isnothing(flat1619) - write(pp, flat1619) + flat1629 = try_flat(pp, msg, pretty_snapshot_mapping) + if !isnothing(flat1629) + write(pp, flat1629) return nothing else _dollar_dollar = msg - fields1615 = (_dollar_dollar.destination_path, _dollar_dollar.source_relation,) - unwrapped_fields1616 = fields1615 - field1617 = unwrapped_fields1616[1] - pretty_edb_path(pp, field1617) + fields1625 = (_dollar_dollar.destination_path, _dollar_dollar.source_relation,) + unwrapped_fields1626 = fields1625 + field1627 = unwrapped_fields1626[1] + pretty_edb_path(pp, field1627) write(pp, " ") - field1618 = unwrapped_fields1616[2] - pretty_relation_id(pp, field1618) + field1628 = unwrapped_fields1626[2] + pretty_relation_id(pp, field1628) end return nothing end function pretty_epoch_reads(pp::PrettyPrinter, msg::Vector{Proto.Read}) - flat1623 = try_flat(pp, msg, pretty_epoch_reads) - if !isnothing(flat1623) - write(pp, flat1623) + flat1633 = try_flat(pp, msg, pretty_epoch_reads) + if !isnothing(flat1633) + write(pp, flat1633) return nothing else - fields1620 = msg + fields1630 = msg write(pp, "(reads") indent_sexp!(pp) - if !isempty(fields1620) + if !isempty(fields1630) newline(pp) - for (i1886, elem1621) in enumerate(fields1620) - i1622 = i1886 - 1 - if (i1622 > 0) + for (i1897, elem1631) in enumerate(fields1630) + i1632 = i1897 - 1 + if (i1632 > 0) newline(pp) end - pretty_read(pp, elem1621) + pretty_read(pp, elem1631) end end dedent!(pp) @@ -4916,65 +4947,65 @@ function pretty_epoch_reads(pp::PrettyPrinter, msg::Vector{Proto.Read}) end function pretty_read(pp::PrettyPrinter, msg::Proto.Read) - flat1634 = try_flat(pp, msg, pretty_read) - if !isnothing(flat1634) - write(pp, flat1634) + flat1644 = try_flat(pp, msg, pretty_read) + if !isnothing(flat1644) + write(pp, flat1644) return nothing else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("demand")) - _t1887 = _get_oneof_field(_dollar_dollar, :demand) + _t1898 = _get_oneof_field(_dollar_dollar, :demand) else - _t1887 = nothing + _t1898 = nothing end - deconstruct_result1632 = _t1887 - if !isnothing(deconstruct_result1632) - unwrapped1633 = deconstruct_result1632 - pretty_demand(pp, unwrapped1633) + deconstruct_result1642 = _t1898 + if !isnothing(deconstruct_result1642) + unwrapped1643 = deconstruct_result1642 + pretty_demand(pp, unwrapped1643) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("output")) - _t1888 = _get_oneof_field(_dollar_dollar, :output) + _t1899 = _get_oneof_field(_dollar_dollar, :output) else - _t1888 = nothing + _t1899 = nothing end - deconstruct_result1630 = _t1888 - if !isnothing(deconstruct_result1630) - unwrapped1631 = deconstruct_result1630 - pretty_output(pp, unwrapped1631) + deconstruct_result1640 = _t1899 + if !isnothing(deconstruct_result1640) + unwrapped1641 = deconstruct_result1640 + pretty_output(pp, unwrapped1641) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("what_if")) - _t1889 = _get_oneof_field(_dollar_dollar, :what_if) + _t1900 = _get_oneof_field(_dollar_dollar, :what_if) else - _t1889 = nothing + _t1900 = nothing end - deconstruct_result1628 = _t1889 - if !isnothing(deconstruct_result1628) - unwrapped1629 = deconstruct_result1628 - pretty_what_if(pp, unwrapped1629) + deconstruct_result1638 = _t1900 + if !isnothing(deconstruct_result1638) + unwrapped1639 = deconstruct_result1638 + pretty_what_if(pp, unwrapped1639) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("abort")) - _t1890 = _get_oneof_field(_dollar_dollar, :abort) + _t1901 = _get_oneof_field(_dollar_dollar, :abort) else - _t1890 = nothing + _t1901 = nothing end - deconstruct_result1626 = _t1890 - if !isnothing(deconstruct_result1626) - unwrapped1627 = deconstruct_result1626 - pretty_abort(pp, unwrapped1627) + deconstruct_result1636 = _t1901 + if !isnothing(deconstruct_result1636) + unwrapped1637 = deconstruct_result1636 + pretty_abort(pp, unwrapped1637) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("#export")) - _t1891 = _get_oneof_field(_dollar_dollar, :var"#export") + _t1902 = _get_oneof_field(_dollar_dollar, :var"#export") else - _t1891 = nothing + _t1902 = nothing end - deconstruct_result1624 = _t1891 - if !isnothing(deconstruct_result1624) - unwrapped1625 = deconstruct_result1624 - pretty_export(pp, unwrapped1625) + deconstruct_result1634 = _t1902 + if !isnothing(deconstruct_result1634) + unwrapped1635 = deconstruct_result1634 + pretty_export(pp, unwrapped1635) else throw(ParseError("No matching rule for read")) end @@ -4987,18 +5018,18 @@ function pretty_read(pp::PrettyPrinter, msg::Proto.Read) end function pretty_demand(pp::PrettyPrinter, msg::Proto.Demand) - flat1637 = try_flat(pp, msg, pretty_demand) - if !isnothing(flat1637) - write(pp, flat1637) + flat1647 = try_flat(pp, msg, pretty_demand) + if !isnothing(flat1647) + write(pp, flat1647) return nothing else _dollar_dollar = msg - fields1635 = _dollar_dollar.relation_id - unwrapped_fields1636 = fields1635 + fields1645 = _dollar_dollar.relation_id + unwrapped_fields1646 = fields1645 write(pp, "(demand") indent_sexp!(pp) newline(pp) - pretty_relation_id(pp, unwrapped_fields1636) + pretty_relation_id(pp, unwrapped_fields1646) dedent!(pp) write(pp, ")") end @@ -5006,22 +5037,22 @@ function pretty_demand(pp::PrettyPrinter, msg::Proto.Demand) end function pretty_output(pp::PrettyPrinter, msg::Proto.Output) - flat1642 = try_flat(pp, msg, pretty_output) - if !isnothing(flat1642) - write(pp, flat1642) + flat1652 = try_flat(pp, msg, pretty_output) + if !isnothing(flat1652) + write(pp, flat1652) return nothing else _dollar_dollar = msg - fields1638 = (_dollar_dollar.name, _dollar_dollar.relation_id,) - unwrapped_fields1639 = fields1638 + fields1648 = (_dollar_dollar.name, _dollar_dollar.relation_id,) + unwrapped_fields1649 = fields1648 write(pp, "(output") indent_sexp!(pp) newline(pp) - field1640 = unwrapped_fields1639[1] - pretty_name(pp, field1640) + field1650 = unwrapped_fields1649[1] + pretty_name(pp, field1650) newline(pp) - field1641 = unwrapped_fields1639[2] - pretty_relation_id(pp, field1641) + field1651 = unwrapped_fields1649[2] + pretty_relation_id(pp, field1651) dedent!(pp) write(pp, ")") end @@ -5029,22 +5060,22 @@ function pretty_output(pp::PrettyPrinter, msg::Proto.Output) end function pretty_what_if(pp::PrettyPrinter, msg::Proto.WhatIf) - flat1647 = try_flat(pp, msg, pretty_what_if) - if !isnothing(flat1647) - write(pp, flat1647) + flat1657 = try_flat(pp, msg, pretty_what_if) + if !isnothing(flat1657) + write(pp, flat1657) return nothing else _dollar_dollar = msg - fields1643 = (_dollar_dollar.branch, _dollar_dollar.epoch,) - unwrapped_fields1644 = fields1643 + fields1653 = (_dollar_dollar.branch, _dollar_dollar.epoch,) + unwrapped_fields1654 = fields1653 write(pp, "(what_if") indent_sexp!(pp) newline(pp) - field1645 = unwrapped_fields1644[1] - pretty_name(pp, field1645) + field1655 = unwrapped_fields1654[1] + pretty_name(pp, field1655) newline(pp) - field1646 = unwrapped_fields1644[2] - pretty_epoch(pp, field1646) + field1656 = unwrapped_fields1654[2] + pretty_epoch(pp, field1656) dedent!(pp) write(pp, ")") end @@ -5052,30 +5083,30 @@ function pretty_what_if(pp::PrettyPrinter, msg::Proto.WhatIf) end function pretty_abort(pp::PrettyPrinter, msg::Proto.Abort) - flat1653 = try_flat(pp, msg, pretty_abort) - if !isnothing(flat1653) - write(pp, flat1653) + flat1663 = try_flat(pp, msg, pretty_abort) + if !isnothing(flat1663) + write(pp, flat1663) return nothing else _dollar_dollar = msg if _dollar_dollar.name != "abort" - _t1892 = _dollar_dollar.name + _t1903 = _dollar_dollar.name else - _t1892 = nothing + _t1903 = nothing end - fields1648 = (_t1892, _dollar_dollar.relation_id,) - unwrapped_fields1649 = fields1648 + fields1658 = (_t1903, _dollar_dollar.relation_id,) + unwrapped_fields1659 = fields1658 write(pp, "(abort") indent_sexp!(pp) - field1650 = unwrapped_fields1649[1] - if !isnothing(field1650) + field1660 = unwrapped_fields1659[1] + if !isnothing(field1660) newline(pp) - opt_val1651 = field1650 - pretty_name(pp, opt_val1651) + opt_val1661 = field1660 + pretty_name(pp, opt_val1661) end newline(pp) - field1652 = unwrapped_fields1649[2] - pretty_relation_id(pp, field1652) + field1662 = unwrapped_fields1659[2] + pretty_relation_id(pp, field1662) dedent!(pp) write(pp, ")") end @@ -5083,40 +5114,40 @@ function pretty_abort(pp::PrettyPrinter, msg::Proto.Abort) end function pretty_export(pp::PrettyPrinter, msg::Proto.Export) - flat1658 = try_flat(pp, msg, pretty_export) - if !isnothing(flat1658) - write(pp, flat1658) + flat1668 = try_flat(pp, msg, pretty_export) + if !isnothing(flat1668) + write(pp, flat1668) return nothing else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("csv_config")) - _t1893 = _get_oneof_field(_dollar_dollar, :csv_config) + _t1904 = _get_oneof_field(_dollar_dollar, :csv_config) else - _t1893 = nothing + _t1904 = nothing end - deconstruct_result1656 = _t1893 - if !isnothing(deconstruct_result1656) - unwrapped1657 = deconstruct_result1656 + deconstruct_result1666 = _t1904 + if !isnothing(deconstruct_result1666) + unwrapped1667 = deconstruct_result1666 write(pp, "(export") indent_sexp!(pp) newline(pp) - pretty_export_csv_config(pp, unwrapped1657) + pretty_export_csv_config(pp, unwrapped1667) dedent!(pp) write(pp, ")") else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("iceberg_config")) - _t1894 = _get_oneof_field(_dollar_dollar, :iceberg_config) + _t1905 = _get_oneof_field(_dollar_dollar, :iceberg_config) else - _t1894 = nothing + _t1905 = nothing end - deconstruct_result1654 = _t1894 - if !isnothing(deconstruct_result1654) - unwrapped1655 = deconstruct_result1654 + deconstruct_result1664 = _t1905 + if !isnothing(deconstruct_result1664) + unwrapped1665 = deconstruct_result1664 write(pp, "(export_iceberg") indent_sexp!(pp) newline(pp) - pretty_export_iceberg_config(pp, unwrapped1655) + pretty_export_iceberg_config(pp, unwrapped1665) dedent!(pp) write(pp, ")") else @@ -5128,56 +5159,56 @@ function pretty_export(pp::PrettyPrinter, msg::Proto.Export) end function pretty_export_csv_config(pp::PrettyPrinter, msg::Proto.ExportCSVConfig) - flat1669 = try_flat(pp, msg, pretty_export_csv_config) - if !isnothing(flat1669) - write(pp, flat1669) + flat1679 = try_flat(pp, msg, pretty_export_csv_config) + if !isnothing(flat1679) + write(pp, flat1679) return nothing else _dollar_dollar = msg if length(_dollar_dollar.data_columns) == 0 - _t1896 = deconstruct_export_csv_output_location(pp, _dollar_dollar) - _t1895 = (_t1896, _dollar_dollar.csv_source, _dollar_dollar.csv_config,) + _t1907 = deconstruct_export_csv_output_location(pp, _dollar_dollar) + _t1906 = (_t1907, _dollar_dollar.csv_source, _dollar_dollar.csv_config,) else - _t1895 = nothing + _t1906 = nothing end - deconstruct_result1664 = _t1895 - if !isnothing(deconstruct_result1664) - unwrapped1665 = deconstruct_result1664 + deconstruct_result1674 = _t1906 + if !isnothing(deconstruct_result1674) + unwrapped1675 = deconstruct_result1674 write(pp, "(export_csv_config_v2") indent_sexp!(pp) newline(pp) - field1666 = unwrapped1665[1] - pretty_export_csv_output_location(pp, field1666) + field1676 = unwrapped1675[1] + pretty_export_csv_output_location(pp, field1676) newline(pp) - field1667 = unwrapped1665[2] - pretty_export_csv_source(pp, field1667) + field1677 = unwrapped1675[2] + pretty_export_csv_source(pp, field1677) newline(pp) - field1668 = unwrapped1665[3] - pretty_csv_config(pp, field1668) + field1678 = unwrapped1675[3] + pretty_csv_config(pp, field1678) dedent!(pp) write(pp, ")") else _dollar_dollar = msg if length(_dollar_dollar.data_columns) != 0 - _t1898 = deconstruct_export_csv_config(pp, _dollar_dollar) - _t1897 = (_dollar_dollar.path, _dollar_dollar.data_columns, _t1898,) + _t1909 = deconstruct_export_csv_config(pp, _dollar_dollar) + _t1908 = (_dollar_dollar.path, _dollar_dollar.data_columns, _t1909,) else - _t1897 = nothing + _t1908 = nothing end - deconstruct_result1659 = _t1897 - if !isnothing(deconstruct_result1659) - unwrapped1660 = deconstruct_result1659 + deconstruct_result1669 = _t1908 + if !isnothing(deconstruct_result1669) + unwrapped1670 = deconstruct_result1669 write(pp, "(export_csv_config") indent_sexp!(pp) newline(pp) - field1661 = unwrapped1660[1] - pretty_export_csv_path(pp, field1661) + field1671 = unwrapped1670[1] + pretty_export_csv_path(pp, field1671) newline(pp) - field1662 = unwrapped1660[2] - pretty_export_csv_columns_list(pp, field1662) + field1672 = unwrapped1670[2] + pretty_export_csv_columns_list(pp, field1672) newline(pp) - field1663 = unwrapped1660[3] - pretty_config_dict(pp, field1663) + field1673 = unwrapped1670[3] + pretty_config_dict(pp, field1673) dedent!(pp) write(pp, ")") else @@ -5189,40 +5220,40 @@ function pretty_export_csv_config(pp::PrettyPrinter, msg::Proto.ExportCSVConfig) end function pretty_export_csv_output_location(pp::PrettyPrinter, msg::Tuple{String, String}) - flat1674 = try_flat(pp, msg, pretty_export_csv_output_location) - if !isnothing(flat1674) - write(pp, flat1674) + flat1684 = try_flat(pp, msg, pretty_export_csv_output_location) + if !isnothing(flat1684) + write(pp, flat1684) return nothing else _dollar_dollar = msg if _dollar_dollar[1] != "" - _t1899 = _dollar_dollar[1] + _t1910 = _dollar_dollar[1] else - _t1899 = nothing + _t1910 = nothing end - deconstruct_result1672 = _t1899 - if !isnothing(deconstruct_result1672) - unwrapped1673 = deconstruct_result1672 + deconstruct_result1682 = _t1910 + if !isnothing(deconstruct_result1682) + unwrapped1683 = deconstruct_result1682 write(pp, "(path") indent_sexp!(pp) newline(pp) - write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, unwrapped1673)) + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, unwrapped1683)) dedent!(pp) write(pp, ")") else _dollar_dollar = msg if _dollar_dollar[2] != "" - _t1900 = _dollar_dollar[2] + _t1911 = _dollar_dollar[2] else - _t1900 = nothing + _t1911 = nothing end - deconstruct_result1670 = _t1900 - if !isnothing(deconstruct_result1670) - unwrapped1671 = deconstruct_result1670 + deconstruct_result1680 = _t1911 + if !isnothing(deconstruct_result1680) + unwrapped1681 = deconstruct_result1680 write(pp, "(transaction_output_name") indent_sexp!(pp) newline(pp) - pretty_name(pp, unwrapped1671) + pretty_name(pp, unwrapped1681) dedent!(pp) write(pp, ")") else @@ -5234,30 +5265,30 @@ function pretty_export_csv_output_location(pp::PrettyPrinter, msg::Tuple{String, end function pretty_export_csv_source(pp::PrettyPrinter, msg::Proto.ExportCSVSource) - flat1681 = try_flat(pp, msg, pretty_export_csv_source) - if !isnothing(flat1681) - write(pp, flat1681) + flat1691 = try_flat(pp, msg, pretty_export_csv_source) + if !isnothing(flat1691) + write(pp, flat1691) return nothing else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("gnf_columns")) - _t1901 = _get_oneof_field(_dollar_dollar, :gnf_columns).columns + _t1912 = _get_oneof_field(_dollar_dollar, :gnf_columns).columns else - _t1901 = nothing + _t1912 = nothing end - deconstruct_result1677 = _t1901 - if !isnothing(deconstruct_result1677) - unwrapped1678 = deconstruct_result1677 + deconstruct_result1687 = _t1912 + if !isnothing(deconstruct_result1687) + unwrapped1688 = deconstruct_result1687 write(pp, "(gnf_columns") indent_sexp!(pp) - if !isempty(unwrapped1678) + if !isempty(unwrapped1688) newline(pp) - for (i1902, elem1679) in enumerate(unwrapped1678) - i1680 = i1902 - 1 - if (i1680 > 0) + for (i1913, elem1689) in enumerate(unwrapped1688) + i1690 = i1913 - 1 + if (i1690 > 0) newline(pp) end - pretty_export_csv_column(pp, elem1679) + pretty_export_csv_column(pp, elem1689) end end dedent!(pp) @@ -5265,17 +5296,17 @@ function pretty_export_csv_source(pp::PrettyPrinter, msg::Proto.ExportCSVSource) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("table_def")) - _t1903 = _get_oneof_field(_dollar_dollar, :table_def) + _t1914 = _get_oneof_field(_dollar_dollar, :table_def) else - _t1903 = nothing + _t1914 = nothing end - deconstruct_result1675 = _t1903 - if !isnothing(deconstruct_result1675) - unwrapped1676 = deconstruct_result1675 + deconstruct_result1685 = _t1914 + if !isnothing(deconstruct_result1685) + unwrapped1686 = deconstruct_result1685 write(pp, "(table_def") indent_sexp!(pp) newline(pp) - pretty_relation_id(pp, unwrapped1676) + pretty_relation_id(pp, unwrapped1686) dedent!(pp) write(pp, ")") else @@ -5287,22 +5318,22 @@ function pretty_export_csv_source(pp::PrettyPrinter, msg::Proto.ExportCSVSource) end function pretty_export_csv_column(pp::PrettyPrinter, msg::Proto.ExportCSVColumn) - flat1686 = try_flat(pp, msg, pretty_export_csv_column) - if !isnothing(flat1686) - write(pp, flat1686) + flat1696 = try_flat(pp, msg, pretty_export_csv_column) + if !isnothing(flat1696) + write(pp, flat1696) return nothing else _dollar_dollar = msg - fields1682 = (_dollar_dollar.column_name, _dollar_dollar.column_data,) - unwrapped_fields1683 = fields1682 + fields1692 = (_dollar_dollar.column_name, _dollar_dollar.column_data,) + unwrapped_fields1693 = fields1692 write(pp, "(column") indent_sexp!(pp) newline(pp) - field1684 = unwrapped_fields1683[1] - write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, field1684)) + field1694 = unwrapped_fields1693[1] + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, field1694)) newline(pp) - field1685 = unwrapped_fields1683[2] - pretty_relation_id(pp, field1685) + field1695 = unwrapped_fields1693[2] + pretty_relation_id(pp, field1695) dedent!(pp) write(pp, ")") end @@ -5310,16 +5341,16 @@ function pretty_export_csv_column(pp::PrettyPrinter, msg::Proto.ExportCSVColumn) end function pretty_export_csv_path(pp::PrettyPrinter, msg::String) - flat1688 = try_flat(pp, msg, pretty_export_csv_path) - if !isnothing(flat1688) - write(pp, flat1688) + flat1698 = try_flat(pp, msg, pretty_export_csv_path) + if !isnothing(flat1698) + write(pp, flat1698) return nothing else - fields1687 = msg + fields1697 = msg write(pp, "(path") indent_sexp!(pp) newline(pp) - write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, fields1687)) + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, fields1697)) dedent!(pp) write(pp, ")") end @@ -5327,22 +5358,22 @@ function pretty_export_csv_path(pp::PrettyPrinter, msg::String) end function pretty_export_csv_columns_list(pp::PrettyPrinter, msg::Vector{Proto.ExportCSVColumn}) - flat1692 = try_flat(pp, msg, pretty_export_csv_columns_list) - if !isnothing(flat1692) - write(pp, flat1692) + flat1702 = try_flat(pp, msg, pretty_export_csv_columns_list) + if !isnothing(flat1702) + write(pp, flat1702) return nothing else - fields1689 = msg + fields1699 = msg write(pp, "(columns") indent_sexp!(pp) - if !isempty(fields1689) + if !isempty(fields1699) newline(pp) - for (i1904, elem1690) in enumerate(fields1689) - i1691 = i1904 - 1 - if (i1691 > 0) + for (i1915, elem1700) in enumerate(fields1699) + i1701 = i1915 - 1 + if (i1701 > 0) newline(pp) end - pretty_export_csv_column(pp, elem1690) + pretty_export_csv_column(pp, elem1700) end end dedent!(pp) @@ -5352,34 +5383,34 @@ function pretty_export_csv_columns_list(pp::PrettyPrinter, msg::Vector{Proto.Exp end function pretty_export_iceberg_config(pp::PrettyPrinter, msg::Proto.ExportIcebergConfig) - flat1701 = try_flat(pp, msg, pretty_export_iceberg_config) - if !isnothing(flat1701) - write(pp, flat1701) + flat1711 = try_flat(pp, msg, pretty_export_iceberg_config) + if !isnothing(flat1711) + write(pp, flat1711) return nothing else _dollar_dollar = msg - _t1905 = deconstruct_export_iceberg_config_optional(pp, _dollar_dollar) - fields1693 = (_dollar_dollar.locator, _dollar_dollar.config, _dollar_dollar.table_def, sort([(k, v) for (k, v) in _dollar_dollar.table_properties]), _t1905,) - unwrapped_fields1694 = fields1693 + _t1916 = deconstruct_export_iceberg_config_optional(pp, _dollar_dollar) + fields1703 = (_dollar_dollar.locator, _dollar_dollar.config, _dollar_dollar.table_def, sort([(k, v) for (k, v) in _dollar_dollar.table_properties]), _t1916,) + unwrapped_fields1704 = fields1703 write(pp, "(export_iceberg_config") indent_sexp!(pp) newline(pp) - field1695 = unwrapped_fields1694[1] - pretty_iceberg_locator(pp, field1695) + field1705 = unwrapped_fields1704[1] + pretty_iceberg_locator(pp, field1705) newline(pp) - field1696 = unwrapped_fields1694[2] - pretty_iceberg_catalog_config(pp, field1696) + field1706 = unwrapped_fields1704[2] + pretty_iceberg_catalog_config(pp, field1706) newline(pp) - field1697 = unwrapped_fields1694[3] - pretty_export_iceberg_table_def(pp, field1697) + field1707 = unwrapped_fields1704[3] + pretty_export_iceberg_table_def(pp, field1707) newline(pp) - field1698 = unwrapped_fields1694[4] - pretty_iceberg_table_properties(pp, field1698) - field1699 = unwrapped_fields1694[5] - if !isnothing(field1699) + field1708 = unwrapped_fields1704[4] + pretty_iceberg_table_properties(pp, field1708) + field1709 = unwrapped_fields1704[5] + if !isnothing(field1709) newline(pp) - opt_val1700 = field1699 - pretty_config_dict(pp, opt_val1700) + opt_val1710 = field1709 + pretty_config_dict(pp, opt_val1710) end dedent!(pp) write(pp, ")") @@ -5388,16 +5419,16 @@ function pretty_export_iceberg_config(pp::PrettyPrinter, msg::Proto.ExportIceber end function pretty_export_iceberg_table_def(pp::PrettyPrinter, msg::Proto.RelationId) - flat1703 = try_flat(pp, msg, pretty_export_iceberg_table_def) - if !isnothing(flat1703) - write(pp, flat1703) + flat1713 = try_flat(pp, msg, pretty_export_iceberg_table_def) + if !isnothing(flat1713) + write(pp, flat1713) return nothing else - fields1702 = msg + fields1712 = msg write(pp, "(table_def") indent_sexp!(pp) newline(pp) - pretty_relation_id(pp, fields1702) + pretty_relation_id(pp, fields1712) dedent!(pp) write(pp, ")") end @@ -5405,22 +5436,22 @@ function pretty_export_iceberg_table_def(pp::PrettyPrinter, msg::Proto.RelationI end function pretty_iceberg_table_properties(pp::PrettyPrinter, msg::Vector{Tuple{String, String}}) - flat1707 = try_flat(pp, msg, pretty_iceberg_table_properties) - if !isnothing(flat1707) - write(pp, flat1707) + flat1717 = try_flat(pp, msg, pretty_iceberg_table_properties) + if !isnothing(flat1717) + write(pp, flat1717) return nothing else - fields1704 = msg + fields1714 = msg write(pp, "(table_properties") indent_sexp!(pp) - if !isempty(fields1704) + if !isempty(fields1714) newline(pp) - for (i1906, elem1705) in enumerate(fields1704) - i1706 = i1906 - 1 - if (i1706 > 0) + for (i1917, elem1715) in enumerate(fields1714) + i1716 = i1917 - 1 + if (i1716 > 0) newline(pp) end - pretty_iceberg_property_entry(pp, elem1705) + pretty_iceberg_property_entry(pp, elem1715) end end dedent!(pp) @@ -5435,12 +5466,12 @@ end function pretty_debug_info(pp::PrettyPrinter, msg::Proto.DebugInfo) write(pp, "(debug_info") indent_sexp!(pp) - for (i1961, _rid) in enumerate(msg.ids) - _idx = i1961 - 1 + for (i1972, _rid) in enumerate(msg.ids) + _idx = i1972 - 1 newline(pp) write(pp, "(") - _t1962 = Proto.UInt128Value(low=_rid.id_low, high=_rid.id_high) - _pprint_dispatch(pp, _t1962) + _t1973 = Proto.UInt128Value(low=_rid.id_low, high=_rid.id_high) + _pprint_dispatch(pp, _t1973) write(pp, " ") write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, msg.orig_names[_idx + 1])) write(pp, ")") @@ -5504,8 +5535,8 @@ function pretty_cdc_targets(pp::PrettyPrinter, msg::Proto.CDCTargets) indent_sexp!(pp) newline(pp) write(pp, ":inserts (") - for (i1963, _elem) in enumerate(msg.inserts) - _idx = i1963 - 1 + for (i1974, _elem) in enumerate(msg.inserts) + _idx = i1974 - 1 if (_idx > 0) write(pp, " ") end @@ -5514,8 +5545,8 @@ function pretty_cdc_targets(pp::PrettyPrinter, msg::Proto.CDCTargets) write(pp, ")") newline(pp) write(pp, ":deletes (") - for (i1964, _elem) in enumerate(msg.deletes) - _idx = i1964 - 1 + for (i1975, _elem) in enumerate(msg.deletes) + _idx = i1975 - 1 if (_idx > 0) write(pp, " ") end @@ -5539,8 +5570,8 @@ function pretty_functional_dependency(pp::PrettyPrinter, msg::Proto.FunctionalDe _pprint_dispatch(pp, msg.guard) newline(pp) write(pp, ":keys (") - for (i1965, _elem) in enumerate(msg.keys) - _idx = i1965 - 1 + for (i1976, _elem) in enumerate(msg.keys) + _idx = i1976 - 1 if (_idx > 0) write(pp, " ") end @@ -5549,8 +5580,8 @@ function pretty_functional_dependency(pp::PrettyPrinter, msg::Proto.FunctionalDe write(pp, ")") newline(pp) write(pp, ":values (") - for (i1966, _elem) in enumerate(msg.values) - _idx = i1966 - 1 + for (i1977, _elem) in enumerate(msg.values) + _idx = i1977 - 1 if (_idx > 0) write(pp, " ") end @@ -5576,8 +5607,8 @@ function pretty_plain_targets(pp::PrettyPrinter, msg::Proto.PlainTargets) indent_sexp!(pp) newline(pp) write(pp, ":targets (") - for (i1967, _elem) in enumerate(msg.targets) - _idx = i1967 - 1 + for (i1978, _elem) in enumerate(msg.targets) + _idx = i1978 - 1 if (_idx > 0) write(pp, " ") end @@ -5621,8 +5652,8 @@ function pretty_export_csv_columns(pp::PrettyPrinter, msg::Proto.ExportCSVColumn indent_sexp!(pp) newline(pp) write(pp, ":columns (") - for (i1968, _elem) in enumerate(msg.columns) - _idx = i1968 - 1 + for (i1979, _elem) in enumerate(msg.columns) + _idx = i1979 - 1 if (_idx > 0) write(pp, " ") end @@ -5700,6 +5731,7 @@ _pprint_dispatch(pp::PrettyPrinter, x::Proto.BooleanType) = pretty_boolean_type( _pprint_dispatch(pp::PrettyPrinter, x::Proto.Int32Type) = pretty_int32_type(pp, x) _pprint_dispatch(pp::PrettyPrinter, x::Proto.Float32Type) = pretty_float32_type(pp, x) _pprint_dispatch(pp::PrettyPrinter, x::Proto.UInt32Type) = pretty_uint32_type(pp, x) +_pprint_dispatch(pp::PrettyPrinter, x::Proto.FixedType) = pretty_fixed_type(pp, x) _pprint_dispatch(pp::PrettyPrinter, x::Vector{Proto.Binding}) = pretty_value_bindings(pp, x) _pprint_dispatch(pp::PrettyPrinter, x::Proto.Formula) = pretty_formula(pp, x) _pprint_dispatch(pp::PrettyPrinter, x::Proto.Conjunction) = pretty_conjunction(pp, x) diff --git a/sdks/julia/LogicalQueryProtocol.jl/test/equality_tests.jl b/sdks/julia/LogicalQueryProtocol.jl/test/equality_tests.jl index 59269651..6132c376 100644 --- a/sdks/julia/LogicalQueryProtocol.jl/test/equality_tests.jl +++ b/sdks/julia/LogicalQueryProtocol.jl/test/equality_tests.jl @@ -142,6 +142,20 @@ end @test u1 == u2 && u2 == u4 && u1 == u4 end +@testitem "Equality for FixedType" tags=[:ring1, :unit] begin + using LogicalQueryProtocol: FixedType + + ft1 = FixedType(length=16) + ft2 = FixedType(length=16) + ft3 = FixedType(length=8) + + @test ft1 == ft2 + @test ft1 != ft3 + @test isequal(ft1, ft2) + @test !isequal(ft1, ft3) + @test hash(ft1) == hash(ft2) +end + @testitem "Equality for DecimalType and DecimalValue" tags=[:ring1, :unit] begin using LogicalQueryProtocol: DecimalType, DecimalValue, Int128Value diff --git a/sdks/python/src/lqp/gen/parser.py b/sdks/python/src/lqp/gen/parser.py index c1608791..48c63395 100644 --- a/sdks/python/src/lqp/gen/parser.py +++ b/sdks/python/src/lqp/gen/parser.py @@ -425,218 +425,218 @@ def _extract_value_int32(self, value: logic_pb2.Value | None, default: int) -> i if value is None: return int(default) else: - _t2219 = None + _t2233 = None assert value is not None if value.HasField("int32_value"): assert value is not None return value.int32_value else: - _t2220 = None + _t2234 = None raise ParseError("expected an int32 value (e.g. `1i32`) for this config field") def _extract_value_int64(self, value: logic_pb2.Value | None, default: int) -> int: if value is not None: assert value is not None - _t2221 = value.HasField("int_value") + _t2235 = value.HasField("int_value") else: - _t2221 = False - if _t2221: + _t2235 = False + if _t2235: assert value is not None return value.int_value else: - _t2222 = None + _t2236 = 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 - _t2223 = value.HasField("string_value") + _t2237 = value.HasField("string_value") else: - _t2223 = False - if _t2223: + _t2237 = False + if _t2237: assert value is not None return value.string_value else: - _t2224 = None + _t2238 = 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 - _t2225 = value.HasField("boolean_value") + _t2239 = value.HasField("boolean_value") else: - _t2225 = False - if _t2225: + _t2239 = False + if _t2239: assert value is not None return value.boolean_value else: - _t2226 = None + _t2240 = 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 - _t2227 = value.HasField("string_value") + _t2241 = value.HasField("string_value") else: - _t2227 = False - if _t2227: + _t2241 = False + if _t2241: assert value is not None return [value.string_value] else: - _t2228 = None + _t2242 = 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 - _t2229 = value.HasField("int_value") + _t2243 = value.HasField("int_value") else: - _t2229 = False - if _t2229: + _t2243 = False + if _t2243: assert value is not None return value.int_value else: - _t2230 = None + _t2244 = 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 - _t2231 = value.HasField("float_value") + _t2245 = value.HasField("float_value") else: - _t2231 = False - if _t2231: + _t2245 = False + if _t2245: assert value is not None return value.float_value else: - _t2232 = None + _t2246 = 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 - _t2233 = value.HasField("string_value") + _t2247 = value.HasField("string_value") else: - _t2233 = False - if _t2233: + _t2247 = False + if _t2247: assert value is not None return value.string_value.encode() else: - _t2234 = None + _t2248 = 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 - _t2235 = value.HasField("uint128_value") + _t2249 = value.HasField("uint128_value") else: - _t2235 = False - if _t2235: + _t2249 = False + if _t2249: assert value is not None return value.uint128_value else: - _t2236 = None + _t2250 = None return None def construct_non_cdc_relations(self, targets: Sequence[logic_pb2.TargetRelation]) -> logic_pb2.TargetRelations: - _t2237 = logic_pb2.PlainTargets(targets=targets) - _t2238 = logic_pb2.TargetRelations(keys=[], plain=_t2237) - return _t2238 + _t2251 = logic_pb2.PlainTargets(targets=targets) + _t2252 = logic_pb2.TargetRelations(keys=[], plain=_t2251) + return _t2252 def construct_cdc_relations(self, inserts: Sequence[logic_pb2.TargetRelation], deletes: Sequence[logic_pb2.TargetRelation]) -> logic_pb2.TargetRelations: - _t2239 = logic_pb2.CDCTargets(inserts=inserts, deletes=deletes) - _t2240 = logic_pb2.TargetRelations(keys=[], cdc=_t2239) - return _t2240 + _t2253 = logic_pb2.CDCTargets(inserts=inserts, deletes=deletes) + _t2254 = logic_pb2.TargetRelations(keys=[], cdc=_t2253) + return _t2254 def construct_relations(self, keys: tuple[Sequence[logic_pb2.NamedColumn], bool], body: logic_pb2.TargetRelations, load_errors_opt: logic_pb2.RelationId | None) -> logic_pb2.TargetRelations: if body.HasField("plain"): - _t2242 = logic_pb2.TargetRelations(keys=keys[0], synthetic_key=keys[1], plain=body.plain, load_errors=load_errors_opt) - return _t2242 + _t2256 = logic_pb2.TargetRelations(keys=keys[0], synthetic_key=keys[1], plain=body.plain, load_errors=load_errors_opt) + return _t2256 else: - _t2241 = None - _t2243 = logic_pb2.TargetRelations(keys=keys[0], synthetic_key=keys[1], cdc=body.cdc, load_errors=load_errors_opt) - return _t2243 + _t2255 = None + _t2257 = logic_pb2.TargetRelations(keys=keys[0], synthetic_key=keys[1], cdc=body.cdc, load_errors=load_errors_opt) + return _t2257 def construct_csv_data(self, locator: logic_pb2.CSVLocator, config: logic_pb2.CSVConfig, columns_opt: Sequence[logic_pb2.GNFColumn] | None, relations_opt: logic_pb2.TargetRelations | None, asof: str) -> logic_pb2.CSVData: - _t2244 = logic_pb2.CSVData(locator=locator, config=config, columns=(columns_opt if columns_opt is not None else []), asof=asof, relations=relations_opt) - return _t2244 + _t2258 = logic_pb2.CSVData(locator=locator, config=config, columns=(columns_opt if columns_opt is not None else []), asof=asof, relations=relations_opt) + return _t2258 def construct_csv_config(self, config_dict: Sequence[tuple[str, logic_pb2.Value]], storage_integration_opt: Sequence[tuple[str, logic_pb2.Value]] | None) -> logic_pb2.CSVConfig: config = dict(config_dict) - _t2245 = self._extract_value_int32(config.get("csv_header_row"), 1) - header_row = _t2245 - _t2246 = self._extract_value_int64(config.get("csv_skip"), 0) - skip = _t2246 - _t2247 = self._extract_value_string(config.get("csv_new_line"), "") - new_line = _t2247 - _t2248 = self._extract_value_string(config.get("csv_delimiter"), ",") - delimiter = _t2248 - _t2249 = self._extract_value_string(config.get("csv_quotechar"), '"') - quotechar = _t2249 - _t2250 = self._extract_value_string(config.get("csv_escapechar"), '"') - escapechar = _t2250 - _t2251 = self._extract_value_string(config.get("csv_comment"), "") - comment = _t2251 - _t2252 = self._extract_value_string_list(config.get("csv_missing_strings"), []) - missing_strings = _t2252 - _t2253 = self._extract_value_string(config.get("csv_decimal_separator"), ".") - decimal_separator = _t2253 - _t2254 = self._extract_value_string(config.get("csv_encoding"), "utf-8") - encoding = _t2254 - _t2255 = self._extract_value_string(config.get("csv_compression"), "") - compression = _t2255 - _t2256 = self._extract_value_int64(config.get("csv_partition_size_mb"), 0) - partition_size_mb = _t2256 - _t2257 = self.construct_csv_storage_integration(storage_integration_opt) - storage_integration = _t2257 - _t2258 = logic_pb2.CSVConfig(header_row=header_row, skip=skip, new_line=new_line, delimiter=delimiter, quotechar=quotechar, escapechar=escapechar, comment=comment, missing_strings=missing_strings, decimal_separator=decimal_separator, encoding=encoding, compression=compression, partition_size_mb=partition_size_mb, storage_integration=storage_integration) - return _t2258 + _t2259 = self._extract_value_int32(config.get("csv_header_row"), 1) + header_row = _t2259 + _t2260 = self._extract_value_int64(config.get("csv_skip"), 0) + skip = _t2260 + _t2261 = self._extract_value_string(config.get("csv_new_line"), "") + new_line = _t2261 + _t2262 = self._extract_value_string(config.get("csv_delimiter"), ",") + delimiter = _t2262 + _t2263 = self._extract_value_string(config.get("csv_quotechar"), '"') + quotechar = _t2263 + _t2264 = self._extract_value_string(config.get("csv_escapechar"), '"') + escapechar = _t2264 + _t2265 = self._extract_value_string(config.get("csv_comment"), "") + comment = _t2265 + _t2266 = self._extract_value_string_list(config.get("csv_missing_strings"), []) + missing_strings = _t2266 + _t2267 = self._extract_value_string(config.get("csv_decimal_separator"), ".") + decimal_separator = _t2267 + _t2268 = self._extract_value_string(config.get("csv_encoding"), "utf-8") + encoding = _t2268 + _t2269 = self._extract_value_string(config.get("csv_compression"), "") + compression = _t2269 + _t2270 = self._extract_value_int64(config.get("csv_partition_size_mb"), 0) + partition_size_mb = _t2270 + _t2271 = self.construct_csv_storage_integration(storage_integration_opt) + storage_integration = _t2271 + _t2272 = logic_pb2.CSVConfig(header_row=header_row, skip=skip, new_line=new_line, delimiter=delimiter, quotechar=quotechar, escapechar=escapechar, comment=comment, missing_strings=missing_strings, decimal_separator=decimal_separator, encoding=encoding, compression=compression, partition_size_mb=partition_size_mb, storage_integration=storage_integration) + return _t2272 def construct_csv_storage_integration(self, storage_integration_opt: Sequence[tuple[str, logic_pb2.Value]] | None) -> logic_pb2.StorageIntegration | None: if storage_integration_opt is None: return None else: - _t2259 = None + _t2273 = None assert storage_integration_opt is not None config = dict(storage_integration_opt) - _t2260 = self._extract_value_string(config.get("provider"), "") - _t2261 = self._extract_value_string(config.get("azure_sas_token"), "") - _t2262 = self._extract_value_string(config.get("s3_region"), "") - _t2263 = self._extract_value_string(config.get("s3_access_key_id"), "") - _t2264 = self._extract_value_string(config.get("s3_secret_access_key"), "") - _t2265 = logic_pb2.StorageIntegration(provider=_t2260, azure_sas_token=_t2261, s3_region=_t2262, s3_access_key_id=_t2263, s3_secret_access_key=_t2264) - return _t2265 + _t2274 = self._extract_value_string(config.get("provider"), "") + _t2275 = self._extract_value_string(config.get("azure_sas_token"), "") + _t2276 = self._extract_value_string(config.get("s3_region"), "") + _t2277 = self._extract_value_string(config.get("s3_access_key_id"), "") + _t2278 = self._extract_value_string(config.get("s3_secret_access_key"), "") + _t2279 = logic_pb2.StorageIntegration(provider=_t2274, azure_sas_token=_t2275, s3_region=_t2276, s3_access_key_id=_t2277, s3_secret_access_key=_t2278) + return _t2279 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) - _t2266 = self._try_extract_value_float64(config.get("betree_config_epsilon")) - epsilon = _t2266 - _t2267 = self._try_extract_value_int64(config.get("betree_config_max_pivots")) - max_pivots = _t2267 - _t2268 = self._try_extract_value_int64(config.get("betree_config_max_deltas")) - max_deltas = _t2268 - _t2269 = self._try_extract_value_int64(config.get("betree_config_max_leaf")) - max_leaf = _t2269 - _t2270 = logic_pb2.BeTreeConfig(epsilon=epsilon, max_pivots=max_pivots, max_deltas=max_deltas, max_leaf=max_leaf) - storage_config = _t2270 - _t2271 = self._try_extract_value_uint128(config.get("betree_locator_root_pageid")) - root_pageid = _t2271 - _t2272 = self._try_extract_value_bytes(config.get("betree_locator_inline_data")) - inline_data = _t2272 - _t2273 = self._try_extract_value_int64(config.get("betree_locator_element_count")) - element_count = _t2273 - _t2274 = self._try_extract_value_int64(config.get("betree_locator_tree_height")) - tree_height = _t2274 - _t2275 = logic_pb2.BeTreeLocator(root_pageid=root_pageid, inline_data=inline_data, element_count=element_count, tree_height=tree_height) - relation_locator = _t2275 - _t2276 = logic_pb2.BeTreeInfo(key_types=key_types, value_types=value_types, storage_config=storage_config, relation_locator=relation_locator) - return _t2276 + _t2280 = self._try_extract_value_float64(config.get("betree_config_epsilon")) + epsilon = _t2280 + _t2281 = self._try_extract_value_int64(config.get("betree_config_max_pivots")) + max_pivots = _t2281 + _t2282 = self._try_extract_value_int64(config.get("betree_config_max_deltas")) + max_deltas = _t2282 + _t2283 = self._try_extract_value_int64(config.get("betree_config_max_leaf")) + max_leaf = _t2283 + _t2284 = logic_pb2.BeTreeConfig(epsilon=epsilon, max_pivots=max_pivots, max_deltas=max_deltas, max_leaf=max_leaf) + storage_config = _t2284 + _t2285 = self._try_extract_value_uint128(config.get("betree_locator_root_pageid")) + root_pageid = _t2285 + _t2286 = self._try_extract_value_bytes(config.get("betree_locator_inline_data")) + inline_data = _t2286 + _t2287 = self._try_extract_value_int64(config.get("betree_locator_element_count")) + element_count = _t2287 + _t2288 = self._try_extract_value_int64(config.get("betree_locator_tree_height")) + tree_height = _t2288 + _t2289 = logic_pb2.BeTreeLocator(root_pageid=root_pageid, inline_data=inline_data, element_count=element_count, tree_height=tree_height) + relation_locator = _t2289 + _t2290 = logic_pb2.BeTreeInfo(key_types=key_types, value_types=value_types, storage_config=storage_config, relation_locator=relation_locator) + return _t2290 def default_configure(self) -> transactions_pb2.Configure: - _t2277 = transactions_pb2.IVMConfig(level=transactions_pb2.MaintenanceLevel.MAINTENANCE_LEVEL_OFF) - ivm_config = _t2277 - _t2278 = transactions_pb2.Configure(semantics_version=0, ivm_config=ivm_config) - return _t2278 + _t2291 = transactions_pb2.IVMConfig(level=transactions_pb2.MaintenanceLevel.MAINTENANCE_LEVEL_OFF) + ivm_config = _t2291 + _t2292 = transactions_pb2.Configure(semantics_version=0, ivm_config=ivm_config) + return _t2292 def construct_configure(self, config_dict: Sequence[tuple[str, logic_pb2.Value]]) -> transactions_pb2.Configure: config = dict(config_dict) @@ -653,3608 +653,3634 @@ 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 - _t2279 = transactions_pb2.IVMConfig(level=maintenance_level) - ivm_config = _t2279 - _t2280 = self._extract_value_int64(config.get("semantics_version"), 0) - semantics_version = _t2280 + _t2293 = transactions_pb2.IVMConfig(level=maintenance_level) + ivm_config = _t2293 + _t2294 = self._extract_value_int64(config.get("semantics_version"), 0) + semantics_version = _t2294 config_values_pairs = [] for pair in config_dict: if (pair[0] != "semantics_version" and pair[0] != "ivm.maintenance_level"): config_values_pairs.append(pair) configuration_values = dict(config_values_pairs) - _t2281 = transactions_pb2.Configure(semantics_version=semantics_version, ivm_config=ivm_config, configuration_values=configuration_values) - return _t2281 + _t2295 = transactions_pb2.Configure(semantics_version=semantics_version, ivm_config=ivm_config, configuration_values=configuration_values) + return _t2295 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) - _t2282 = self._extract_value_int64(config.get("partition_size"), 0) - partition_size = _t2282 - _t2283 = self._extract_value_string(config.get("compression"), "") - compression = _t2283 - _t2284 = self._extract_value_boolean(config.get("syntax_header_row"), True) - syntax_header_row = _t2284 - _t2285 = self._extract_value_string(config.get("syntax_missing_string"), "") - syntax_missing_string = _t2285 - _t2286 = self._extract_value_string(config.get("syntax_delim"), ",") - syntax_delim = _t2286 - _t2287 = self._extract_value_string(config.get("syntax_quotechar"), '"') - syntax_quotechar = _t2287 - _t2288 = self._extract_value_string(config.get("syntax_escapechar"), "\\") - syntax_escapechar = _t2288 - _t2289 = 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 _t2289 + _t2296 = self._extract_value_int64(config.get("partition_size"), 0) + partition_size = _t2296 + _t2297 = self._extract_value_string(config.get("compression"), "") + compression = _t2297 + _t2298 = self._extract_value_boolean(config.get("syntax_header_row"), True) + syntax_header_row = _t2298 + _t2299 = self._extract_value_string(config.get("syntax_missing_string"), "") + syntax_missing_string = _t2299 + _t2300 = self._extract_value_string(config.get("syntax_delim"), ",") + syntax_delim = _t2300 + _t2301 = self._extract_value_string(config.get("syntax_quotechar"), '"') + syntax_quotechar = _t2301 + _t2302 = self._extract_value_string(config.get("syntax_escapechar"), "\\") + syntax_escapechar = _t2302 + _t2303 = 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 _t2303 def construct_export_csv_config_with_location(self, location: tuple[str, str], csv_source: transactions_pb2.ExportCSVSource, csv_config: logic_pb2.CSVConfig) -> transactions_pb2.ExportCSVConfig: - _t2290 = transactions_pb2.ExportCSVConfig(path=location[0], transaction_output_name=location[1], csv_source=csv_source, csv_config=csv_config) - return _t2290 + _t2304 = transactions_pb2.ExportCSVConfig(path=location[0], transaction_output_name=location[1], csv_source=csv_source, csv_config=csv_config) + return _t2304 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) - _t2291 = logic_pb2.IcebergCatalogConfig(catalog_uri=catalog_uri, scope=(scope_opt if scope_opt is not None else ""), properties=props, auth_properties=auth_props) - return _t2291 + _t2305 = logic_pb2.IcebergCatalogConfig(catalog_uri=catalog_uri, scope=(scope_opt if scope_opt is not None else ""), properties=props, auth_properties=auth_props) + return _t2305 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: - _t2292 = 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 _t2292 + _t2306 = 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 _t2306 def construct_export_iceberg_config_full(self, locator: logic_pb2.IcebergLocator, config: logic_pb2.IcebergCatalogConfig, table_def: logic_pb2.RelationId, table_property_pairs: Sequence[tuple[str, str]], config_dict: Sequence[tuple[str, logic_pb2.Value]] | None) -> transactions_pb2.ExportIcebergConfig: cfg = dict((config_dict if config_dict is not None else [])) - _t2293 = self._extract_value_string(cfg.get("prefix"), "") - prefix = _t2293 - _t2294 = self._extract_value_int64(cfg.get("target_file_size_bytes"), 0) - target_file_size_bytes = _t2294 - _t2295 = self._extract_value_string(cfg.get("compression"), "") - compression = _t2295 + _t2307 = self._extract_value_string(cfg.get("prefix"), "") + prefix = _t2307 + _t2308 = self._extract_value_int64(cfg.get("target_file_size_bytes"), 0) + target_file_size_bytes = _t2308 + _t2309 = self._extract_value_string(cfg.get("compression"), "") + compression = _t2309 table_props = dict(table_property_pairs) - _t2296 = transactions_pb2.ExportIcebergConfig(locator=locator, config=config, table_def=table_def, prefix=prefix, target_file_size_bytes=target_file_size_bytes, compression=compression, table_properties=table_props) - return _t2296 + _t2310 = transactions_pb2.ExportIcebergConfig(locator=locator, config=config, table_def=table_def, prefix=prefix, target_file_size_bytes=target_file_size_bytes, compression=compression, table_properties=table_props) + return _t2310 # --- Parse methods --- def parse_transaction(self) -> transactions_pb2.Transaction: - span_start718 = self.span_start() + span_start722 = self.span_start() self.consume_literal("(") self.consume_literal("transaction") if (self.match_lookahead_literal("(", 0) and self.match_lookahead_literal("configure", 1)): - _t1425 = self.parse_configure() - _t1424 = _t1425 + _t1433 = self.parse_configure() + _t1432 = _t1433 else: - _t1424 = None - configure712 = _t1424 + _t1432 = None + configure716 = _t1432 if (self.match_lookahead_literal("(", 0) and self.match_lookahead_literal("sync", 1)): - _t1427 = self.parse_sync() - _t1426 = _t1427 + _t1435 = self.parse_sync() + _t1434 = _t1435 else: - _t1426 = None - sync713 = _t1426 - xs714 = [] - cond715 = self.match_lookahead_literal("(", 0) - while cond715: - _t1428 = self.parse_epoch() - item716 = _t1428 - xs714.append(item716) - cond715 = self.match_lookahead_literal("(", 0) - epochs717 = xs714 + _t1434 = None + sync717 = _t1434 + xs718 = [] + cond719 = self.match_lookahead_literal("(", 0) + while cond719: + _t1436 = self.parse_epoch() + item720 = _t1436 + xs718.append(item720) + cond719 = self.match_lookahead_literal("(", 0) + epochs721 = xs718 self.consume_literal(")") - _t1429 = self.default_configure() - _t1430 = transactions_pb2.Transaction(epochs=epochs717, configure=(configure712 if configure712 is not None else _t1429), sync=sync713) - result719 = _t1430 - self.record_span(span_start718, "Transaction") - return result719 + _t1437 = self.default_configure() + _t1438 = transactions_pb2.Transaction(epochs=epochs721, configure=(configure716 if configure716 is not None else _t1437), sync=sync717) + result723 = _t1438 + self.record_span(span_start722, "Transaction") + return result723 def parse_configure(self) -> transactions_pb2.Configure: - span_start721 = self.span_start() + span_start725 = self.span_start() self.consume_literal("(") self.consume_literal("configure") - _t1431 = self.parse_config_dict() - config_dict720 = _t1431 + _t1439 = self.parse_config_dict() + config_dict724 = _t1439 self.consume_literal(")") - _t1432 = self.construct_configure(config_dict720) - result722 = _t1432 - self.record_span(span_start721, "Configure") - return result722 + _t1440 = self.construct_configure(config_dict724) + result726 = _t1440 + self.record_span(span_start725, "Configure") + return result726 def parse_config_dict(self) -> Sequence[tuple[str, logic_pb2.Value]]: self.consume_literal("{") - xs723 = [] - cond724 = self.match_lookahead_literal(":", 0) - while cond724: - _t1433 = self.parse_config_key_value() - item725 = _t1433 - xs723.append(item725) - cond724 = self.match_lookahead_literal(":", 0) - config_key_values726 = xs723 + xs727 = [] + cond728 = self.match_lookahead_literal(":", 0) + while cond728: + _t1441 = self.parse_config_key_value() + item729 = _t1441 + xs727.append(item729) + cond728 = self.match_lookahead_literal(":", 0) + config_key_values730 = xs727 self.consume_literal("}") - return config_key_values726 + return config_key_values730 def parse_config_key_value(self) -> tuple[str, logic_pb2.Value]: self.consume_literal(":") - symbol727 = self.consume_terminal("SYMBOL") - _t1434 = self.parse_raw_value() - raw_value728 = _t1434 - return (symbol727, raw_value728,) + symbol731 = self.consume_terminal("SYMBOL") + _t1442 = self.parse_raw_value() + raw_value732 = _t1442 + return (symbol731, raw_value732,) def parse_raw_value(self) -> logic_pb2.Value: - span_start742 = self.span_start() + span_start746 = self.span_start() if self.match_lookahead_literal("true", 0): - _t1435 = 12 + _t1443 = 12 else: if self.match_lookahead_literal("missing", 0): - _t1436 = 11 + _t1444 = 11 else: if self.match_lookahead_literal("false", 0): - _t1437 = 12 + _t1445 = 12 else: if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("datetime", 1): - _t1439 = 1 + _t1447 = 1 else: if self.match_lookahead_literal("date", 1): - _t1440 = 0 + _t1448 = 0 else: - _t1440 = -1 - _t1439 = _t1440 - _t1438 = _t1439 + _t1448 = -1 + _t1447 = _t1448 + _t1446 = _t1447 else: if self.match_lookahead_terminal("UINT32", 0): - _t1441 = 7 + _t1449 = 7 else: if self.match_lookahead_terminal("UINT128", 0): - _t1442 = 8 + _t1450 = 8 else: if self.match_lookahead_terminal("STRING", 0): - _t1443 = 2 + _t1451 = 2 else: if self.match_lookahead_terminal("INT32", 0): - _t1444 = 3 + _t1452 = 3 else: if self.match_lookahead_terminal("INT128", 0): - _t1445 = 9 + _t1453 = 9 else: if self.match_lookahead_terminal("INT", 0): - _t1446 = 4 + _t1454 = 4 else: if self.match_lookahead_terminal("FLOAT32", 0): - _t1447 = 5 + _t1455 = 5 else: if self.match_lookahead_terminal("FLOAT", 0): - _t1448 = 6 + _t1456 = 6 else: if self.match_lookahead_terminal("DECIMAL", 0): - _t1449 = 10 + _t1457 = 10 else: - _t1449 = -1 - _t1448 = _t1449 - _t1447 = _t1448 - _t1446 = _t1447 - _t1445 = _t1446 - _t1444 = _t1445 - _t1443 = _t1444 - _t1442 = _t1443 - _t1441 = _t1442 - _t1438 = _t1441 - _t1437 = _t1438 - _t1436 = _t1437 - _t1435 = _t1436 - prediction729 = _t1435 - if prediction729 == 12: - _t1451 = self.parse_boolean_value() - boolean_value741 = _t1451 - _t1452 = logic_pb2.Value(boolean_value=boolean_value741) - _t1450 = _t1452 + _t1457 = -1 + _t1456 = _t1457 + _t1455 = _t1456 + _t1454 = _t1455 + _t1453 = _t1454 + _t1452 = _t1453 + _t1451 = _t1452 + _t1450 = _t1451 + _t1449 = _t1450 + _t1446 = _t1449 + _t1445 = _t1446 + _t1444 = _t1445 + _t1443 = _t1444 + prediction733 = _t1443 + if prediction733 == 12: + _t1459 = self.parse_boolean_value() + boolean_value745 = _t1459 + _t1460 = logic_pb2.Value(boolean_value=boolean_value745) + _t1458 = _t1460 else: - if prediction729 == 11: + if prediction733 == 11: self.consume_literal("missing") - _t1454 = logic_pb2.MissingValue() - _t1455 = logic_pb2.Value(missing_value=_t1454) - _t1453 = _t1455 + _t1462 = logic_pb2.MissingValue() + _t1463 = logic_pb2.Value(missing_value=_t1462) + _t1461 = _t1463 else: - if prediction729 == 10: - decimal740 = self.consume_terminal("DECIMAL") - _t1457 = logic_pb2.Value(decimal_value=decimal740) - _t1456 = _t1457 + if prediction733 == 10: + decimal744 = self.consume_terminal("DECIMAL") + _t1465 = logic_pb2.Value(decimal_value=decimal744) + _t1464 = _t1465 else: - if prediction729 == 9: - int128739 = self.consume_terminal("INT128") - _t1459 = logic_pb2.Value(int128_value=int128739) - _t1458 = _t1459 + if prediction733 == 9: + int128743 = self.consume_terminal("INT128") + _t1467 = logic_pb2.Value(int128_value=int128743) + _t1466 = _t1467 else: - if prediction729 == 8: - uint128738 = self.consume_terminal("UINT128") - _t1461 = logic_pb2.Value(uint128_value=uint128738) - _t1460 = _t1461 + if prediction733 == 8: + uint128742 = self.consume_terminal("UINT128") + _t1469 = logic_pb2.Value(uint128_value=uint128742) + _t1468 = _t1469 else: - if prediction729 == 7: - uint32737 = self.consume_terminal("UINT32") - _t1463 = logic_pb2.Value(uint32_value=uint32737) - _t1462 = _t1463 + if prediction733 == 7: + uint32741 = self.consume_terminal("UINT32") + _t1471 = logic_pb2.Value(uint32_value=uint32741) + _t1470 = _t1471 else: - if prediction729 == 6: - float736 = self.consume_terminal("FLOAT") - _t1465 = logic_pb2.Value(float_value=float736) - _t1464 = _t1465 + if prediction733 == 6: + float740 = self.consume_terminal("FLOAT") + _t1473 = logic_pb2.Value(float_value=float740) + _t1472 = _t1473 else: - if prediction729 == 5: - float32735 = self.consume_terminal("FLOAT32") - _t1467 = logic_pb2.Value(float32_value=float32735) - _t1466 = _t1467 + if prediction733 == 5: + float32739 = self.consume_terminal("FLOAT32") + _t1475 = logic_pb2.Value(float32_value=float32739) + _t1474 = _t1475 else: - if prediction729 == 4: - int734 = self.consume_terminal("INT") - _t1469 = logic_pb2.Value(int_value=int734) - _t1468 = _t1469 + if prediction733 == 4: + int738 = self.consume_terminal("INT") + _t1477 = logic_pb2.Value(int_value=int738) + _t1476 = _t1477 else: - if prediction729 == 3: - int32733 = self.consume_terminal("INT32") - _t1471 = logic_pb2.Value(int32_value=int32733) - _t1470 = _t1471 + if prediction733 == 3: + int32737 = self.consume_terminal("INT32") + _t1479 = logic_pb2.Value(int32_value=int32737) + _t1478 = _t1479 else: - if prediction729 == 2: - string732 = self.consume_terminal("STRING") - _t1473 = logic_pb2.Value(string_value=string732) - _t1472 = _t1473 + if prediction733 == 2: + string736 = self.consume_terminal("STRING") + _t1481 = logic_pb2.Value(string_value=string736) + _t1480 = _t1481 else: - if prediction729 == 1: - _t1475 = self.parse_raw_datetime() - raw_datetime731 = _t1475 - _t1476 = logic_pb2.Value(datetime_value=raw_datetime731) - _t1474 = _t1476 + if prediction733 == 1: + _t1483 = self.parse_raw_datetime() + raw_datetime735 = _t1483 + _t1484 = logic_pb2.Value(datetime_value=raw_datetime735) + _t1482 = _t1484 else: - if prediction729 == 0: - _t1478 = self.parse_raw_date() - raw_date730 = _t1478 - _t1479 = logic_pb2.Value(date_value=raw_date730) - _t1477 = _t1479 + if prediction733 == 0: + _t1486 = self.parse_raw_date() + raw_date734 = _t1486 + _t1487 = logic_pb2.Value(date_value=raw_date734) + _t1485 = _t1487 else: raise ParseError("Unexpected token in raw_value" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1474 = _t1477 - _t1472 = _t1474 - _t1470 = _t1472 - _t1468 = _t1470 - _t1466 = _t1468 - _t1464 = _t1466 - _t1462 = _t1464 - _t1460 = _t1462 - _t1458 = _t1460 - _t1456 = _t1458 - _t1453 = _t1456 - _t1450 = _t1453 - result743 = _t1450 - self.record_span(span_start742, "Value") - return result743 + _t1482 = _t1485 + _t1480 = _t1482 + _t1478 = _t1480 + _t1476 = _t1478 + _t1474 = _t1476 + _t1472 = _t1474 + _t1470 = _t1472 + _t1468 = _t1470 + _t1466 = _t1468 + _t1464 = _t1466 + _t1461 = _t1464 + _t1458 = _t1461 + result747 = _t1458 + self.record_span(span_start746, "Value") + return result747 def parse_raw_date(self) -> logic_pb2.DateValue: - span_start747 = self.span_start() + span_start751 = self.span_start() self.consume_literal("(") self.consume_literal("date") - int744 = self.consume_terminal("INT") - int_3745 = self.consume_terminal("INT") - int_4746 = self.consume_terminal("INT") + int748 = self.consume_terminal("INT") + int_3749 = self.consume_terminal("INT") + int_4750 = self.consume_terminal("INT") self.consume_literal(")") - _t1480 = logic_pb2.DateValue(year=int(int744), month=int(int_3745), day=int(int_4746)) - result748 = _t1480 - self.record_span(span_start747, "DateValue") - return result748 + _t1488 = logic_pb2.DateValue(year=int(int748), month=int(int_3749), day=int(int_4750)) + result752 = _t1488 + self.record_span(span_start751, "DateValue") + return result752 def parse_raw_datetime(self) -> logic_pb2.DateTimeValue: - span_start756 = self.span_start() + span_start760 = self.span_start() self.consume_literal("(") self.consume_literal("datetime") - int749 = self.consume_terminal("INT") - int_3750 = self.consume_terminal("INT") - int_4751 = self.consume_terminal("INT") - int_5752 = self.consume_terminal("INT") - int_6753 = self.consume_terminal("INT") - int_7754 = self.consume_terminal("INT") + int753 = self.consume_terminal("INT") + int_3754 = self.consume_terminal("INT") + int_4755 = self.consume_terminal("INT") + int_5756 = self.consume_terminal("INT") + int_6757 = self.consume_terminal("INT") + int_7758 = self.consume_terminal("INT") if self.match_lookahead_terminal("INT", 0): - _t1481 = self.consume_terminal("INT") + _t1489 = self.consume_terminal("INT") else: - _t1481 = None - int_8755 = _t1481 + _t1489 = None + int_8759 = _t1489 self.consume_literal(")") - _t1482 = logic_pb2.DateTimeValue(year=int(int749), month=int(int_3750), day=int(int_4751), hour=int(int_5752), minute=int(int_6753), second=int(int_7754), microsecond=int((int_8755 if int_8755 is not None else 0))) - result757 = _t1482 - self.record_span(span_start756, "DateTimeValue") - return result757 + _t1490 = logic_pb2.DateTimeValue(year=int(int753), month=int(int_3754), day=int(int_4755), hour=int(int_5756), minute=int(int_6757), second=int(int_7758), microsecond=int((int_8759 if int_8759 is not None else 0))) + result761 = _t1490 + self.record_span(span_start760, "DateTimeValue") + return result761 def parse_boolean_value(self) -> bool: if self.match_lookahead_literal("true", 0): - _t1483 = 0 + _t1491 = 0 else: if self.match_lookahead_literal("false", 0): - _t1484 = 1 + _t1492 = 1 else: - _t1484 = -1 - _t1483 = _t1484 - prediction758 = _t1483 - if prediction758 == 1: + _t1492 = -1 + _t1491 = _t1492 + prediction762 = _t1491 + if prediction762 == 1: self.consume_literal("false") - _t1485 = False + _t1493 = False else: - if prediction758 == 0: + if prediction762 == 0: self.consume_literal("true") - _t1486 = True + _t1494 = True else: raise ParseError("Unexpected token in boolean_value" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1485 = _t1486 - return _t1485 + _t1493 = _t1494 + return _t1493 def parse_sync(self) -> transactions_pb2.Sync: - span_start763 = self.span_start() + span_start767 = self.span_start() self.consume_literal("(") self.consume_literal("sync") - xs759 = [] - cond760 = self.match_lookahead_literal(":", 0) - while cond760: - _t1487 = self.parse_fragment_id() - item761 = _t1487 - xs759.append(item761) - cond760 = self.match_lookahead_literal(":", 0) - fragment_ids762 = xs759 + xs763 = [] + cond764 = self.match_lookahead_literal(":", 0) + while cond764: + _t1495 = self.parse_fragment_id() + item765 = _t1495 + xs763.append(item765) + cond764 = self.match_lookahead_literal(":", 0) + fragment_ids766 = xs763 self.consume_literal(")") - _t1488 = transactions_pb2.Sync(fragments=fragment_ids762) - result764 = _t1488 - self.record_span(span_start763, "Sync") - return result764 + _t1496 = transactions_pb2.Sync(fragments=fragment_ids766) + result768 = _t1496 + self.record_span(span_start767, "Sync") + return result768 def parse_fragment_id(self) -> fragments_pb2.FragmentId: - span_start766 = self.span_start() + span_start770 = self.span_start() self.consume_literal(":") - symbol765 = self.consume_terminal("SYMBOL") - result767 = fragments_pb2.FragmentId(id=symbol765.encode()) - self.record_span(span_start766, "FragmentId") - return result767 + symbol769 = self.consume_terminal("SYMBOL") + result771 = fragments_pb2.FragmentId(id=symbol769.encode()) + self.record_span(span_start770, "FragmentId") + return result771 def parse_epoch(self) -> transactions_pb2.Epoch: - span_start770 = self.span_start() + span_start774 = self.span_start() self.consume_literal("(") self.consume_literal("epoch") if (self.match_lookahead_literal("(", 0) and self.match_lookahead_literal("writes", 1)): - _t1490 = self.parse_epoch_writes() - _t1489 = _t1490 + _t1498 = self.parse_epoch_writes() + _t1497 = _t1498 else: - _t1489 = None - epoch_writes768 = _t1489 + _t1497 = None + epoch_writes772 = _t1497 if self.match_lookahead_literal("(", 0): - _t1492 = self.parse_epoch_reads() - _t1491 = _t1492 + _t1500 = self.parse_epoch_reads() + _t1499 = _t1500 else: - _t1491 = None - epoch_reads769 = _t1491 + _t1499 = None + epoch_reads773 = _t1499 self.consume_literal(")") - _t1493 = transactions_pb2.Epoch(writes=(epoch_writes768 if epoch_writes768 is not None else []), reads=(epoch_reads769 if epoch_reads769 is not None else [])) - result771 = _t1493 - self.record_span(span_start770, "Epoch") - return result771 + _t1501 = transactions_pb2.Epoch(writes=(epoch_writes772 if epoch_writes772 is not None else []), reads=(epoch_reads773 if epoch_reads773 is not None else [])) + result775 = _t1501 + self.record_span(span_start774, "Epoch") + return result775 def parse_epoch_writes(self) -> Sequence[transactions_pb2.Write]: self.consume_literal("(") self.consume_literal("writes") - xs772 = [] - cond773 = self.match_lookahead_literal("(", 0) - while cond773: - _t1494 = self.parse_write() - item774 = _t1494 - xs772.append(item774) - cond773 = self.match_lookahead_literal("(", 0) - writes775 = xs772 + xs776 = [] + cond777 = self.match_lookahead_literal("(", 0) + while cond777: + _t1502 = self.parse_write() + item778 = _t1502 + xs776.append(item778) + cond777 = self.match_lookahead_literal("(", 0) + writes779 = xs776 self.consume_literal(")") - return writes775 + return writes779 def parse_write(self) -> transactions_pb2.Write: - span_start781 = self.span_start() + span_start785 = self.span_start() if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("undefine", 1): - _t1496 = 1 + _t1504 = 1 else: if self.match_lookahead_literal("snapshot", 1): - _t1497 = 3 + _t1505 = 3 else: if self.match_lookahead_literal("define", 1): - _t1498 = 0 + _t1506 = 0 else: if self.match_lookahead_literal("context", 1): - _t1499 = 2 + _t1507 = 2 else: - _t1499 = -1 - _t1498 = _t1499 - _t1497 = _t1498 - _t1496 = _t1497 - _t1495 = _t1496 + _t1507 = -1 + _t1506 = _t1507 + _t1505 = _t1506 + _t1504 = _t1505 + _t1503 = _t1504 else: - _t1495 = -1 - prediction776 = _t1495 - if prediction776 == 3: - _t1501 = self.parse_snapshot() - snapshot780 = _t1501 - _t1502 = transactions_pb2.Write(snapshot=snapshot780) - _t1500 = _t1502 + _t1503 = -1 + prediction780 = _t1503 + if prediction780 == 3: + _t1509 = self.parse_snapshot() + snapshot784 = _t1509 + _t1510 = transactions_pb2.Write(snapshot=snapshot784) + _t1508 = _t1510 else: - if prediction776 == 2: - _t1504 = self.parse_context() - context779 = _t1504 - _t1505 = transactions_pb2.Write(context=context779) - _t1503 = _t1505 + if prediction780 == 2: + _t1512 = self.parse_context() + context783 = _t1512 + _t1513 = transactions_pb2.Write(context=context783) + _t1511 = _t1513 else: - if prediction776 == 1: - _t1507 = self.parse_undefine() - undefine778 = _t1507 - _t1508 = transactions_pb2.Write(undefine=undefine778) - _t1506 = _t1508 + if prediction780 == 1: + _t1515 = self.parse_undefine() + undefine782 = _t1515 + _t1516 = transactions_pb2.Write(undefine=undefine782) + _t1514 = _t1516 else: - if prediction776 == 0: - _t1510 = self.parse_define() - define777 = _t1510 - _t1511 = transactions_pb2.Write(define=define777) - _t1509 = _t1511 + if prediction780 == 0: + _t1518 = self.parse_define() + define781 = _t1518 + _t1519 = transactions_pb2.Write(define=define781) + _t1517 = _t1519 else: raise ParseError("Unexpected token in write" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1506 = _t1509 - _t1503 = _t1506 - _t1500 = _t1503 - result782 = _t1500 - self.record_span(span_start781, "Write") - return result782 + _t1514 = _t1517 + _t1511 = _t1514 + _t1508 = _t1511 + result786 = _t1508 + self.record_span(span_start785, "Write") + return result786 def parse_define(self) -> transactions_pb2.Define: - span_start784 = self.span_start() + span_start788 = self.span_start() self.consume_literal("(") self.consume_literal("define") - _t1512 = self.parse_fragment() - fragment783 = _t1512 + _t1520 = self.parse_fragment() + fragment787 = _t1520 self.consume_literal(")") - _t1513 = transactions_pb2.Define(fragment=fragment783) - result785 = _t1513 - self.record_span(span_start784, "Define") - return result785 + _t1521 = transactions_pb2.Define(fragment=fragment787) + result789 = _t1521 + self.record_span(span_start788, "Define") + return result789 def parse_fragment(self) -> fragments_pb2.Fragment: - span_start791 = self.span_start() + span_start795 = self.span_start() self.consume_literal("(") self.consume_literal("fragment") - _t1514 = self.parse_new_fragment_id() - new_fragment_id786 = _t1514 - xs787 = [] - cond788 = self.match_lookahead_literal("(", 0) - while cond788: - _t1515 = self.parse_declaration() - item789 = _t1515 - xs787.append(item789) - cond788 = self.match_lookahead_literal("(", 0) - declarations790 = xs787 + _t1522 = self.parse_new_fragment_id() + new_fragment_id790 = _t1522 + xs791 = [] + cond792 = self.match_lookahead_literal("(", 0) + while cond792: + _t1523 = self.parse_declaration() + item793 = _t1523 + xs791.append(item793) + cond792 = self.match_lookahead_literal("(", 0) + declarations794 = xs791 self.consume_literal(")") - result792 = self.construct_fragment(new_fragment_id786, declarations790) - self.record_span(span_start791, "Fragment") - return result792 + result796 = self.construct_fragment(new_fragment_id790, declarations794) + self.record_span(span_start795, "Fragment") + return result796 def parse_new_fragment_id(self) -> fragments_pb2.FragmentId: - span_start794 = self.span_start() - _t1516 = self.parse_fragment_id() - fragment_id793 = _t1516 - self.start_fragment(fragment_id793) - result795 = fragment_id793 - self.record_span(span_start794, "FragmentId") - return result795 + span_start798 = self.span_start() + _t1524 = self.parse_fragment_id() + fragment_id797 = _t1524 + self.start_fragment(fragment_id797) + result799 = fragment_id797 + self.record_span(span_start798, "FragmentId") + return result799 def parse_declaration(self) -> logic_pb2.Declaration: - span_start801 = self.span_start() + span_start805 = self.span_start() if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("iceberg_data", 1): - _t1518 = 3 + _t1526 = 3 else: if self.match_lookahead_literal("functional_dependency", 1): - _t1519 = 2 + _t1527 = 2 else: if self.match_lookahead_literal("edb", 1): - _t1520 = 3 + _t1528 = 3 else: if self.match_lookahead_literal("def", 1): - _t1521 = 0 + _t1529 = 0 else: if self.match_lookahead_literal("csv_data", 1): - _t1522 = 3 + _t1530 = 3 else: if self.match_lookahead_literal("betree_relation", 1): - _t1523 = 3 + _t1531 = 3 else: if self.match_lookahead_literal("algorithm", 1): - _t1524 = 1 + _t1532 = 1 else: - _t1524 = -1 - _t1523 = _t1524 - _t1522 = _t1523 - _t1521 = _t1522 - _t1520 = _t1521 - _t1519 = _t1520 - _t1518 = _t1519 - _t1517 = _t1518 + _t1532 = -1 + _t1531 = _t1532 + _t1530 = _t1531 + _t1529 = _t1530 + _t1528 = _t1529 + _t1527 = _t1528 + _t1526 = _t1527 + _t1525 = _t1526 else: - _t1517 = -1 - prediction796 = _t1517 - if prediction796 == 3: - _t1526 = self.parse_data() - data800 = _t1526 - _t1527 = logic_pb2.Declaration(data=data800) - _t1525 = _t1527 + _t1525 = -1 + prediction800 = _t1525 + if prediction800 == 3: + _t1534 = self.parse_data() + data804 = _t1534 + _t1535 = logic_pb2.Declaration(data=data804) + _t1533 = _t1535 else: - if prediction796 == 2: - _t1529 = self.parse_constraint() - constraint799 = _t1529 - _t1530 = logic_pb2.Declaration(constraint=constraint799) - _t1528 = _t1530 + if prediction800 == 2: + _t1537 = self.parse_constraint() + constraint803 = _t1537 + _t1538 = logic_pb2.Declaration(constraint=constraint803) + _t1536 = _t1538 else: - if prediction796 == 1: - _t1532 = self.parse_algorithm() - algorithm798 = _t1532 - _t1533 = logic_pb2.Declaration(algorithm=algorithm798) - _t1531 = _t1533 + if prediction800 == 1: + _t1540 = self.parse_algorithm() + algorithm802 = _t1540 + _t1541 = logic_pb2.Declaration(algorithm=algorithm802) + _t1539 = _t1541 else: - if prediction796 == 0: - _t1535 = self.parse_def() - def797 = _t1535 - _t1536 = logic_pb2.Declaration() - getattr(_t1536, 'def').CopyFrom(def797) - _t1534 = _t1536 + if prediction800 == 0: + _t1543 = self.parse_def() + def801 = _t1543 + _t1544 = logic_pb2.Declaration() + getattr(_t1544, 'def').CopyFrom(def801) + _t1542 = _t1544 else: raise ParseError("Unexpected token in declaration" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1531 = _t1534 - _t1528 = _t1531 - _t1525 = _t1528 - result802 = _t1525 - self.record_span(span_start801, "Declaration") - return result802 + _t1539 = _t1542 + _t1536 = _t1539 + _t1533 = _t1536 + result806 = _t1533 + self.record_span(span_start805, "Declaration") + return result806 def parse_def(self) -> logic_pb2.Def: - span_start806 = self.span_start() + span_start810 = self.span_start() self.consume_literal("(") self.consume_literal("def") - _t1537 = self.parse_relation_id() - relation_id803 = _t1537 - _t1538 = self.parse_abstraction() - abstraction804 = _t1538 + _t1545 = self.parse_relation_id() + relation_id807 = _t1545 + _t1546 = self.parse_abstraction() + abstraction808 = _t1546 if self.match_lookahead_literal("(", 0): - _t1540 = self.parse_attrs() - _t1539 = _t1540 + _t1548 = self.parse_attrs() + _t1547 = _t1548 else: - _t1539 = None - attrs805 = _t1539 + _t1547 = None + attrs809 = _t1547 self.consume_literal(")") - _t1541 = logic_pb2.Def(name=relation_id803, body=abstraction804, attrs=(attrs805 if attrs805 is not None else [])) - result807 = _t1541 - self.record_span(span_start806, "Def") - return result807 + _t1549 = logic_pb2.Def(name=relation_id807, body=abstraction808, attrs=(attrs809 if attrs809 is not None else [])) + result811 = _t1549 + self.record_span(span_start810, "Def") + return result811 def parse_relation_id(self) -> logic_pb2.RelationId: - span_start811 = self.span_start() + span_start815 = self.span_start() if self.match_lookahead_literal(":", 0): - _t1542 = 0 + _t1550 = 0 else: if self.match_lookahead_terminal("UINT128", 0): - _t1543 = 1 + _t1551 = 1 else: - _t1543 = -1 - _t1542 = _t1543 - prediction808 = _t1542 - if prediction808 == 1: - uint128810 = self.consume_terminal("UINT128") - _t1544 = logic_pb2.RelationId(id_low=uint128810.low, id_high=uint128810.high) + _t1551 = -1 + _t1550 = _t1551 + prediction812 = _t1550 + if prediction812 == 1: + uint128814 = self.consume_terminal("UINT128") + _t1552 = logic_pb2.RelationId(id_low=uint128814.low, id_high=uint128814.high) else: - if prediction808 == 0: + if prediction812 == 0: self.consume_literal(":") - symbol809 = self.consume_terminal("SYMBOL") - _t1545 = self.relation_id_from_string(symbol809) + symbol813 = self.consume_terminal("SYMBOL") + _t1553 = self.relation_id_from_string(symbol813) else: raise ParseError("Unexpected token in relation_id" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1544 = _t1545 - result812 = _t1544 - self.record_span(span_start811, "RelationId") - return result812 + _t1552 = _t1553 + result816 = _t1552 + self.record_span(span_start815, "RelationId") + return result816 def parse_abstraction(self) -> logic_pb2.Abstraction: - span_start815 = self.span_start() + span_start819 = self.span_start() self.consume_literal("(") - _t1546 = self.parse_bindings() - bindings813 = _t1546 - _t1547 = self.parse_formula() - formula814 = _t1547 + _t1554 = self.parse_bindings() + bindings817 = _t1554 + _t1555 = self.parse_formula() + formula818 = _t1555 self.consume_literal(")") - _t1548 = logic_pb2.Abstraction(vars=(list(bindings813[0]) + list(bindings813[1] if bindings813[1] is not None else [])), value=formula814) - result816 = _t1548 - self.record_span(span_start815, "Abstraction") - return result816 + _t1556 = logic_pb2.Abstraction(vars=(list(bindings817[0]) + list(bindings817[1] if bindings817[1] is not None else [])), value=formula818) + result820 = _t1556 + self.record_span(span_start819, "Abstraction") + return result820 def parse_bindings(self) -> tuple[Sequence[logic_pb2.Binding], Sequence[logic_pb2.Binding]]: self.consume_literal("[") - xs817 = [] - cond818 = self.match_lookahead_terminal("SYMBOL", 0) - while cond818: - _t1549 = self.parse_binding() - item819 = _t1549 - xs817.append(item819) - cond818 = self.match_lookahead_terminal("SYMBOL", 0) - bindings820 = xs817 + xs821 = [] + cond822 = self.match_lookahead_terminal("SYMBOL", 0) + while cond822: + _t1557 = self.parse_binding() + item823 = _t1557 + xs821.append(item823) + cond822 = self.match_lookahead_terminal("SYMBOL", 0) + bindings824 = xs821 if self.match_lookahead_literal("|", 0): - _t1551 = self.parse_value_bindings() - _t1550 = _t1551 + _t1559 = self.parse_value_bindings() + _t1558 = _t1559 else: - _t1550 = None - value_bindings821 = _t1550 + _t1558 = None + value_bindings825 = _t1558 self.consume_literal("]") - return (bindings820, (value_bindings821 if value_bindings821 is not None else []),) + return (bindings824, (value_bindings825 if value_bindings825 is not None else []),) def parse_binding(self) -> logic_pb2.Binding: - span_start824 = self.span_start() - symbol822 = self.consume_terminal("SYMBOL") + span_start828 = self.span_start() + symbol826 = self.consume_terminal("SYMBOL") self.consume_literal("::") - _t1552 = self.parse_type() - type823 = _t1552 - _t1553 = logic_pb2.Var(name=symbol822) - _t1554 = logic_pb2.Binding(var=_t1553, type=type823) - result825 = _t1554 - self.record_span(span_start824, "Binding") - return result825 + _t1560 = self.parse_type() + type827 = _t1560 + _t1561 = logic_pb2.Var(name=symbol826) + _t1562 = logic_pb2.Binding(var=_t1561, type=type827) + result829 = _t1562 + self.record_span(span_start828, "Binding") + return result829 def parse_type(self) -> logic_pb2.Type: - span_start841 = self.span_start() + span_start846 = self.span_start() if self.match_lookahead_literal("UNKNOWN", 0): - _t1555 = 0 + _t1563 = 0 else: if self.match_lookahead_literal("UINT32", 0): - _t1556 = 13 + _t1564 = 13 else: if self.match_lookahead_literal("UINT128", 0): - _t1557 = 4 + _t1565 = 4 else: if self.match_lookahead_literal("STRING", 0): - _t1558 = 1 + _t1566 = 1 else: if self.match_lookahead_literal("MISSING", 0): - _t1559 = 8 + _t1567 = 8 else: if self.match_lookahead_literal("INT32", 0): - _t1560 = 11 + _t1568 = 11 else: if self.match_lookahead_literal("INT128", 0): - _t1561 = 5 + _t1569 = 5 else: if self.match_lookahead_literal("INT", 0): - _t1562 = 2 + _t1570 = 2 else: if self.match_lookahead_literal("FLOAT32", 0): - _t1563 = 12 + _t1571 = 12 else: if self.match_lookahead_literal("FLOAT", 0): - _t1564 = 3 + _t1572 = 3 else: if self.match_lookahead_literal("DATETIME", 0): - _t1565 = 7 + _t1573 = 7 else: if self.match_lookahead_literal("DATE", 0): - _t1566 = 6 + _t1574 = 6 else: if self.match_lookahead_literal("BOOLEAN", 0): - _t1567 = 10 + _t1575 = 10 else: if self.match_lookahead_literal("(", 0): - _t1568 = 9 + if self.match_lookahead_literal("FIXED", 1): + _t1577 = 14 + else: + if self.match_lookahead_literal("DECIMAL", 1): + _t1578 = 9 + else: + _t1578 = -1 + _t1577 = _t1578 + _t1576 = _t1577 else: - _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 - prediction826 = _t1555 - if prediction826 == 13: - _t1570 = self.parse_uint32_type() - uint32_type840 = _t1570 - _t1571 = logic_pb2.Type(uint32_type=uint32_type840) - _t1569 = _t1571 + _t1576 = -1 + _t1575 = _t1576 + _t1574 = _t1575 + _t1573 = _t1574 + _t1572 = _t1573 + _t1571 = _t1572 + _t1570 = _t1571 + _t1569 = _t1570 + _t1568 = _t1569 + _t1567 = _t1568 + _t1566 = _t1567 + _t1565 = _t1566 + _t1564 = _t1565 + _t1563 = _t1564 + prediction830 = _t1563 + if prediction830 == 14: + _t1580 = self.parse_fixed_type() + fixed_type845 = _t1580 + _t1581 = logic_pb2.Type(fixed_type=fixed_type845) + _t1579 = _t1581 else: - if prediction826 == 12: - _t1573 = self.parse_float32_type() - float32_type839 = _t1573 - _t1574 = logic_pb2.Type(float32_type=float32_type839) - _t1572 = _t1574 + if prediction830 == 13: + _t1583 = self.parse_uint32_type() + uint32_type844 = _t1583 + _t1584 = logic_pb2.Type(uint32_type=uint32_type844) + _t1582 = _t1584 else: - if prediction826 == 11: - _t1576 = self.parse_int32_type() - int32_type838 = _t1576 - _t1577 = logic_pb2.Type(int32_type=int32_type838) - _t1575 = _t1577 + if prediction830 == 12: + _t1586 = self.parse_float32_type() + float32_type843 = _t1586 + _t1587 = logic_pb2.Type(float32_type=float32_type843) + _t1585 = _t1587 else: - if prediction826 == 10: - _t1579 = self.parse_boolean_type() - boolean_type837 = _t1579 - _t1580 = logic_pb2.Type(boolean_type=boolean_type837) - _t1578 = _t1580 + if prediction830 == 11: + _t1589 = self.parse_int32_type() + int32_type842 = _t1589 + _t1590 = logic_pb2.Type(int32_type=int32_type842) + _t1588 = _t1590 else: - if prediction826 == 9: - _t1582 = self.parse_decimal_type() - decimal_type836 = _t1582 - _t1583 = logic_pb2.Type(decimal_type=decimal_type836) - _t1581 = _t1583 + if prediction830 == 10: + _t1592 = self.parse_boolean_type() + boolean_type841 = _t1592 + _t1593 = logic_pb2.Type(boolean_type=boolean_type841) + _t1591 = _t1593 else: - if prediction826 == 8: - _t1585 = self.parse_missing_type() - missing_type835 = _t1585 - _t1586 = logic_pb2.Type(missing_type=missing_type835) - _t1584 = _t1586 + if prediction830 == 9: + _t1595 = self.parse_decimal_type() + decimal_type840 = _t1595 + _t1596 = logic_pb2.Type(decimal_type=decimal_type840) + _t1594 = _t1596 else: - if prediction826 == 7: - _t1588 = self.parse_datetime_type() - datetime_type834 = _t1588 - _t1589 = logic_pb2.Type(datetime_type=datetime_type834) - _t1587 = _t1589 + if prediction830 == 8: + _t1598 = self.parse_missing_type() + missing_type839 = _t1598 + _t1599 = logic_pb2.Type(missing_type=missing_type839) + _t1597 = _t1599 else: - if prediction826 == 6: - _t1591 = self.parse_date_type() - date_type833 = _t1591 - _t1592 = logic_pb2.Type(date_type=date_type833) - _t1590 = _t1592 + if prediction830 == 7: + _t1601 = self.parse_datetime_type() + datetime_type838 = _t1601 + _t1602 = logic_pb2.Type(datetime_type=datetime_type838) + _t1600 = _t1602 else: - if prediction826 == 5: - _t1594 = self.parse_int128_type() - int128_type832 = _t1594 - _t1595 = logic_pb2.Type(int128_type=int128_type832) - _t1593 = _t1595 + if prediction830 == 6: + _t1604 = self.parse_date_type() + date_type837 = _t1604 + _t1605 = logic_pb2.Type(date_type=date_type837) + _t1603 = _t1605 else: - if prediction826 == 4: - _t1597 = self.parse_uint128_type() - uint128_type831 = _t1597 - _t1598 = logic_pb2.Type(uint128_type=uint128_type831) - _t1596 = _t1598 + if prediction830 == 5: + _t1607 = self.parse_int128_type() + int128_type836 = _t1607 + _t1608 = logic_pb2.Type(int128_type=int128_type836) + _t1606 = _t1608 else: - if prediction826 == 3: - _t1600 = self.parse_float_type() - float_type830 = _t1600 - _t1601 = logic_pb2.Type(float_type=float_type830) - _t1599 = _t1601 + if prediction830 == 4: + _t1610 = self.parse_uint128_type() + uint128_type835 = _t1610 + _t1611 = logic_pb2.Type(uint128_type=uint128_type835) + _t1609 = _t1611 else: - if prediction826 == 2: - _t1603 = self.parse_int_type() - int_type829 = _t1603 - _t1604 = logic_pb2.Type(int_type=int_type829) - _t1602 = _t1604 + if prediction830 == 3: + _t1613 = self.parse_float_type() + float_type834 = _t1613 + _t1614 = logic_pb2.Type(float_type=float_type834) + _t1612 = _t1614 else: - if prediction826 == 1: - _t1606 = self.parse_string_type() - string_type828 = _t1606 - _t1607 = logic_pb2.Type(string_type=string_type828) - _t1605 = _t1607 + if prediction830 == 2: + _t1616 = self.parse_int_type() + int_type833 = _t1616 + _t1617 = logic_pb2.Type(int_type=int_type833) + _t1615 = _t1617 else: - if prediction826 == 0: - _t1609 = self.parse_unspecified_type() - unspecified_type827 = _t1609 - _t1610 = logic_pb2.Type(unspecified_type=unspecified_type827) - _t1608 = _t1610 + if prediction830 == 1: + _t1619 = self.parse_string_type() + string_type832 = _t1619 + _t1620 = logic_pb2.Type(string_type=string_type832) + _t1618 = _t1620 else: - raise ParseError("Unexpected token in type" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1605 = _t1608 - _t1602 = _t1605 - _t1599 = _t1602 - _t1596 = _t1599 - _t1593 = _t1596 - _t1590 = _t1593 - _t1587 = _t1590 - _t1584 = _t1587 - _t1581 = _t1584 - _t1578 = _t1581 - _t1575 = _t1578 - _t1572 = _t1575 - _t1569 = _t1572 - result842 = _t1569 - self.record_span(span_start841, "Type") - return result842 + if prediction830 == 0: + _t1622 = self.parse_unspecified_type() + unspecified_type831 = _t1622 + _t1623 = logic_pb2.Type(unspecified_type=unspecified_type831) + _t1621 = _t1623 + else: + raise ParseError("Unexpected token in type" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") + _t1618 = _t1621 + _t1615 = _t1618 + _t1612 = _t1615 + _t1609 = _t1612 + _t1606 = _t1609 + _t1603 = _t1606 + _t1600 = _t1603 + _t1597 = _t1600 + _t1594 = _t1597 + _t1591 = _t1594 + _t1588 = _t1591 + _t1585 = _t1588 + _t1582 = _t1585 + _t1579 = _t1582 + result847 = _t1579 + self.record_span(span_start846, "Type") + return result847 def parse_unspecified_type(self) -> logic_pb2.UnspecifiedType: - span_start843 = self.span_start() + span_start848 = self.span_start() self.consume_literal("UNKNOWN") - _t1611 = logic_pb2.UnspecifiedType() - result844 = _t1611 - self.record_span(span_start843, "UnspecifiedType") - return result844 + _t1624 = logic_pb2.UnspecifiedType() + result849 = _t1624 + self.record_span(span_start848, "UnspecifiedType") + return result849 def parse_string_type(self) -> logic_pb2.StringType: - span_start845 = self.span_start() + span_start850 = self.span_start() self.consume_literal("STRING") - _t1612 = logic_pb2.StringType() - result846 = _t1612 - self.record_span(span_start845, "StringType") - return result846 + _t1625 = logic_pb2.StringType() + result851 = _t1625 + self.record_span(span_start850, "StringType") + return result851 def parse_int_type(self) -> logic_pb2.IntType: - span_start847 = self.span_start() + span_start852 = self.span_start() self.consume_literal("INT") - _t1613 = logic_pb2.IntType() - result848 = _t1613 - self.record_span(span_start847, "IntType") - return result848 + _t1626 = logic_pb2.IntType() + result853 = _t1626 + self.record_span(span_start852, "IntType") + return result853 def parse_float_type(self) -> logic_pb2.FloatType: - span_start849 = self.span_start() + span_start854 = self.span_start() self.consume_literal("FLOAT") - _t1614 = logic_pb2.FloatType() - result850 = _t1614 - self.record_span(span_start849, "FloatType") - return result850 + _t1627 = logic_pb2.FloatType() + result855 = _t1627 + self.record_span(span_start854, "FloatType") + return result855 def parse_uint128_type(self) -> logic_pb2.UInt128Type: - span_start851 = self.span_start() + span_start856 = self.span_start() self.consume_literal("UINT128") - _t1615 = logic_pb2.UInt128Type() - result852 = _t1615 - self.record_span(span_start851, "UInt128Type") - return result852 + _t1628 = logic_pb2.UInt128Type() + result857 = _t1628 + self.record_span(span_start856, "UInt128Type") + return result857 def parse_int128_type(self) -> logic_pb2.Int128Type: - span_start853 = self.span_start() + span_start858 = self.span_start() self.consume_literal("INT128") - _t1616 = logic_pb2.Int128Type() - result854 = _t1616 - self.record_span(span_start853, "Int128Type") - return result854 + _t1629 = logic_pb2.Int128Type() + result859 = _t1629 + self.record_span(span_start858, "Int128Type") + return result859 def parse_date_type(self) -> logic_pb2.DateType: - span_start855 = self.span_start() + span_start860 = self.span_start() self.consume_literal("DATE") - _t1617 = logic_pb2.DateType() - result856 = _t1617 - self.record_span(span_start855, "DateType") - return result856 + _t1630 = logic_pb2.DateType() + result861 = _t1630 + self.record_span(span_start860, "DateType") + return result861 def parse_datetime_type(self) -> logic_pb2.DateTimeType: - span_start857 = self.span_start() + span_start862 = self.span_start() self.consume_literal("DATETIME") - _t1618 = logic_pb2.DateTimeType() - result858 = _t1618 - self.record_span(span_start857, "DateTimeType") - return result858 + _t1631 = logic_pb2.DateTimeType() + result863 = _t1631 + self.record_span(span_start862, "DateTimeType") + return result863 def parse_missing_type(self) -> logic_pb2.MissingType: - span_start859 = self.span_start() + span_start864 = self.span_start() self.consume_literal("MISSING") - _t1619 = logic_pb2.MissingType() - result860 = _t1619 - self.record_span(span_start859, "MissingType") - return result860 + _t1632 = logic_pb2.MissingType() + result865 = _t1632 + self.record_span(span_start864, "MissingType") + return result865 def parse_decimal_type(self) -> logic_pb2.DecimalType: - span_start863 = self.span_start() + span_start868 = self.span_start() self.consume_literal("(") self.consume_literal("DECIMAL") - int861 = self.consume_terminal("INT") - int_3862 = self.consume_terminal("INT") + int866 = self.consume_terminal("INT") + int_3867 = self.consume_terminal("INT") self.consume_literal(")") - _t1620 = logic_pb2.DecimalType(precision=int(int861), scale=int(int_3862)) - result864 = _t1620 - self.record_span(span_start863, "DecimalType") - return result864 + _t1633 = logic_pb2.DecimalType(precision=int(int866), scale=int(int_3867)) + result869 = _t1633 + self.record_span(span_start868, "DecimalType") + return result869 def parse_boolean_type(self) -> logic_pb2.BooleanType: - span_start865 = self.span_start() + span_start870 = self.span_start() self.consume_literal("BOOLEAN") - _t1621 = logic_pb2.BooleanType() - result866 = _t1621 - self.record_span(span_start865, "BooleanType") - return result866 + _t1634 = logic_pb2.BooleanType() + result871 = _t1634 + self.record_span(span_start870, "BooleanType") + return result871 def parse_int32_type(self) -> logic_pb2.Int32Type: - span_start867 = self.span_start() + span_start872 = self.span_start() self.consume_literal("INT32") - _t1622 = logic_pb2.Int32Type() - result868 = _t1622 - self.record_span(span_start867, "Int32Type") - return result868 + _t1635 = logic_pb2.Int32Type() + result873 = _t1635 + self.record_span(span_start872, "Int32Type") + return result873 def parse_float32_type(self) -> logic_pb2.Float32Type: - span_start869 = self.span_start() + span_start874 = self.span_start() self.consume_literal("FLOAT32") - _t1623 = logic_pb2.Float32Type() - result870 = _t1623 - self.record_span(span_start869, "Float32Type") - return result870 + _t1636 = logic_pb2.Float32Type() + result875 = _t1636 + self.record_span(span_start874, "Float32Type") + return result875 def parse_uint32_type(self) -> logic_pb2.UInt32Type: - span_start871 = self.span_start() + span_start876 = self.span_start() self.consume_literal("UINT32") - _t1624 = logic_pb2.UInt32Type() - result872 = _t1624 - self.record_span(span_start871, "UInt32Type") - return result872 + _t1637 = logic_pb2.UInt32Type() + result877 = _t1637 + self.record_span(span_start876, "UInt32Type") + return result877 + + def parse_fixed_type(self) -> logic_pb2.FixedType: + span_start879 = self.span_start() + self.consume_literal("(") + self.consume_literal("FIXED") + int878 = self.consume_terminal("INT") + self.consume_literal(")") + _t1638 = logic_pb2.FixedType(length=int(int878)) + result880 = _t1638 + self.record_span(span_start879, "FixedType") + return result880 def parse_value_bindings(self) -> Sequence[logic_pb2.Binding]: self.consume_literal("|") - xs873 = [] - cond874 = self.match_lookahead_terminal("SYMBOL", 0) - while cond874: - _t1625 = self.parse_binding() - item875 = _t1625 - xs873.append(item875) - cond874 = self.match_lookahead_terminal("SYMBOL", 0) - bindings876 = xs873 - return bindings876 + xs881 = [] + cond882 = self.match_lookahead_terminal("SYMBOL", 0) + while cond882: + _t1639 = self.parse_binding() + item883 = _t1639 + xs881.append(item883) + cond882 = self.match_lookahead_terminal("SYMBOL", 0) + bindings884 = xs881 + return bindings884 def parse_formula(self) -> logic_pb2.Formula: - span_start891 = self.span_start() + span_start899 = self.span_start() if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("true", 1): - _t1627 = 0 + _t1641 = 0 else: if self.match_lookahead_literal("relatom", 1): - _t1628 = 11 + _t1642 = 11 else: if self.match_lookahead_literal("reduce", 1): - _t1629 = 3 + _t1643 = 3 else: if self.match_lookahead_literal("primitive", 1): - _t1630 = 10 + _t1644 = 10 else: if self.match_lookahead_literal("pragma", 1): - _t1631 = 9 + _t1645 = 9 else: if self.match_lookahead_literal("or", 1): - _t1632 = 5 + _t1646 = 5 else: if self.match_lookahead_literal("not", 1): - _t1633 = 6 + _t1647 = 6 else: if self.match_lookahead_literal("ffi", 1): - _t1634 = 7 + _t1648 = 7 else: if self.match_lookahead_literal("false", 1): - _t1635 = 1 + _t1649 = 1 else: if self.match_lookahead_literal("exists", 1): - _t1636 = 2 + _t1650 = 2 else: if self.match_lookahead_literal("cast", 1): - _t1637 = 12 + _t1651 = 12 else: if self.match_lookahead_literal("atom", 1): - _t1638 = 8 + _t1652 = 8 else: if self.match_lookahead_literal("and", 1): - _t1639 = 4 + _t1653 = 4 else: if self.match_lookahead_literal(">=", 1): - _t1640 = 10 + _t1654 = 10 else: if self.match_lookahead_literal(">", 1): - _t1641 = 10 + _t1655 = 10 else: if self.match_lookahead_literal("=", 1): - _t1642 = 10 + _t1656 = 10 else: if self.match_lookahead_literal("<=", 1): - _t1643 = 10 + _t1657 = 10 else: if self.match_lookahead_literal("<", 1): - _t1644 = 10 + _t1658 = 10 else: if self.match_lookahead_literal("/", 1): - _t1645 = 10 + _t1659 = 10 else: if self.match_lookahead_literal("-", 1): - _t1646 = 10 + _t1660 = 10 else: if self.match_lookahead_literal("+", 1): - _t1647 = 10 + _t1661 = 10 else: if self.match_lookahead_literal("*", 1): - _t1648 = 10 + _t1662 = 10 else: - _t1648 = -1 - _t1647 = _t1648 - _t1646 = _t1647 - _t1645 = _t1646 - _t1644 = _t1645 - _t1643 = _t1644 - _t1642 = _t1643 - _t1641 = _t1642 - _t1640 = _t1641 - _t1639 = _t1640 - _t1638 = _t1639 - _t1637 = _t1638 - _t1636 = _t1637 - _t1635 = _t1636 - _t1634 = _t1635 - _t1633 = _t1634 - _t1632 = _t1633 - _t1631 = _t1632 - _t1630 = _t1631 - _t1629 = _t1630 - _t1628 = _t1629 - _t1627 = _t1628 - _t1626 = _t1627 + _t1662 = -1 + _t1661 = _t1662 + _t1660 = _t1661 + _t1659 = _t1660 + _t1658 = _t1659 + _t1657 = _t1658 + _t1656 = _t1657 + _t1655 = _t1656 + _t1654 = _t1655 + _t1653 = _t1654 + _t1652 = _t1653 + _t1651 = _t1652 + _t1650 = _t1651 + _t1649 = _t1650 + _t1648 = _t1649 + _t1647 = _t1648 + _t1646 = _t1647 + _t1645 = _t1646 + _t1644 = _t1645 + _t1643 = _t1644 + _t1642 = _t1643 + _t1641 = _t1642 + _t1640 = _t1641 else: - _t1626 = -1 - prediction877 = _t1626 - if prediction877 == 12: - _t1650 = self.parse_cast() - cast890 = _t1650 - _t1651 = logic_pb2.Formula(cast=cast890) - _t1649 = _t1651 + _t1640 = -1 + prediction885 = _t1640 + if prediction885 == 12: + _t1664 = self.parse_cast() + cast898 = _t1664 + _t1665 = logic_pb2.Formula(cast=cast898) + _t1663 = _t1665 else: - if prediction877 == 11: - _t1653 = self.parse_rel_atom() - rel_atom889 = _t1653 - _t1654 = logic_pb2.Formula(rel_atom=rel_atom889) - _t1652 = _t1654 + if prediction885 == 11: + _t1667 = self.parse_rel_atom() + rel_atom897 = _t1667 + _t1668 = logic_pb2.Formula(rel_atom=rel_atom897) + _t1666 = _t1668 else: - if prediction877 == 10: - _t1656 = self.parse_primitive() - primitive888 = _t1656 - _t1657 = logic_pb2.Formula(primitive=primitive888) - _t1655 = _t1657 + if prediction885 == 10: + _t1670 = self.parse_primitive() + primitive896 = _t1670 + _t1671 = logic_pb2.Formula(primitive=primitive896) + _t1669 = _t1671 else: - if prediction877 == 9: - _t1659 = self.parse_pragma() - pragma887 = _t1659 - _t1660 = logic_pb2.Formula(pragma=pragma887) - _t1658 = _t1660 + if prediction885 == 9: + _t1673 = self.parse_pragma() + pragma895 = _t1673 + _t1674 = logic_pb2.Formula(pragma=pragma895) + _t1672 = _t1674 else: - if prediction877 == 8: - _t1662 = self.parse_atom() - atom886 = _t1662 - _t1663 = logic_pb2.Formula(atom=atom886) - _t1661 = _t1663 + if prediction885 == 8: + _t1676 = self.parse_atom() + atom894 = _t1676 + _t1677 = logic_pb2.Formula(atom=atom894) + _t1675 = _t1677 else: - if prediction877 == 7: - _t1665 = self.parse_ffi() - ffi885 = _t1665 - _t1666 = logic_pb2.Formula(ffi=ffi885) - _t1664 = _t1666 + if prediction885 == 7: + _t1679 = self.parse_ffi() + ffi893 = _t1679 + _t1680 = logic_pb2.Formula(ffi=ffi893) + _t1678 = _t1680 else: - if prediction877 == 6: - _t1668 = self.parse_not() - not884 = _t1668 - _t1669 = logic_pb2.Formula() - getattr(_t1669, 'not').CopyFrom(not884) - _t1667 = _t1669 + if prediction885 == 6: + _t1682 = self.parse_not() + not892 = _t1682 + _t1683 = logic_pb2.Formula() + getattr(_t1683, 'not').CopyFrom(not892) + _t1681 = _t1683 else: - if prediction877 == 5: - _t1671 = self.parse_disjunction() - disjunction883 = _t1671 - _t1672 = logic_pb2.Formula(disjunction=disjunction883) - _t1670 = _t1672 + if prediction885 == 5: + _t1685 = self.parse_disjunction() + disjunction891 = _t1685 + _t1686 = logic_pb2.Formula(disjunction=disjunction891) + _t1684 = _t1686 else: - if prediction877 == 4: - _t1674 = self.parse_conjunction() - conjunction882 = _t1674 - _t1675 = logic_pb2.Formula(conjunction=conjunction882) - _t1673 = _t1675 + if prediction885 == 4: + _t1688 = self.parse_conjunction() + conjunction890 = _t1688 + _t1689 = logic_pb2.Formula(conjunction=conjunction890) + _t1687 = _t1689 else: - if prediction877 == 3: - _t1677 = self.parse_reduce() - reduce881 = _t1677 - _t1678 = logic_pb2.Formula(reduce=reduce881) - _t1676 = _t1678 + if prediction885 == 3: + _t1691 = self.parse_reduce() + reduce889 = _t1691 + _t1692 = logic_pb2.Formula(reduce=reduce889) + _t1690 = _t1692 else: - if prediction877 == 2: - _t1680 = self.parse_exists() - exists880 = _t1680 - _t1681 = logic_pb2.Formula(exists=exists880) - _t1679 = _t1681 + if prediction885 == 2: + _t1694 = self.parse_exists() + exists888 = _t1694 + _t1695 = logic_pb2.Formula(exists=exists888) + _t1693 = _t1695 else: - if prediction877 == 1: - _t1683 = self.parse_false() - false879 = _t1683 - _t1684 = logic_pb2.Formula(disjunction=false879) - _t1682 = _t1684 + if prediction885 == 1: + _t1697 = self.parse_false() + false887 = _t1697 + _t1698 = logic_pb2.Formula(disjunction=false887) + _t1696 = _t1698 else: - if prediction877 == 0: - _t1686 = self.parse_true() - true878 = _t1686 - _t1687 = logic_pb2.Formula(conjunction=true878) - _t1685 = _t1687 + if prediction885 == 0: + _t1700 = self.parse_true() + true886 = _t1700 + _t1701 = logic_pb2.Formula(conjunction=true886) + _t1699 = _t1701 else: raise ParseError("Unexpected token in formula" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1682 = _t1685 - _t1679 = _t1682 - _t1676 = _t1679 - _t1673 = _t1676 - _t1670 = _t1673 - _t1667 = _t1670 - _t1664 = _t1667 - _t1661 = _t1664 - _t1658 = _t1661 - _t1655 = _t1658 - _t1652 = _t1655 - _t1649 = _t1652 - result892 = _t1649 - self.record_span(span_start891, "Formula") - return result892 + _t1696 = _t1699 + _t1693 = _t1696 + _t1690 = _t1693 + _t1687 = _t1690 + _t1684 = _t1687 + _t1681 = _t1684 + _t1678 = _t1681 + _t1675 = _t1678 + _t1672 = _t1675 + _t1669 = _t1672 + _t1666 = _t1669 + _t1663 = _t1666 + result900 = _t1663 + self.record_span(span_start899, "Formula") + return result900 def parse_true(self) -> logic_pb2.Conjunction: - span_start893 = self.span_start() + span_start901 = self.span_start() self.consume_literal("(") self.consume_literal("true") self.consume_literal(")") - _t1688 = logic_pb2.Conjunction(args=[]) - result894 = _t1688 - self.record_span(span_start893, "Conjunction") - return result894 + _t1702 = logic_pb2.Conjunction(args=[]) + result902 = _t1702 + self.record_span(span_start901, "Conjunction") + return result902 def parse_false(self) -> logic_pb2.Disjunction: - span_start895 = self.span_start() + span_start903 = self.span_start() self.consume_literal("(") self.consume_literal("false") self.consume_literal(")") - _t1689 = logic_pb2.Disjunction(args=[]) - result896 = _t1689 - self.record_span(span_start895, "Disjunction") - return result896 + _t1703 = logic_pb2.Disjunction(args=[]) + result904 = _t1703 + self.record_span(span_start903, "Disjunction") + return result904 def parse_exists(self) -> logic_pb2.Exists: - span_start899 = self.span_start() + span_start907 = self.span_start() self.consume_literal("(") self.consume_literal("exists") - _t1690 = self.parse_bindings() - bindings897 = _t1690 - _t1691 = self.parse_formula() - formula898 = _t1691 + _t1704 = self.parse_bindings() + bindings905 = _t1704 + _t1705 = self.parse_formula() + formula906 = _t1705 self.consume_literal(")") - _t1692 = logic_pb2.Abstraction(vars=(list(bindings897[0]) + list(bindings897[1] if bindings897[1] is not None else [])), value=formula898) - _t1693 = logic_pb2.Exists(body=_t1692) - result900 = _t1693 - self.record_span(span_start899, "Exists") - return result900 + _t1706 = logic_pb2.Abstraction(vars=(list(bindings905[0]) + list(bindings905[1] if bindings905[1] is not None else [])), value=formula906) + _t1707 = logic_pb2.Exists(body=_t1706) + result908 = _t1707 + self.record_span(span_start907, "Exists") + return result908 def parse_reduce(self) -> logic_pb2.Reduce: - span_start904 = self.span_start() + span_start912 = self.span_start() self.consume_literal("(") self.consume_literal("reduce") - _t1694 = self.parse_abstraction() - abstraction901 = _t1694 - _t1695 = self.parse_abstraction() - abstraction_3902 = _t1695 - _t1696 = self.parse_terms() - terms903 = _t1696 + _t1708 = self.parse_abstraction() + abstraction909 = _t1708 + _t1709 = self.parse_abstraction() + abstraction_3910 = _t1709 + _t1710 = self.parse_terms() + terms911 = _t1710 self.consume_literal(")") - _t1697 = logic_pb2.Reduce(op=abstraction901, body=abstraction_3902, terms=terms903) - result905 = _t1697 - self.record_span(span_start904, "Reduce") - return result905 + _t1711 = logic_pb2.Reduce(op=abstraction909, body=abstraction_3910, terms=terms911) + result913 = _t1711 + self.record_span(span_start912, "Reduce") + return result913 def parse_terms(self) -> Sequence[logic_pb2.Term]: self.consume_literal("(") self.consume_literal("terms") - xs906 = [] - cond907 = (((((((((((((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 cond907: - _t1698 = self.parse_term() - item908 = _t1698 - xs906.append(item908) - cond907 = (((((((((((((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)) - terms909 = xs906 + xs914 = [] + cond915 = (((((((((((((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 cond915: + _t1712 = self.parse_term() + item916 = _t1712 + xs914.append(item916) + cond915 = (((((((((((((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)) + terms917 = xs914 self.consume_literal(")") - return terms909 + return terms917 def parse_term(self) -> logic_pb2.Term: - span_start913 = self.span_start() + span_start921 = self.span_start() if self.match_lookahead_literal("true", 0): - _t1699 = 1 + _t1713 = 1 else: if self.match_lookahead_literal("missing", 0): - _t1700 = 1 + _t1714 = 1 else: if self.match_lookahead_literal("false", 0): - _t1701 = 1 + _t1715 = 1 else: if self.match_lookahead_literal("(", 0): - _t1702 = 1 + _t1716 = 1 else: if self.match_lookahead_terminal("SYMBOL", 0): - _t1703 = 0 + _t1717 = 0 else: if self.match_lookahead_terminal("UINT32", 0): - _t1704 = 1 + _t1718 = 1 else: if self.match_lookahead_terminal("UINT128", 0): - _t1705 = 1 + _t1719 = 1 else: if self.match_lookahead_terminal("STRING", 0): - _t1706 = 1 + _t1720 = 1 else: if self.match_lookahead_terminal("INT32", 0): - _t1707 = 1 + _t1721 = 1 else: if self.match_lookahead_terminal("INT128", 0): - _t1708 = 1 + _t1722 = 1 else: if self.match_lookahead_terminal("INT", 0): - _t1709 = 1 + _t1723 = 1 else: if self.match_lookahead_terminal("FLOAT32", 0): - _t1710 = 1 + _t1724 = 1 else: if self.match_lookahead_terminal("FLOAT", 0): - _t1711 = 1 + _t1725 = 1 else: if self.match_lookahead_terminal("DECIMAL", 0): - _t1712 = 1 + _t1726 = 1 else: - _t1712 = -1 - _t1711 = _t1712 - _t1710 = _t1711 - _t1709 = _t1710 - _t1708 = _t1709 - _t1707 = _t1708 - _t1706 = _t1707 - _t1705 = _t1706 - _t1704 = _t1705 - _t1703 = _t1704 - _t1702 = _t1703 - _t1701 = _t1702 - _t1700 = _t1701 - _t1699 = _t1700 - prediction910 = _t1699 - if prediction910 == 1: - _t1714 = self.parse_value() - value912 = _t1714 - _t1715 = logic_pb2.Term(constant=value912) - _t1713 = _t1715 + _t1726 = -1 + _t1725 = _t1726 + _t1724 = _t1725 + _t1723 = _t1724 + _t1722 = _t1723 + _t1721 = _t1722 + _t1720 = _t1721 + _t1719 = _t1720 + _t1718 = _t1719 + _t1717 = _t1718 + _t1716 = _t1717 + _t1715 = _t1716 + _t1714 = _t1715 + _t1713 = _t1714 + prediction918 = _t1713 + if prediction918 == 1: + _t1728 = self.parse_value() + value920 = _t1728 + _t1729 = logic_pb2.Term(constant=value920) + _t1727 = _t1729 else: - if prediction910 == 0: - _t1717 = self.parse_var() - var911 = _t1717 - _t1718 = logic_pb2.Term(var=var911) - _t1716 = _t1718 + if prediction918 == 0: + _t1731 = self.parse_var() + var919 = _t1731 + _t1732 = logic_pb2.Term(var=var919) + _t1730 = _t1732 else: raise ParseError("Unexpected token in term" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1713 = _t1716 - result914 = _t1713 - self.record_span(span_start913, "Term") - return result914 + _t1727 = _t1730 + result922 = _t1727 + self.record_span(span_start921, "Term") + return result922 def parse_var(self) -> logic_pb2.Var: - span_start916 = self.span_start() - symbol915 = self.consume_terminal("SYMBOL") - _t1719 = logic_pb2.Var(name=symbol915) - result917 = _t1719 - self.record_span(span_start916, "Var") - return result917 + span_start924 = self.span_start() + symbol923 = self.consume_terminal("SYMBOL") + _t1733 = logic_pb2.Var(name=symbol923) + result925 = _t1733 + self.record_span(span_start924, "Var") + return result925 def parse_value(self) -> logic_pb2.Value: - span_start931 = self.span_start() + span_start939 = self.span_start() if self.match_lookahead_literal("true", 0): - _t1720 = 12 + _t1734 = 12 else: if self.match_lookahead_literal("missing", 0): - _t1721 = 11 + _t1735 = 11 else: if self.match_lookahead_literal("false", 0): - _t1722 = 12 + _t1736 = 12 else: if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("datetime", 1): - _t1724 = 1 + _t1738 = 1 else: if self.match_lookahead_literal("date", 1): - _t1725 = 0 + _t1739 = 0 else: - _t1725 = -1 - _t1724 = _t1725 - _t1723 = _t1724 + _t1739 = -1 + _t1738 = _t1739 + _t1737 = _t1738 else: if self.match_lookahead_terminal("UINT32", 0): - _t1726 = 7 + _t1740 = 7 else: if self.match_lookahead_terminal("UINT128", 0): - _t1727 = 8 + _t1741 = 8 else: if self.match_lookahead_terminal("STRING", 0): - _t1728 = 2 + _t1742 = 2 else: if self.match_lookahead_terminal("INT32", 0): - _t1729 = 3 + _t1743 = 3 else: if self.match_lookahead_terminal("INT128", 0): - _t1730 = 9 + _t1744 = 9 else: if self.match_lookahead_terminal("INT", 0): - _t1731 = 4 + _t1745 = 4 else: if self.match_lookahead_terminal("FLOAT32", 0): - _t1732 = 5 + _t1746 = 5 else: if self.match_lookahead_terminal("FLOAT", 0): - _t1733 = 6 + _t1747 = 6 else: if self.match_lookahead_terminal("DECIMAL", 0): - _t1734 = 10 + _t1748 = 10 else: - _t1734 = -1 - _t1733 = _t1734 - _t1732 = _t1733 - _t1731 = _t1732 - _t1730 = _t1731 - _t1729 = _t1730 - _t1728 = _t1729 - _t1727 = _t1728 - _t1726 = _t1727 - _t1723 = _t1726 - _t1722 = _t1723 - _t1721 = _t1722 - _t1720 = _t1721 - prediction918 = _t1720 - if prediction918 == 12: - _t1736 = self.parse_boolean_value() - boolean_value930 = _t1736 - _t1737 = logic_pb2.Value(boolean_value=boolean_value930) - _t1735 = _t1737 + _t1748 = -1 + _t1747 = _t1748 + _t1746 = _t1747 + _t1745 = _t1746 + _t1744 = _t1745 + _t1743 = _t1744 + _t1742 = _t1743 + _t1741 = _t1742 + _t1740 = _t1741 + _t1737 = _t1740 + _t1736 = _t1737 + _t1735 = _t1736 + _t1734 = _t1735 + prediction926 = _t1734 + if prediction926 == 12: + _t1750 = self.parse_boolean_value() + boolean_value938 = _t1750 + _t1751 = logic_pb2.Value(boolean_value=boolean_value938) + _t1749 = _t1751 else: - if prediction918 == 11: + if prediction926 == 11: self.consume_literal("missing") - _t1739 = logic_pb2.MissingValue() - _t1740 = logic_pb2.Value(missing_value=_t1739) - _t1738 = _t1740 + _t1753 = logic_pb2.MissingValue() + _t1754 = logic_pb2.Value(missing_value=_t1753) + _t1752 = _t1754 else: - if prediction918 == 10: - formatted_decimal929 = self.consume_terminal("DECIMAL") - _t1742 = logic_pb2.Value(decimal_value=formatted_decimal929) - _t1741 = _t1742 + if prediction926 == 10: + formatted_decimal937 = self.consume_terminal("DECIMAL") + _t1756 = logic_pb2.Value(decimal_value=formatted_decimal937) + _t1755 = _t1756 else: - if prediction918 == 9: - formatted_int128928 = self.consume_terminal("INT128") - _t1744 = logic_pb2.Value(int128_value=formatted_int128928) - _t1743 = _t1744 + if prediction926 == 9: + formatted_int128936 = self.consume_terminal("INT128") + _t1758 = logic_pb2.Value(int128_value=formatted_int128936) + _t1757 = _t1758 else: - if prediction918 == 8: - formatted_uint128927 = self.consume_terminal("UINT128") - _t1746 = logic_pb2.Value(uint128_value=formatted_uint128927) - _t1745 = _t1746 + if prediction926 == 8: + formatted_uint128935 = self.consume_terminal("UINT128") + _t1760 = logic_pb2.Value(uint128_value=formatted_uint128935) + _t1759 = _t1760 else: - if prediction918 == 7: - formatted_uint32926 = self.consume_terminal("UINT32") - _t1748 = logic_pb2.Value(uint32_value=formatted_uint32926) - _t1747 = _t1748 + if prediction926 == 7: + formatted_uint32934 = self.consume_terminal("UINT32") + _t1762 = logic_pb2.Value(uint32_value=formatted_uint32934) + _t1761 = _t1762 else: - if prediction918 == 6: - formatted_float925 = self.consume_terminal("FLOAT") - _t1750 = logic_pb2.Value(float_value=formatted_float925) - _t1749 = _t1750 + if prediction926 == 6: + formatted_float933 = self.consume_terminal("FLOAT") + _t1764 = logic_pb2.Value(float_value=formatted_float933) + _t1763 = _t1764 else: - if prediction918 == 5: - formatted_float32924 = self.consume_terminal("FLOAT32") - _t1752 = logic_pb2.Value(float32_value=formatted_float32924) - _t1751 = _t1752 + if prediction926 == 5: + formatted_float32932 = self.consume_terminal("FLOAT32") + _t1766 = logic_pb2.Value(float32_value=formatted_float32932) + _t1765 = _t1766 else: - if prediction918 == 4: - formatted_int923 = self.consume_terminal("INT") - _t1754 = logic_pb2.Value(int_value=formatted_int923) - _t1753 = _t1754 + if prediction926 == 4: + formatted_int931 = self.consume_terminal("INT") + _t1768 = logic_pb2.Value(int_value=formatted_int931) + _t1767 = _t1768 else: - if prediction918 == 3: - formatted_int32922 = self.consume_terminal("INT32") - _t1756 = logic_pb2.Value(int32_value=formatted_int32922) - _t1755 = _t1756 + if prediction926 == 3: + formatted_int32930 = self.consume_terminal("INT32") + _t1770 = logic_pb2.Value(int32_value=formatted_int32930) + _t1769 = _t1770 else: - if prediction918 == 2: - formatted_string921 = self.consume_terminal("STRING") - _t1758 = logic_pb2.Value(string_value=formatted_string921) - _t1757 = _t1758 + if prediction926 == 2: + formatted_string929 = self.consume_terminal("STRING") + _t1772 = logic_pb2.Value(string_value=formatted_string929) + _t1771 = _t1772 else: - if prediction918 == 1: - _t1760 = self.parse_datetime() - datetime920 = _t1760 - _t1761 = logic_pb2.Value(datetime_value=datetime920) - _t1759 = _t1761 + if prediction926 == 1: + _t1774 = self.parse_datetime() + datetime928 = _t1774 + _t1775 = logic_pb2.Value(datetime_value=datetime928) + _t1773 = _t1775 else: - if prediction918 == 0: - _t1763 = self.parse_date() - date919 = _t1763 - _t1764 = logic_pb2.Value(date_value=date919) - _t1762 = _t1764 + if prediction926 == 0: + _t1777 = self.parse_date() + date927 = _t1777 + _t1778 = logic_pb2.Value(date_value=date927) + _t1776 = _t1778 else: raise ParseError("Unexpected token in value" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1759 = _t1762 - _t1757 = _t1759 - _t1755 = _t1757 - _t1753 = _t1755 - _t1751 = _t1753 - _t1749 = _t1751 - _t1747 = _t1749 - _t1745 = _t1747 - _t1743 = _t1745 - _t1741 = _t1743 - _t1738 = _t1741 - _t1735 = _t1738 - result932 = _t1735 - self.record_span(span_start931, "Value") - return result932 + _t1773 = _t1776 + _t1771 = _t1773 + _t1769 = _t1771 + _t1767 = _t1769 + _t1765 = _t1767 + _t1763 = _t1765 + _t1761 = _t1763 + _t1759 = _t1761 + _t1757 = _t1759 + _t1755 = _t1757 + _t1752 = _t1755 + _t1749 = _t1752 + result940 = _t1749 + self.record_span(span_start939, "Value") + return result940 def parse_date(self) -> logic_pb2.DateValue: - span_start936 = self.span_start() + span_start944 = self.span_start() self.consume_literal("(") self.consume_literal("date") - formatted_int933 = self.consume_terminal("INT") - formatted_int_3934 = self.consume_terminal("INT") - formatted_int_4935 = self.consume_terminal("INT") + formatted_int941 = self.consume_terminal("INT") + formatted_int_3942 = self.consume_terminal("INT") + formatted_int_4943 = self.consume_terminal("INT") self.consume_literal(")") - _t1765 = logic_pb2.DateValue(year=int(formatted_int933), month=int(formatted_int_3934), day=int(formatted_int_4935)) - result937 = _t1765 - self.record_span(span_start936, "DateValue") - return result937 + _t1779 = logic_pb2.DateValue(year=int(formatted_int941), month=int(formatted_int_3942), day=int(formatted_int_4943)) + result945 = _t1779 + self.record_span(span_start944, "DateValue") + return result945 def parse_datetime(self) -> logic_pb2.DateTimeValue: - span_start945 = self.span_start() + span_start953 = self.span_start() self.consume_literal("(") self.consume_literal("datetime") - formatted_int938 = self.consume_terminal("INT") - formatted_int_3939 = self.consume_terminal("INT") - formatted_int_4940 = self.consume_terminal("INT") - formatted_int_5941 = self.consume_terminal("INT") - formatted_int_6942 = self.consume_terminal("INT") - formatted_int_7943 = self.consume_terminal("INT") + formatted_int946 = self.consume_terminal("INT") + formatted_int_3947 = self.consume_terminal("INT") + formatted_int_4948 = self.consume_terminal("INT") + formatted_int_5949 = self.consume_terminal("INT") + formatted_int_6950 = self.consume_terminal("INT") + formatted_int_7951 = self.consume_terminal("INT") if self.match_lookahead_terminal("INT", 0): - _t1766 = self.consume_terminal("INT") + _t1780 = self.consume_terminal("INT") else: - _t1766 = None - formatted_int_8944 = _t1766 + _t1780 = None + formatted_int_8952 = _t1780 self.consume_literal(")") - _t1767 = logic_pb2.DateTimeValue(year=int(formatted_int938), month=int(formatted_int_3939), day=int(formatted_int_4940), hour=int(formatted_int_5941), minute=int(formatted_int_6942), second=int(formatted_int_7943), microsecond=int((formatted_int_8944 if formatted_int_8944 is not None else 0))) - result946 = _t1767 - self.record_span(span_start945, "DateTimeValue") - return result946 + _t1781 = logic_pb2.DateTimeValue(year=int(formatted_int946), month=int(formatted_int_3947), day=int(formatted_int_4948), hour=int(formatted_int_5949), minute=int(formatted_int_6950), second=int(formatted_int_7951), microsecond=int((formatted_int_8952 if formatted_int_8952 is not None else 0))) + result954 = _t1781 + self.record_span(span_start953, "DateTimeValue") + return result954 def parse_conjunction(self) -> logic_pb2.Conjunction: - span_start951 = self.span_start() + span_start959 = self.span_start() self.consume_literal("(") self.consume_literal("and") - xs947 = [] - cond948 = self.match_lookahead_literal("(", 0) - while cond948: - _t1768 = self.parse_formula() - item949 = _t1768 - xs947.append(item949) - cond948 = self.match_lookahead_literal("(", 0) - formulas950 = xs947 + xs955 = [] + cond956 = self.match_lookahead_literal("(", 0) + while cond956: + _t1782 = self.parse_formula() + item957 = _t1782 + xs955.append(item957) + cond956 = self.match_lookahead_literal("(", 0) + formulas958 = xs955 self.consume_literal(")") - _t1769 = logic_pb2.Conjunction(args=formulas950) - result952 = _t1769 - self.record_span(span_start951, "Conjunction") - return result952 + _t1783 = logic_pb2.Conjunction(args=formulas958) + result960 = _t1783 + self.record_span(span_start959, "Conjunction") + return result960 def parse_disjunction(self) -> logic_pb2.Disjunction: - span_start957 = self.span_start() + span_start965 = self.span_start() self.consume_literal("(") self.consume_literal("or") - xs953 = [] - cond954 = self.match_lookahead_literal("(", 0) - while cond954: - _t1770 = self.parse_formula() - item955 = _t1770 - xs953.append(item955) - cond954 = self.match_lookahead_literal("(", 0) - formulas956 = xs953 + xs961 = [] + cond962 = self.match_lookahead_literal("(", 0) + while cond962: + _t1784 = self.parse_formula() + item963 = _t1784 + xs961.append(item963) + cond962 = self.match_lookahead_literal("(", 0) + formulas964 = xs961 self.consume_literal(")") - _t1771 = logic_pb2.Disjunction(args=formulas956) - result958 = _t1771 - self.record_span(span_start957, "Disjunction") - return result958 + _t1785 = logic_pb2.Disjunction(args=formulas964) + result966 = _t1785 + self.record_span(span_start965, "Disjunction") + return result966 def parse_not(self) -> logic_pb2.Not: - span_start960 = self.span_start() + span_start968 = self.span_start() self.consume_literal("(") self.consume_literal("not") - _t1772 = self.parse_formula() - formula959 = _t1772 + _t1786 = self.parse_formula() + formula967 = _t1786 self.consume_literal(")") - _t1773 = logic_pb2.Not(arg=formula959) - result961 = _t1773 - self.record_span(span_start960, "Not") - return result961 + _t1787 = logic_pb2.Not(arg=formula967) + result969 = _t1787 + self.record_span(span_start968, "Not") + return result969 def parse_ffi(self) -> logic_pb2.FFI: - span_start965 = self.span_start() + span_start973 = self.span_start() self.consume_literal("(") self.consume_literal("ffi") - _t1774 = self.parse_name() - name962 = _t1774 - _t1775 = self.parse_ffi_args() - ffi_args963 = _t1775 - _t1776 = self.parse_terms() - terms964 = _t1776 + _t1788 = self.parse_name() + name970 = _t1788 + _t1789 = self.parse_ffi_args() + ffi_args971 = _t1789 + _t1790 = self.parse_terms() + terms972 = _t1790 self.consume_literal(")") - _t1777 = logic_pb2.FFI(name=name962, args=ffi_args963, terms=terms964) - result966 = _t1777 - self.record_span(span_start965, "FFI") - return result966 + _t1791 = logic_pb2.FFI(name=name970, args=ffi_args971, terms=terms972) + result974 = _t1791 + self.record_span(span_start973, "FFI") + return result974 def parse_name(self) -> str: self.consume_literal(":") - symbol967 = self.consume_terminal("SYMBOL") - return symbol967 + symbol975 = self.consume_terminal("SYMBOL") + return symbol975 def parse_ffi_args(self) -> Sequence[logic_pb2.Abstraction]: self.consume_literal("(") self.consume_literal("args") - xs968 = [] - cond969 = self.match_lookahead_literal("(", 0) - while cond969: - _t1778 = self.parse_abstraction() - item970 = _t1778 - xs968.append(item970) - cond969 = self.match_lookahead_literal("(", 0) - abstractions971 = xs968 + xs976 = [] + cond977 = self.match_lookahead_literal("(", 0) + while cond977: + _t1792 = self.parse_abstraction() + item978 = _t1792 + xs976.append(item978) + cond977 = self.match_lookahead_literal("(", 0) + abstractions979 = xs976 self.consume_literal(")") - return abstractions971 + return abstractions979 def parse_atom(self) -> logic_pb2.Atom: - span_start977 = self.span_start() + span_start985 = self.span_start() self.consume_literal("(") self.consume_literal("atom") - _t1779 = self.parse_relation_id() - relation_id972 = _t1779 - xs973 = [] - cond974 = (((((((((((((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 cond974: - _t1780 = self.parse_term() - item975 = _t1780 - xs973.append(item975) - cond974 = (((((((((((((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)) - terms976 = xs973 + _t1793 = self.parse_relation_id() + relation_id980 = _t1793 + xs981 = [] + cond982 = (((((((((((((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 cond982: + _t1794 = self.parse_term() + item983 = _t1794 + xs981.append(item983) + cond982 = (((((((((((((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)) + terms984 = xs981 self.consume_literal(")") - _t1781 = logic_pb2.Atom(name=relation_id972, terms=terms976) - result978 = _t1781 - self.record_span(span_start977, "Atom") - return result978 + _t1795 = logic_pb2.Atom(name=relation_id980, terms=terms984) + result986 = _t1795 + self.record_span(span_start985, "Atom") + return result986 def parse_pragma(self) -> logic_pb2.Pragma: - span_start984 = self.span_start() + span_start992 = self.span_start() self.consume_literal("(") self.consume_literal("pragma") - _t1782 = self.parse_name() - name979 = _t1782 - xs980 = [] - cond981 = (((((((((((((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 cond981: - _t1783 = self.parse_term() - item982 = _t1783 - xs980.append(item982) - cond981 = (((((((((((((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)) - terms983 = xs980 + _t1796 = self.parse_name() + name987 = _t1796 + xs988 = [] + cond989 = (((((((((((((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 cond989: + _t1797 = self.parse_term() + item990 = _t1797 + xs988.append(item990) + cond989 = (((((((((((((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)) + terms991 = xs988 self.consume_literal(")") - _t1784 = logic_pb2.Pragma(name=name979, terms=terms983) - result985 = _t1784 - self.record_span(span_start984, "Pragma") - return result985 + _t1798 = logic_pb2.Pragma(name=name987, terms=terms991) + result993 = _t1798 + self.record_span(span_start992, "Pragma") + return result993 def parse_primitive(self) -> logic_pb2.Primitive: - span_start1001 = self.span_start() + span_start1009 = self.span_start() if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("primitive", 1): - _t1786 = 9 + _t1800 = 9 else: if self.match_lookahead_literal(">=", 1): - _t1787 = 4 + _t1801 = 4 else: if self.match_lookahead_literal(">", 1): - _t1788 = 3 + _t1802 = 3 else: if self.match_lookahead_literal("=", 1): - _t1789 = 0 + _t1803 = 0 else: if self.match_lookahead_literal("<=", 1): - _t1790 = 2 + _t1804 = 2 else: if self.match_lookahead_literal("<", 1): - _t1791 = 1 + _t1805 = 1 else: if self.match_lookahead_literal("/", 1): - _t1792 = 8 + _t1806 = 8 else: if self.match_lookahead_literal("-", 1): - _t1793 = 6 + _t1807 = 6 else: if self.match_lookahead_literal("+", 1): - _t1794 = 5 + _t1808 = 5 else: if self.match_lookahead_literal("*", 1): - _t1795 = 7 + _t1809 = 7 else: - _t1795 = -1 - _t1794 = _t1795 - _t1793 = _t1794 - _t1792 = _t1793 - _t1791 = _t1792 - _t1790 = _t1791 - _t1789 = _t1790 - _t1788 = _t1789 - _t1787 = _t1788 - _t1786 = _t1787 - _t1785 = _t1786 + _t1809 = -1 + _t1808 = _t1809 + _t1807 = _t1808 + _t1806 = _t1807 + _t1805 = _t1806 + _t1804 = _t1805 + _t1803 = _t1804 + _t1802 = _t1803 + _t1801 = _t1802 + _t1800 = _t1801 + _t1799 = _t1800 else: - _t1785 = -1 - prediction986 = _t1785 - if prediction986 == 9: + _t1799 = -1 + prediction994 = _t1799 + if prediction994 == 9: self.consume_literal("(") self.consume_literal("primitive") - _t1797 = self.parse_name() - name996 = _t1797 - xs997 = [] - cond998 = ((((((((((((((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 cond998: - _t1798 = self.parse_rel_term() - item999 = _t1798 - xs997.append(item999) - cond998 = ((((((((((((((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_terms1000 = xs997 + _t1811 = self.parse_name() + name1004 = _t1811 + xs1005 = [] + cond1006 = ((((((((((((((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 cond1006: + _t1812 = self.parse_rel_term() + item1007 = _t1812 + xs1005.append(item1007) + cond1006 = ((((((((((((((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_terms1008 = xs1005 self.consume_literal(")") - _t1799 = logic_pb2.Primitive(name=name996, terms=rel_terms1000) - _t1796 = _t1799 + _t1813 = logic_pb2.Primitive(name=name1004, terms=rel_terms1008) + _t1810 = _t1813 else: - if prediction986 == 8: - _t1801 = self.parse_divide() - divide995 = _t1801 - _t1800 = divide995 + if prediction994 == 8: + _t1815 = self.parse_divide() + divide1003 = _t1815 + _t1814 = divide1003 else: - if prediction986 == 7: - _t1803 = self.parse_multiply() - multiply994 = _t1803 - _t1802 = multiply994 + if prediction994 == 7: + _t1817 = self.parse_multiply() + multiply1002 = _t1817 + _t1816 = multiply1002 else: - if prediction986 == 6: - _t1805 = self.parse_minus() - minus993 = _t1805 - _t1804 = minus993 + if prediction994 == 6: + _t1819 = self.parse_minus() + minus1001 = _t1819 + _t1818 = minus1001 else: - if prediction986 == 5: - _t1807 = self.parse_add() - add992 = _t1807 - _t1806 = add992 + if prediction994 == 5: + _t1821 = self.parse_add() + add1000 = _t1821 + _t1820 = add1000 else: - if prediction986 == 4: - _t1809 = self.parse_gt_eq() - gt_eq991 = _t1809 - _t1808 = gt_eq991 + if prediction994 == 4: + _t1823 = self.parse_gt_eq() + gt_eq999 = _t1823 + _t1822 = gt_eq999 else: - if prediction986 == 3: - _t1811 = self.parse_gt() - gt990 = _t1811 - _t1810 = gt990 + if prediction994 == 3: + _t1825 = self.parse_gt() + gt998 = _t1825 + _t1824 = gt998 else: - if prediction986 == 2: - _t1813 = self.parse_lt_eq() - lt_eq989 = _t1813 - _t1812 = lt_eq989 + if prediction994 == 2: + _t1827 = self.parse_lt_eq() + lt_eq997 = _t1827 + _t1826 = lt_eq997 else: - if prediction986 == 1: - _t1815 = self.parse_lt() - lt988 = _t1815 - _t1814 = lt988 + if prediction994 == 1: + _t1829 = self.parse_lt() + lt996 = _t1829 + _t1828 = lt996 else: - if prediction986 == 0: - _t1817 = self.parse_eq() - eq987 = _t1817 - _t1816 = eq987 + if prediction994 == 0: + _t1831 = self.parse_eq() + eq995 = _t1831 + _t1830 = eq995 else: raise ParseError("Unexpected token in primitive" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1814 = _t1816 - _t1812 = _t1814 - _t1810 = _t1812 - _t1808 = _t1810 - _t1806 = _t1808 - _t1804 = _t1806 - _t1802 = _t1804 - _t1800 = _t1802 - _t1796 = _t1800 - result1002 = _t1796 - self.record_span(span_start1001, "Primitive") - return result1002 + _t1828 = _t1830 + _t1826 = _t1828 + _t1824 = _t1826 + _t1822 = _t1824 + _t1820 = _t1822 + _t1818 = _t1820 + _t1816 = _t1818 + _t1814 = _t1816 + _t1810 = _t1814 + result1010 = _t1810 + self.record_span(span_start1009, "Primitive") + return result1010 def parse_eq(self) -> logic_pb2.Primitive: - span_start1005 = self.span_start() + span_start1013 = self.span_start() self.consume_literal("(") self.consume_literal("=") - _t1818 = self.parse_term() - term1003 = _t1818 - _t1819 = self.parse_term() - term_31004 = _t1819 + _t1832 = self.parse_term() + term1011 = _t1832 + _t1833 = self.parse_term() + term_31012 = _t1833 self.consume_literal(")") - _t1820 = logic_pb2.RelTerm(term=term1003) - _t1821 = logic_pb2.RelTerm(term=term_31004) - _t1822 = logic_pb2.Primitive(name="rel_primitive_eq", terms=[_t1820, _t1821]) - result1006 = _t1822 - self.record_span(span_start1005, "Primitive") - return result1006 + _t1834 = logic_pb2.RelTerm(term=term1011) + _t1835 = logic_pb2.RelTerm(term=term_31012) + _t1836 = logic_pb2.Primitive(name="rel_primitive_eq", terms=[_t1834, _t1835]) + result1014 = _t1836 + self.record_span(span_start1013, "Primitive") + return result1014 def parse_lt(self) -> logic_pb2.Primitive: - span_start1009 = self.span_start() + span_start1017 = self.span_start() self.consume_literal("(") self.consume_literal("<") - _t1823 = self.parse_term() - term1007 = _t1823 - _t1824 = self.parse_term() - term_31008 = _t1824 + _t1837 = self.parse_term() + term1015 = _t1837 + _t1838 = self.parse_term() + term_31016 = _t1838 self.consume_literal(")") - _t1825 = logic_pb2.RelTerm(term=term1007) - _t1826 = logic_pb2.RelTerm(term=term_31008) - _t1827 = logic_pb2.Primitive(name="rel_primitive_lt_monotype", terms=[_t1825, _t1826]) - result1010 = _t1827 - self.record_span(span_start1009, "Primitive") - return result1010 + _t1839 = logic_pb2.RelTerm(term=term1015) + _t1840 = logic_pb2.RelTerm(term=term_31016) + _t1841 = logic_pb2.Primitive(name="rel_primitive_lt_monotype", terms=[_t1839, _t1840]) + result1018 = _t1841 + self.record_span(span_start1017, "Primitive") + return result1018 def parse_lt_eq(self) -> logic_pb2.Primitive: - span_start1013 = self.span_start() + span_start1021 = self.span_start() self.consume_literal("(") self.consume_literal("<=") - _t1828 = self.parse_term() - term1011 = _t1828 - _t1829 = self.parse_term() - term_31012 = _t1829 + _t1842 = self.parse_term() + term1019 = _t1842 + _t1843 = self.parse_term() + term_31020 = _t1843 self.consume_literal(")") - _t1830 = logic_pb2.RelTerm(term=term1011) - _t1831 = logic_pb2.RelTerm(term=term_31012) - _t1832 = logic_pb2.Primitive(name="rel_primitive_lt_eq_monotype", terms=[_t1830, _t1831]) - result1014 = _t1832 - self.record_span(span_start1013, "Primitive") - return result1014 + _t1844 = logic_pb2.RelTerm(term=term1019) + _t1845 = logic_pb2.RelTerm(term=term_31020) + _t1846 = logic_pb2.Primitive(name="rel_primitive_lt_eq_monotype", terms=[_t1844, _t1845]) + result1022 = _t1846 + self.record_span(span_start1021, "Primitive") + return result1022 def parse_gt(self) -> logic_pb2.Primitive: - span_start1017 = self.span_start() + span_start1025 = self.span_start() self.consume_literal("(") self.consume_literal(">") - _t1833 = self.parse_term() - term1015 = _t1833 - _t1834 = self.parse_term() - term_31016 = _t1834 + _t1847 = self.parse_term() + term1023 = _t1847 + _t1848 = self.parse_term() + term_31024 = _t1848 self.consume_literal(")") - _t1835 = logic_pb2.RelTerm(term=term1015) - _t1836 = logic_pb2.RelTerm(term=term_31016) - _t1837 = logic_pb2.Primitive(name="rel_primitive_gt_monotype", terms=[_t1835, _t1836]) - result1018 = _t1837 - self.record_span(span_start1017, "Primitive") - return result1018 + _t1849 = logic_pb2.RelTerm(term=term1023) + _t1850 = logic_pb2.RelTerm(term=term_31024) + _t1851 = logic_pb2.Primitive(name="rel_primitive_gt_monotype", terms=[_t1849, _t1850]) + result1026 = _t1851 + self.record_span(span_start1025, "Primitive") + return result1026 def parse_gt_eq(self) -> logic_pb2.Primitive: - span_start1021 = self.span_start() + span_start1029 = self.span_start() self.consume_literal("(") self.consume_literal(">=") - _t1838 = self.parse_term() - term1019 = _t1838 - _t1839 = self.parse_term() - term_31020 = _t1839 + _t1852 = self.parse_term() + term1027 = _t1852 + _t1853 = self.parse_term() + term_31028 = _t1853 self.consume_literal(")") - _t1840 = logic_pb2.RelTerm(term=term1019) - _t1841 = logic_pb2.RelTerm(term=term_31020) - _t1842 = logic_pb2.Primitive(name="rel_primitive_gt_eq_monotype", terms=[_t1840, _t1841]) - result1022 = _t1842 - self.record_span(span_start1021, "Primitive") - return result1022 + _t1854 = logic_pb2.RelTerm(term=term1027) + _t1855 = logic_pb2.RelTerm(term=term_31028) + _t1856 = logic_pb2.Primitive(name="rel_primitive_gt_eq_monotype", terms=[_t1854, _t1855]) + result1030 = _t1856 + self.record_span(span_start1029, "Primitive") + return result1030 def parse_add(self) -> logic_pb2.Primitive: - span_start1026 = self.span_start() + span_start1034 = self.span_start() self.consume_literal("(") self.consume_literal("+") - _t1843 = self.parse_term() - term1023 = _t1843 - _t1844 = self.parse_term() - term_31024 = _t1844 - _t1845 = self.parse_term() - term_41025 = _t1845 + _t1857 = self.parse_term() + term1031 = _t1857 + _t1858 = self.parse_term() + term_31032 = _t1858 + _t1859 = self.parse_term() + term_41033 = _t1859 self.consume_literal(")") - _t1846 = logic_pb2.RelTerm(term=term1023) - _t1847 = logic_pb2.RelTerm(term=term_31024) - _t1848 = logic_pb2.RelTerm(term=term_41025) - _t1849 = logic_pb2.Primitive(name="rel_primitive_add_monotype", terms=[_t1846, _t1847, _t1848]) - result1027 = _t1849 - self.record_span(span_start1026, "Primitive") - return result1027 + _t1860 = logic_pb2.RelTerm(term=term1031) + _t1861 = logic_pb2.RelTerm(term=term_31032) + _t1862 = logic_pb2.RelTerm(term=term_41033) + _t1863 = logic_pb2.Primitive(name="rel_primitive_add_monotype", terms=[_t1860, _t1861, _t1862]) + result1035 = _t1863 + self.record_span(span_start1034, "Primitive") + return result1035 def parse_minus(self) -> logic_pb2.Primitive: - span_start1031 = self.span_start() + span_start1039 = self.span_start() self.consume_literal("(") self.consume_literal("-") - _t1850 = self.parse_term() - term1028 = _t1850 - _t1851 = self.parse_term() - term_31029 = _t1851 - _t1852 = self.parse_term() - term_41030 = _t1852 + _t1864 = self.parse_term() + term1036 = _t1864 + _t1865 = self.parse_term() + term_31037 = _t1865 + _t1866 = self.parse_term() + term_41038 = _t1866 self.consume_literal(")") - _t1853 = logic_pb2.RelTerm(term=term1028) - _t1854 = logic_pb2.RelTerm(term=term_31029) - _t1855 = logic_pb2.RelTerm(term=term_41030) - _t1856 = logic_pb2.Primitive(name="rel_primitive_subtract_monotype", terms=[_t1853, _t1854, _t1855]) - result1032 = _t1856 - self.record_span(span_start1031, "Primitive") - return result1032 + _t1867 = logic_pb2.RelTerm(term=term1036) + _t1868 = logic_pb2.RelTerm(term=term_31037) + _t1869 = logic_pb2.RelTerm(term=term_41038) + _t1870 = logic_pb2.Primitive(name="rel_primitive_subtract_monotype", terms=[_t1867, _t1868, _t1869]) + result1040 = _t1870 + self.record_span(span_start1039, "Primitive") + return result1040 def parse_multiply(self) -> logic_pb2.Primitive: - span_start1036 = self.span_start() + span_start1044 = self.span_start() self.consume_literal("(") self.consume_literal("*") - _t1857 = self.parse_term() - term1033 = _t1857 - _t1858 = self.parse_term() - term_31034 = _t1858 - _t1859 = self.parse_term() - term_41035 = _t1859 + _t1871 = self.parse_term() + term1041 = _t1871 + _t1872 = self.parse_term() + term_31042 = _t1872 + _t1873 = self.parse_term() + term_41043 = _t1873 self.consume_literal(")") - _t1860 = logic_pb2.RelTerm(term=term1033) - _t1861 = logic_pb2.RelTerm(term=term_31034) - _t1862 = logic_pb2.RelTerm(term=term_41035) - _t1863 = logic_pb2.Primitive(name="rel_primitive_multiply_monotype", terms=[_t1860, _t1861, _t1862]) - result1037 = _t1863 - self.record_span(span_start1036, "Primitive") - return result1037 + _t1874 = logic_pb2.RelTerm(term=term1041) + _t1875 = logic_pb2.RelTerm(term=term_31042) + _t1876 = logic_pb2.RelTerm(term=term_41043) + _t1877 = logic_pb2.Primitive(name="rel_primitive_multiply_monotype", terms=[_t1874, _t1875, _t1876]) + result1045 = _t1877 + self.record_span(span_start1044, "Primitive") + return result1045 def parse_divide(self) -> logic_pb2.Primitive: - span_start1041 = self.span_start() + span_start1049 = self.span_start() self.consume_literal("(") self.consume_literal("/") - _t1864 = self.parse_term() - term1038 = _t1864 - _t1865 = self.parse_term() - term_31039 = _t1865 - _t1866 = self.parse_term() - term_41040 = _t1866 + _t1878 = self.parse_term() + term1046 = _t1878 + _t1879 = self.parse_term() + term_31047 = _t1879 + _t1880 = self.parse_term() + term_41048 = _t1880 self.consume_literal(")") - _t1867 = logic_pb2.RelTerm(term=term1038) - _t1868 = logic_pb2.RelTerm(term=term_31039) - _t1869 = logic_pb2.RelTerm(term=term_41040) - _t1870 = logic_pb2.Primitive(name="rel_primitive_divide_monotype", terms=[_t1867, _t1868, _t1869]) - result1042 = _t1870 - self.record_span(span_start1041, "Primitive") - return result1042 + _t1881 = logic_pb2.RelTerm(term=term1046) + _t1882 = logic_pb2.RelTerm(term=term_31047) + _t1883 = logic_pb2.RelTerm(term=term_41048) + _t1884 = logic_pb2.Primitive(name="rel_primitive_divide_monotype", terms=[_t1881, _t1882, _t1883]) + result1050 = _t1884 + self.record_span(span_start1049, "Primitive") + return result1050 def parse_rel_term(self) -> logic_pb2.RelTerm: - span_start1046 = self.span_start() + span_start1054 = self.span_start() if self.match_lookahead_literal("true", 0): - _t1871 = 1 + _t1885 = 1 else: if self.match_lookahead_literal("missing", 0): - _t1872 = 1 + _t1886 = 1 else: if self.match_lookahead_literal("false", 0): - _t1873 = 1 + _t1887 = 1 else: if self.match_lookahead_literal("(", 0): - _t1874 = 1 + _t1888 = 1 else: if self.match_lookahead_literal("#", 0): - _t1875 = 0 + _t1889 = 0 else: if self.match_lookahead_terminal("SYMBOL", 0): - _t1876 = 1 + _t1890 = 1 else: if self.match_lookahead_terminal("UINT32", 0): - _t1877 = 1 + _t1891 = 1 else: if self.match_lookahead_terminal("UINT128", 0): - _t1878 = 1 + _t1892 = 1 else: if self.match_lookahead_terminal("STRING", 0): - _t1879 = 1 + _t1893 = 1 else: if self.match_lookahead_terminal("INT32", 0): - _t1880 = 1 + _t1894 = 1 else: if self.match_lookahead_terminal("INT128", 0): - _t1881 = 1 + _t1895 = 1 else: if self.match_lookahead_terminal("INT", 0): - _t1882 = 1 + _t1896 = 1 else: if self.match_lookahead_terminal("FLOAT32", 0): - _t1883 = 1 + _t1897 = 1 else: if self.match_lookahead_terminal("FLOAT", 0): - _t1884 = 1 + _t1898 = 1 else: if self.match_lookahead_terminal("DECIMAL", 0): - _t1885 = 1 + _t1899 = 1 else: - _t1885 = -1 - _t1884 = _t1885 - _t1883 = _t1884 - _t1882 = _t1883 - _t1881 = _t1882 - _t1880 = _t1881 - _t1879 = _t1880 - _t1878 = _t1879 - _t1877 = _t1878 - _t1876 = _t1877 - _t1875 = _t1876 - _t1874 = _t1875 - _t1873 = _t1874 - _t1872 = _t1873 - _t1871 = _t1872 - prediction1043 = _t1871 - if prediction1043 == 1: - _t1887 = self.parse_term() - term1045 = _t1887 - _t1888 = logic_pb2.RelTerm(term=term1045) - _t1886 = _t1888 + _t1899 = -1 + _t1898 = _t1899 + _t1897 = _t1898 + _t1896 = _t1897 + _t1895 = _t1896 + _t1894 = _t1895 + _t1893 = _t1894 + _t1892 = _t1893 + _t1891 = _t1892 + _t1890 = _t1891 + _t1889 = _t1890 + _t1888 = _t1889 + _t1887 = _t1888 + _t1886 = _t1887 + _t1885 = _t1886 + prediction1051 = _t1885 + if prediction1051 == 1: + _t1901 = self.parse_term() + term1053 = _t1901 + _t1902 = logic_pb2.RelTerm(term=term1053) + _t1900 = _t1902 else: - if prediction1043 == 0: - _t1890 = self.parse_specialized_value() - specialized_value1044 = _t1890 - _t1891 = logic_pb2.RelTerm(specialized_value=specialized_value1044) - _t1889 = _t1891 + if prediction1051 == 0: + _t1904 = self.parse_specialized_value() + specialized_value1052 = _t1904 + _t1905 = logic_pb2.RelTerm(specialized_value=specialized_value1052) + _t1903 = _t1905 else: raise ParseError("Unexpected token in rel_term" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1886 = _t1889 - result1047 = _t1886 - self.record_span(span_start1046, "RelTerm") - return result1047 + _t1900 = _t1903 + result1055 = _t1900 + self.record_span(span_start1054, "RelTerm") + return result1055 def parse_specialized_value(self) -> logic_pb2.Value: - span_start1049 = self.span_start() + span_start1057 = self.span_start() self.consume_literal("#") - _t1892 = self.parse_raw_value() - raw_value1048 = _t1892 - result1050 = raw_value1048 - self.record_span(span_start1049, "Value") - return result1050 + _t1906 = self.parse_raw_value() + raw_value1056 = _t1906 + result1058 = raw_value1056 + self.record_span(span_start1057, "Value") + return result1058 def parse_rel_atom(self) -> logic_pb2.RelAtom: - span_start1056 = self.span_start() + span_start1064 = self.span_start() self.consume_literal("(") self.consume_literal("relatom") - _t1893 = self.parse_name() - name1051 = _t1893 - xs1052 = [] - cond1053 = ((((((((((((((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 cond1053: - _t1894 = self.parse_rel_term() - item1054 = _t1894 - xs1052.append(item1054) - cond1053 = ((((((((((((((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_terms1055 = xs1052 + _t1907 = self.parse_name() + name1059 = _t1907 + xs1060 = [] + cond1061 = ((((((((((((((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 cond1061: + _t1908 = self.parse_rel_term() + item1062 = _t1908 + xs1060.append(item1062) + cond1061 = ((((((((((((((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_terms1063 = xs1060 self.consume_literal(")") - _t1895 = logic_pb2.RelAtom(name=name1051, terms=rel_terms1055) - result1057 = _t1895 - self.record_span(span_start1056, "RelAtom") - return result1057 + _t1909 = logic_pb2.RelAtom(name=name1059, terms=rel_terms1063) + result1065 = _t1909 + self.record_span(span_start1064, "RelAtom") + return result1065 def parse_cast(self) -> logic_pb2.Cast: - span_start1060 = self.span_start() + span_start1068 = self.span_start() self.consume_literal("(") self.consume_literal("cast") - _t1896 = self.parse_term() - term1058 = _t1896 - _t1897 = self.parse_term() - term_31059 = _t1897 + _t1910 = self.parse_term() + term1066 = _t1910 + _t1911 = self.parse_term() + term_31067 = _t1911 self.consume_literal(")") - _t1898 = logic_pb2.Cast(input=term1058, result=term_31059) - result1061 = _t1898 - self.record_span(span_start1060, "Cast") - return result1061 + _t1912 = logic_pb2.Cast(input=term1066, result=term_31067) + result1069 = _t1912 + self.record_span(span_start1068, "Cast") + return result1069 def parse_attrs(self) -> Sequence[logic_pb2.Attribute]: self.consume_literal("(") self.consume_literal("attrs") - xs1062 = [] - cond1063 = self.match_lookahead_literal("(", 0) - while cond1063: - _t1899 = self.parse_attribute() - item1064 = _t1899 - xs1062.append(item1064) - cond1063 = self.match_lookahead_literal("(", 0) - attributes1065 = xs1062 + xs1070 = [] + cond1071 = self.match_lookahead_literal("(", 0) + while cond1071: + _t1913 = self.parse_attribute() + item1072 = _t1913 + xs1070.append(item1072) + cond1071 = self.match_lookahead_literal("(", 0) + attributes1073 = xs1070 self.consume_literal(")") - return attributes1065 + return attributes1073 def parse_attribute(self) -> logic_pb2.Attribute: - span_start1071 = self.span_start() + span_start1079 = self.span_start() self.consume_literal("(") self.consume_literal("attribute") - _t1900 = self.parse_name() - name1066 = _t1900 - xs1067 = [] - cond1068 = ((((((((((((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 cond1068: - _t1901 = self.parse_raw_value() - item1069 = _t1901 - xs1067.append(item1069) - cond1068 = ((((((((((((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_values1070 = xs1067 + _t1914 = self.parse_name() + name1074 = _t1914 + xs1075 = [] + cond1076 = ((((((((((((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 cond1076: + _t1915 = self.parse_raw_value() + item1077 = _t1915 + xs1075.append(item1077) + cond1076 = ((((((((((((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_values1078 = xs1075 self.consume_literal(")") - _t1902 = logic_pb2.Attribute(name=name1066, args=raw_values1070) - result1072 = _t1902 - self.record_span(span_start1071, "Attribute") - return result1072 + _t1916 = logic_pb2.Attribute(name=name1074, args=raw_values1078) + result1080 = _t1916 + self.record_span(span_start1079, "Attribute") + return result1080 def parse_algorithm(self) -> logic_pb2.Algorithm: - span_start1079 = self.span_start() + span_start1087 = self.span_start() self.consume_literal("(") self.consume_literal("algorithm") - xs1073 = [] - cond1074 = (self.match_lookahead_literal(":", 0) or self.match_lookahead_terminal("UINT128", 0)) - while cond1074: - _t1903 = self.parse_relation_id() - item1075 = _t1903 - xs1073.append(item1075) - cond1074 = (self.match_lookahead_literal(":", 0) or self.match_lookahead_terminal("UINT128", 0)) - relation_ids1076 = xs1073 - _t1904 = self.parse_script() - script1077 = _t1904 + xs1081 = [] + cond1082 = (self.match_lookahead_literal(":", 0) or self.match_lookahead_terminal("UINT128", 0)) + while cond1082: + _t1917 = self.parse_relation_id() + item1083 = _t1917 + xs1081.append(item1083) + cond1082 = (self.match_lookahead_literal(":", 0) or self.match_lookahead_terminal("UINT128", 0)) + relation_ids1084 = xs1081 + _t1918 = self.parse_script() + script1085 = _t1918 if self.match_lookahead_literal("(", 0): - _t1906 = self.parse_attrs() - _t1905 = _t1906 + _t1920 = self.parse_attrs() + _t1919 = _t1920 else: - _t1905 = None - attrs1078 = _t1905 + _t1919 = None + attrs1086 = _t1919 self.consume_literal(")") - _t1907 = logic_pb2.Algorithm(body=script1077, attrs=(attrs1078 if attrs1078 is not None else [])) - getattr(_t1907, 'global').extend(relation_ids1076) - result1080 = _t1907 - self.record_span(span_start1079, "Algorithm") - return result1080 + _t1921 = logic_pb2.Algorithm(body=script1085, attrs=(attrs1086 if attrs1086 is not None else [])) + getattr(_t1921, 'global').extend(relation_ids1084) + result1088 = _t1921 + self.record_span(span_start1087, "Algorithm") + return result1088 def parse_script(self) -> logic_pb2.Script: - span_start1085 = self.span_start() + span_start1093 = self.span_start() self.consume_literal("(") self.consume_literal("script") - xs1081 = [] - cond1082 = self.match_lookahead_literal("(", 0) - while cond1082: - _t1908 = self.parse_construct() - item1083 = _t1908 - xs1081.append(item1083) - cond1082 = self.match_lookahead_literal("(", 0) - constructs1084 = xs1081 + xs1089 = [] + cond1090 = self.match_lookahead_literal("(", 0) + while cond1090: + _t1922 = self.parse_construct() + item1091 = _t1922 + xs1089.append(item1091) + cond1090 = self.match_lookahead_literal("(", 0) + constructs1092 = xs1089 self.consume_literal(")") - _t1909 = logic_pb2.Script(constructs=constructs1084) - result1086 = _t1909 - self.record_span(span_start1085, "Script") - return result1086 + _t1923 = logic_pb2.Script(constructs=constructs1092) + result1094 = _t1923 + self.record_span(span_start1093, "Script") + return result1094 def parse_construct(self) -> logic_pb2.Construct: - span_start1090 = self.span_start() + span_start1098 = self.span_start() if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("upsert", 1): - _t1911 = 1 + _t1925 = 1 else: if self.match_lookahead_literal("monus", 1): - _t1912 = 1 + _t1926 = 1 else: if self.match_lookahead_literal("monoid", 1): - _t1913 = 1 + _t1927 = 1 else: if self.match_lookahead_literal("loop", 1): - _t1914 = 0 + _t1928 = 0 else: if self.match_lookahead_literal("break", 1): - _t1915 = 1 + _t1929 = 1 else: if self.match_lookahead_literal("assign", 1): - _t1916 = 1 + _t1930 = 1 else: - _t1916 = -1 - _t1915 = _t1916 - _t1914 = _t1915 - _t1913 = _t1914 - _t1912 = _t1913 - _t1911 = _t1912 - _t1910 = _t1911 + _t1930 = -1 + _t1929 = _t1930 + _t1928 = _t1929 + _t1927 = _t1928 + _t1926 = _t1927 + _t1925 = _t1926 + _t1924 = _t1925 else: - _t1910 = -1 - prediction1087 = _t1910 - if prediction1087 == 1: - _t1918 = self.parse_instruction() - instruction1089 = _t1918 - _t1919 = logic_pb2.Construct(instruction=instruction1089) - _t1917 = _t1919 + _t1924 = -1 + prediction1095 = _t1924 + if prediction1095 == 1: + _t1932 = self.parse_instruction() + instruction1097 = _t1932 + _t1933 = logic_pb2.Construct(instruction=instruction1097) + _t1931 = _t1933 else: - if prediction1087 == 0: - _t1921 = self.parse_loop() - loop1088 = _t1921 - _t1922 = logic_pb2.Construct(loop=loop1088) - _t1920 = _t1922 + if prediction1095 == 0: + _t1935 = self.parse_loop() + loop1096 = _t1935 + _t1936 = logic_pb2.Construct(loop=loop1096) + _t1934 = _t1936 else: raise ParseError("Unexpected token in construct" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1917 = _t1920 - result1091 = _t1917 - self.record_span(span_start1090, "Construct") - return result1091 + _t1931 = _t1934 + result1099 = _t1931 + self.record_span(span_start1098, "Construct") + return result1099 def parse_loop(self) -> logic_pb2.Loop: - span_start1095 = self.span_start() + span_start1103 = self.span_start() self.consume_literal("(") self.consume_literal("loop") - _t1923 = self.parse_init() - init1092 = _t1923 - _t1924 = self.parse_script() - script1093 = _t1924 + _t1937 = self.parse_init() + init1100 = _t1937 + _t1938 = self.parse_script() + script1101 = _t1938 if self.match_lookahead_literal("(", 0): - _t1926 = self.parse_attrs() - _t1925 = _t1926 + _t1940 = self.parse_attrs() + _t1939 = _t1940 else: - _t1925 = None - attrs1094 = _t1925 + _t1939 = None + attrs1102 = _t1939 self.consume_literal(")") - _t1927 = logic_pb2.Loop(init=init1092, body=script1093, attrs=(attrs1094 if attrs1094 is not None else [])) - result1096 = _t1927 - self.record_span(span_start1095, "Loop") - return result1096 + _t1941 = logic_pb2.Loop(init=init1100, body=script1101, attrs=(attrs1102 if attrs1102 is not None else [])) + result1104 = _t1941 + self.record_span(span_start1103, "Loop") + return result1104 def parse_init(self) -> Sequence[logic_pb2.Instruction]: self.consume_literal("(") self.consume_literal("init") - xs1097 = [] - cond1098 = self.match_lookahead_literal("(", 0) - while cond1098: - _t1928 = self.parse_instruction() - item1099 = _t1928 - xs1097.append(item1099) - cond1098 = self.match_lookahead_literal("(", 0) - instructions1100 = xs1097 + xs1105 = [] + cond1106 = self.match_lookahead_literal("(", 0) + while cond1106: + _t1942 = self.parse_instruction() + item1107 = _t1942 + xs1105.append(item1107) + cond1106 = self.match_lookahead_literal("(", 0) + instructions1108 = xs1105 self.consume_literal(")") - return instructions1100 + return instructions1108 def parse_instruction(self) -> logic_pb2.Instruction: - span_start1107 = self.span_start() + span_start1115 = self.span_start() if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("upsert", 1): - _t1930 = 1 + _t1944 = 1 else: if self.match_lookahead_literal("monus", 1): - _t1931 = 4 + _t1945 = 4 else: if self.match_lookahead_literal("monoid", 1): - _t1932 = 3 + _t1946 = 3 else: if self.match_lookahead_literal("break", 1): - _t1933 = 2 + _t1947 = 2 else: if self.match_lookahead_literal("assign", 1): - _t1934 = 0 + _t1948 = 0 else: - _t1934 = -1 - _t1933 = _t1934 - _t1932 = _t1933 - _t1931 = _t1932 - _t1930 = _t1931 - _t1929 = _t1930 + _t1948 = -1 + _t1947 = _t1948 + _t1946 = _t1947 + _t1945 = _t1946 + _t1944 = _t1945 + _t1943 = _t1944 else: - _t1929 = -1 - prediction1101 = _t1929 - if prediction1101 == 4: - _t1936 = self.parse_monus_def() - monus_def1106 = _t1936 - _t1937 = logic_pb2.Instruction(monus_def=monus_def1106) - _t1935 = _t1937 + _t1943 = -1 + prediction1109 = _t1943 + if prediction1109 == 4: + _t1950 = self.parse_monus_def() + monus_def1114 = _t1950 + _t1951 = logic_pb2.Instruction(monus_def=monus_def1114) + _t1949 = _t1951 else: - if prediction1101 == 3: - _t1939 = self.parse_monoid_def() - monoid_def1105 = _t1939 - _t1940 = logic_pb2.Instruction(monoid_def=monoid_def1105) - _t1938 = _t1940 + if prediction1109 == 3: + _t1953 = self.parse_monoid_def() + monoid_def1113 = _t1953 + _t1954 = logic_pb2.Instruction(monoid_def=monoid_def1113) + _t1952 = _t1954 else: - if prediction1101 == 2: - _t1942 = self.parse_break() - break1104 = _t1942 - _t1943 = logic_pb2.Instruction() - getattr(_t1943, 'break').CopyFrom(break1104) - _t1941 = _t1943 + if prediction1109 == 2: + _t1956 = self.parse_break() + break1112 = _t1956 + _t1957 = logic_pb2.Instruction() + getattr(_t1957, 'break').CopyFrom(break1112) + _t1955 = _t1957 else: - if prediction1101 == 1: - _t1945 = self.parse_upsert() - upsert1103 = _t1945 - _t1946 = logic_pb2.Instruction(upsert=upsert1103) - _t1944 = _t1946 + if prediction1109 == 1: + _t1959 = self.parse_upsert() + upsert1111 = _t1959 + _t1960 = logic_pb2.Instruction(upsert=upsert1111) + _t1958 = _t1960 else: - if prediction1101 == 0: - _t1948 = self.parse_assign() - assign1102 = _t1948 - _t1949 = logic_pb2.Instruction(assign=assign1102) - _t1947 = _t1949 + if prediction1109 == 0: + _t1962 = self.parse_assign() + assign1110 = _t1962 + _t1963 = logic_pb2.Instruction(assign=assign1110) + _t1961 = _t1963 else: raise ParseError("Unexpected token in instruction" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1944 = _t1947 - _t1941 = _t1944 - _t1938 = _t1941 - _t1935 = _t1938 - result1108 = _t1935 - self.record_span(span_start1107, "Instruction") - return result1108 + _t1958 = _t1961 + _t1955 = _t1958 + _t1952 = _t1955 + _t1949 = _t1952 + result1116 = _t1949 + self.record_span(span_start1115, "Instruction") + return result1116 def parse_assign(self) -> logic_pb2.Assign: - span_start1112 = self.span_start() + span_start1120 = self.span_start() self.consume_literal("(") self.consume_literal("assign") - _t1950 = self.parse_relation_id() - relation_id1109 = _t1950 - _t1951 = self.parse_abstraction() - abstraction1110 = _t1951 + _t1964 = self.parse_relation_id() + relation_id1117 = _t1964 + _t1965 = self.parse_abstraction() + abstraction1118 = _t1965 if self.match_lookahead_literal("(", 0): - _t1953 = self.parse_attrs() - _t1952 = _t1953 + _t1967 = self.parse_attrs() + _t1966 = _t1967 else: - _t1952 = None - attrs1111 = _t1952 + _t1966 = None + attrs1119 = _t1966 self.consume_literal(")") - _t1954 = logic_pb2.Assign(name=relation_id1109, body=abstraction1110, attrs=(attrs1111 if attrs1111 is not None else [])) - result1113 = _t1954 - self.record_span(span_start1112, "Assign") - return result1113 + _t1968 = logic_pb2.Assign(name=relation_id1117, body=abstraction1118, attrs=(attrs1119 if attrs1119 is not None else [])) + result1121 = _t1968 + self.record_span(span_start1120, "Assign") + return result1121 def parse_upsert(self) -> logic_pb2.Upsert: - span_start1117 = self.span_start() + span_start1125 = self.span_start() self.consume_literal("(") self.consume_literal("upsert") - _t1955 = self.parse_relation_id() - relation_id1114 = _t1955 - _t1956 = self.parse_abstraction_with_arity() - abstraction_with_arity1115 = _t1956 + _t1969 = self.parse_relation_id() + relation_id1122 = _t1969 + _t1970 = self.parse_abstraction_with_arity() + abstraction_with_arity1123 = _t1970 if self.match_lookahead_literal("(", 0): - _t1958 = self.parse_attrs() - _t1957 = _t1958 + _t1972 = self.parse_attrs() + _t1971 = _t1972 else: - _t1957 = None - attrs1116 = _t1957 + _t1971 = None + attrs1124 = _t1971 self.consume_literal(")") - _t1959 = logic_pb2.Upsert(name=relation_id1114, body=abstraction_with_arity1115[0], attrs=(attrs1116 if attrs1116 is not None else []), value_arity=abstraction_with_arity1115[1]) - result1118 = _t1959 - self.record_span(span_start1117, "Upsert") - return result1118 + _t1973 = logic_pb2.Upsert(name=relation_id1122, body=abstraction_with_arity1123[0], attrs=(attrs1124 if attrs1124 is not None else []), value_arity=abstraction_with_arity1123[1]) + result1126 = _t1973 + self.record_span(span_start1125, "Upsert") + return result1126 def parse_abstraction_with_arity(self) -> tuple[logic_pb2.Abstraction, int]: self.consume_literal("(") - _t1960 = self.parse_bindings() - bindings1119 = _t1960 - _t1961 = self.parse_formula() - formula1120 = _t1961 + _t1974 = self.parse_bindings() + bindings1127 = _t1974 + _t1975 = self.parse_formula() + formula1128 = _t1975 self.consume_literal(")") - _t1962 = logic_pb2.Abstraction(vars=(list(bindings1119[0]) + list(bindings1119[1] if bindings1119[1] is not None else [])), value=formula1120) - return (_t1962, len(bindings1119[1]),) + _t1976 = logic_pb2.Abstraction(vars=(list(bindings1127[0]) + list(bindings1127[1] if bindings1127[1] is not None else [])), value=formula1128) + return (_t1976, len(bindings1127[1]),) def parse_break(self) -> logic_pb2.Break: - span_start1124 = self.span_start() + span_start1132 = self.span_start() self.consume_literal("(") self.consume_literal("break") - _t1963 = self.parse_relation_id() - relation_id1121 = _t1963 - _t1964 = self.parse_abstraction() - abstraction1122 = _t1964 + _t1977 = self.parse_relation_id() + relation_id1129 = _t1977 + _t1978 = self.parse_abstraction() + abstraction1130 = _t1978 if self.match_lookahead_literal("(", 0): - _t1966 = self.parse_attrs() - _t1965 = _t1966 + _t1980 = self.parse_attrs() + _t1979 = _t1980 else: - _t1965 = None - attrs1123 = _t1965 + _t1979 = None + attrs1131 = _t1979 self.consume_literal(")") - _t1967 = logic_pb2.Break(name=relation_id1121, body=abstraction1122, attrs=(attrs1123 if attrs1123 is not None else [])) - result1125 = _t1967 - self.record_span(span_start1124, "Break") - return result1125 + _t1981 = logic_pb2.Break(name=relation_id1129, body=abstraction1130, attrs=(attrs1131 if attrs1131 is not None else [])) + result1133 = _t1981 + self.record_span(span_start1132, "Break") + return result1133 def parse_monoid_def(self) -> logic_pb2.MonoidDef: - span_start1130 = self.span_start() + span_start1138 = self.span_start() self.consume_literal("(") self.consume_literal("monoid") - _t1968 = self.parse_monoid() - monoid1126 = _t1968 - _t1969 = self.parse_relation_id() - relation_id1127 = _t1969 - _t1970 = self.parse_abstraction_with_arity() - abstraction_with_arity1128 = _t1970 + _t1982 = self.parse_monoid() + monoid1134 = _t1982 + _t1983 = self.parse_relation_id() + relation_id1135 = _t1983 + _t1984 = self.parse_abstraction_with_arity() + abstraction_with_arity1136 = _t1984 if self.match_lookahead_literal("(", 0): - _t1972 = self.parse_attrs() - _t1971 = _t1972 + _t1986 = self.parse_attrs() + _t1985 = _t1986 else: - _t1971 = None - attrs1129 = _t1971 + _t1985 = None + attrs1137 = _t1985 self.consume_literal(")") - _t1973 = logic_pb2.MonoidDef(monoid=monoid1126, name=relation_id1127, body=abstraction_with_arity1128[0], attrs=(attrs1129 if attrs1129 is not None else []), value_arity=abstraction_with_arity1128[1]) - result1131 = _t1973 - self.record_span(span_start1130, "MonoidDef") - return result1131 + _t1987 = logic_pb2.MonoidDef(monoid=monoid1134, name=relation_id1135, body=abstraction_with_arity1136[0], attrs=(attrs1137 if attrs1137 is not None else []), value_arity=abstraction_with_arity1136[1]) + result1139 = _t1987 + self.record_span(span_start1138, "MonoidDef") + return result1139 def parse_monoid(self) -> logic_pb2.Monoid: - span_start1137 = self.span_start() + span_start1145 = self.span_start() if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("sum", 1): - _t1975 = 3 + _t1989 = 3 else: if self.match_lookahead_literal("or", 1): - _t1976 = 0 + _t1990 = 0 else: if self.match_lookahead_literal("min", 1): - _t1977 = 1 + _t1991 = 1 else: if self.match_lookahead_literal("max", 1): - _t1978 = 2 + _t1992 = 2 else: - _t1978 = -1 - _t1977 = _t1978 - _t1976 = _t1977 - _t1975 = _t1976 - _t1974 = _t1975 + _t1992 = -1 + _t1991 = _t1992 + _t1990 = _t1991 + _t1989 = _t1990 + _t1988 = _t1989 else: - _t1974 = -1 - prediction1132 = _t1974 - if prediction1132 == 3: - _t1980 = self.parse_sum_monoid() - sum_monoid1136 = _t1980 - _t1981 = logic_pb2.Monoid(sum_monoid=sum_monoid1136) - _t1979 = _t1981 + _t1988 = -1 + prediction1140 = _t1988 + if prediction1140 == 3: + _t1994 = self.parse_sum_monoid() + sum_monoid1144 = _t1994 + _t1995 = logic_pb2.Monoid(sum_monoid=sum_monoid1144) + _t1993 = _t1995 else: - if prediction1132 == 2: - _t1983 = self.parse_max_monoid() - max_monoid1135 = _t1983 - _t1984 = logic_pb2.Monoid(max_monoid=max_monoid1135) - _t1982 = _t1984 + if prediction1140 == 2: + _t1997 = self.parse_max_monoid() + max_monoid1143 = _t1997 + _t1998 = logic_pb2.Monoid(max_monoid=max_monoid1143) + _t1996 = _t1998 else: - if prediction1132 == 1: - _t1986 = self.parse_min_monoid() - min_monoid1134 = _t1986 - _t1987 = logic_pb2.Monoid(min_monoid=min_monoid1134) - _t1985 = _t1987 + if prediction1140 == 1: + _t2000 = self.parse_min_monoid() + min_monoid1142 = _t2000 + _t2001 = logic_pb2.Monoid(min_monoid=min_monoid1142) + _t1999 = _t2001 else: - if prediction1132 == 0: - _t1989 = self.parse_or_monoid() - or_monoid1133 = _t1989 - _t1990 = logic_pb2.Monoid(or_monoid=or_monoid1133) - _t1988 = _t1990 + if prediction1140 == 0: + _t2003 = self.parse_or_monoid() + or_monoid1141 = _t2003 + _t2004 = logic_pb2.Monoid(or_monoid=or_monoid1141) + _t2002 = _t2004 else: raise ParseError("Unexpected token in monoid" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1985 = _t1988 - _t1982 = _t1985 - _t1979 = _t1982 - result1138 = _t1979 - self.record_span(span_start1137, "Monoid") - return result1138 + _t1999 = _t2002 + _t1996 = _t1999 + _t1993 = _t1996 + result1146 = _t1993 + self.record_span(span_start1145, "Monoid") + return result1146 def parse_or_monoid(self) -> logic_pb2.OrMonoid: - span_start1139 = self.span_start() + span_start1147 = self.span_start() self.consume_literal("(") self.consume_literal("or") self.consume_literal(")") - _t1991 = logic_pb2.OrMonoid() - result1140 = _t1991 - self.record_span(span_start1139, "OrMonoid") - return result1140 + _t2005 = logic_pb2.OrMonoid() + result1148 = _t2005 + self.record_span(span_start1147, "OrMonoid") + return result1148 def parse_min_monoid(self) -> logic_pb2.MinMonoid: - span_start1142 = self.span_start() + span_start1150 = self.span_start() self.consume_literal("(") self.consume_literal("min") - _t1992 = self.parse_type() - type1141 = _t1992 + _t2006 = self.parse_type() + type1149 = _t2006 self.consume_literal(")") - _t1993 = logic_pb2.MinMonoid(type=type1141) - result1143 = _t1993 - self.record_span(span_start1142, "MinMonoid") - return result1143 + _t2007 = logic_pb2.MinMonoid(type=type1149) + result1151 = _t2007 + self.record_span(span_start1150, "MinMonoid") + return result1151 def parse_max_monoid(self) -> logic_pb2.MaxMonoid: - span_start1145 = self.span_start() + span_start1153 = self.span_start() self.consume_literal("(") self.consume_literal("max") - _t1994 = self.parse_type() - type1144 = _t1994 + _t2008 = self.parse_type() + type1152 = _t2008 self.consume_literal(")") - _t1995 = logic_pb2.MaxMonoid(type=type1144) - result1146 = _t1995 - self.record_span(span_start1145, "MaxMonoid") - return result1146 + _t2009 = logic_pb2.MaxMonoid(type=type1152) + result1154 = _t2009 + self.record_span(span_start1153, "MaxMonoid") + return result1154 def parse_sum_monoid(self) -> logic_pb2.SumMonoid: - span_start1148 = self.span_start() + span_start1156 = self.span_start() self.consume_literal("(") self.consume_literal("sum") - _t1996 = self.parse_type() - type1147 = _t1996 + _t2010 = self.parse_type() + type1155 = _t2010 self.consume_literal(")") - _t1997 = logic_pb2.SumMonoid(type=type1147) - result1149 = _t1997 - self.record_span(span_start1148, "SumMonoid") - return result1149 + _t2011 = logic_pb2.SumMonoid(type=type1155) + result1157 = _t2011 + self.record_span(span_start1156, "SumMonoid") + return result1157 def parse_monus_def(self) -> logic_pb2.MonusDef: - span_start1154 = self.span_start() + span_start1162 = self.span_start() self.consume_literal("(") self.consume_literal("monus") - _t1998 = self.parse_monoid() - monoid1150 = _t1998 - _t1999 = self.parse_relation_id() - relation_id1151 = _t1999 - _t2000 = self.parse_abstraction_with_arity() - abstraction_with_arity1152 = _t2000 + _t2012 = self.parse_monoid() + monoid1158 = _t2012 + _t2013 = self.parse_relation_id() + relation_id1159 = _t2013 + _t2014 = self.parse_abstraction_with_arity() + abstraction_with_arity1160 = _t2014 if self.match_lookahead_literal("(", 0): - _t2002 = self.parse_attrs() - _t2001 = _t2002 + _t2016 = self.parse_attrs() + _t2015 = _t2016 else: - _t2001 = None - attrs1153 = _t2001 + _t2015 = None + attrs1161 = _t2015 self.consume_literal(")") - _t2003 = logic_pb2.MonusDef(monoid=monoid1150, name=relation_id1151, body=abstraction_with_arity1152[0], attrs=(attrs1153 if attrs1153 is not None else []), value_arity=abstraction_with_arity1152[1]) - result1155 = _t2003 - self.record_span(span_start1154, "MonusDef") - return result1155 + _t2017 = logic_pb2.MonusDef(monoid=monoid1158, name=relation_id1159, body=abstraction_with_arity1160[0], attrs=(attrs1161 if attrs1161 is not None else []), value_arity=abstraction_with_arity1160[1]) + result1163 = _t2017 + self.record_span(span_start1162, "MonusDef") + return result1163 def parse_constraint(self) -> logic_pb2.Constraint: - span_start1160 = self.span_start() + span_start1168 = self.span_start() self.consume_literal("(") self.consume_literal("functional_dependency") - _t2004 = self.parse_relation_id() - relation_id1156 = _t2004 - _t2005 = self.parse_abstraction() - abstraction1157 = _t2005 - _t2006 = self.parse_functional_dependency_keys() - functional_dependency_keys1158 = _t2006 - _t2007 = self.parse_functional_dependency_values() - functional_dependency_values1159 = _t2007 + _t2018 = self.parse_relation_id() + relation_id1164 = _t2018 + _t2019 = self.parse_abstraction() + abstraction1165 = _t2019 + _t2020 = self.parse_functional_dependency_keys() + functional_dependency_keys1166 = _t2020 + _t2021 = self.parse_functional_dependency_values() + functional_dependency_values1167 = _t2021 self.consume_literal(")") - _t2008 = logic_pb2.FunctionalDependency(guard=abstraction1157, keys=functional_dependency_keys1158, values=functional_dependency_values1159) - _t2009 = logic_pb2.Constraint(name=relation_id1156, functional_dependency=_t2008) - result1161 = _t2009 - self.record_span(span_start1160, "Constraint") - return result1161 + _t2022 = logic_pb2.FunctionalDependency(guard=abstraction1165, keys=functional_dependency_keys1166, values=functional_dependency_values1167) + _t2023 = logic_pb2.Constraint(name=relation_id1164, functional_dependency=_t2022) + result1169 = _t2023 + self.record_span(span_start1168, "Constraint") + return result1169 def parse_functional_dependency_keys(self) -> Sequence[logic_pb2.Var]: self.consume_literal("(") self.consume_literal("keys") - xs1162 = [] - cond1163 = self.match_lookahead_terminal("SYMBOL", 0) - while cond1163: - _t2010 = self.parse_var() - item1164 = _t2010 - xs1162.append(item1164) - cond1163 = self.match_lookahead_terminal("SYMBOL", 0) - vars1165 = xs1162 + xs1170 = [] + cond1171 = self.match_lookahead_terminal("SYMBOL", 0) + while cond1171: + _t2024 = self.parse_var() + item1172 = _t2024 + xs1170.append(item1172) + cond1171 = self.match_lookahead_terminal("SYMBOL", 0) + vars1173 = xs1170 self.consume_literal(")") - return vars1165 + return vars1173 def parse_functional_dependency_values(self) -> Sequence[logic_pb2.Var]: self.consume_literal("(") self.consume_literal("values") - xs1166 = [] - cond1167 = self.match_lookahead_terminal("SYMBOL", 0) - while cond1167: - _t2011 = self.parse_var() - item1168 = _t2011 - xs1166.append(item1168) - cond1167 = self.match_lookahead_terminal("SYMBOL", 0) - vars1169 = xs1166 + xs1174 = [] + cond1175 = self.match_lookahead_terminal("SYMBOL", 0) + while cond1175: + _t2025 = self.parse_var() + item1176 = _t2025 + xs1174.append(item1176) + cond1175 = self.match_lookahead_terminal("SYMBOL", 0) + vars1177 = xs1174 self.consume_literal(")") - return vars1169 + return vars1177 def parse_data(self) -> logic_pb2.Data: - span_start1175 = self.span_start() + span_start1183 = self.span_start() if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("iceberg_data", 1): - _t2013 = 3 + _t2027 = 3 else: if self.match_lookahead_literal("edb", 1): - _t2014 = 0 + _t2028 = 0 else: if self.match_lookahead_literal("csv_data", 1): - _t2015 = 2 + _t2029 = 2 else: if self.match_lookahead_literal("betree_relation", 1): - _t2016 = 1 + _t2030 = 1 else: - _t2016 = -1 - _t2015 = _t2016 - _t2014 = _t2015 - _t2013 = _t2014 - _t2012 = _t2013 + _t2030 = -1 + _t2029 = _t2030 + _t2028 = _t2029 + _t2027 = _t2028 + _t2026 = _t2027 else: - _t2012 = -1 - prediction1170 = _t2012 - if prediction1170 == 3: - _t2018 = self.parse_iceberg_data() - iceberg_data1174 = _t2018 - _t2019 = logic_pb2.Data(iceberg_data=iceberg_data1174) - _t2017 = _t2019 + _t2026 = -1 + prediction1178 = _t2026 + if prediction1178 == 3: + _t2032 = self.parse_iceberg_data() + iceberg_data1182 = _t2032 + _t2033 = logic_pb2.Data(iceberg_data=iceberg_data1182) + _t2031 = _t2033 else: - if prediction1170 == 2: - _t2021 = self.parse_csv_data() - csv_data1173 = _t2021 - _t2022 = logic_pb2.Data(csv_data=csv_data1173) - _t2020 = _t2022 + if prediction1178 == 2: + _t2035 = self.parse_csv_data() + csv_data1181 = _t2035 + _t2036 = logic_pb2.Data(csv_data=csv_data1181) + _t2034 = _t2036 else: - if prediction1170 == 1: - _t2024 = self.parse_betree_relation() - betree_relation1172 = _t2024 - _t2025 = logic_pb2.Data(betree_relation=betree_relation1172) - _t2023 = _t2025 + if prediction1178 == 1: + _t2038 = self.parse_betree_relation() + betree_relation1180 = _t2038 + _t2039 = logic_pb2.Data(betree_relation=betree_relation1180) + _t2037 = _t2039 else: - if prediction1170 == 0: - _t2027 = self.parse_edb() - edb1171 = _t2027 - _t2028 = logic_pb2.Data(edb=edb1171) - _t2026 = _t2028 + if prediction1178 == 0: + _t2041 = self.parse_edb() + edb1179 = _t2041 + _t2042 = logic_pb2.Data(edb=edb1179) + _t2040 = _t2042 else: raise ParseError("Unexpected token in data" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t2023 = _t2026 - _t2020 = _t2023 - _t2017 = _t2020 - result1176 = _t2017 - self.record_span(span_start1175, "Data") - return result1176 + _t2037 = _t2040 + _t2034 = _t2037 + _t2031 = _t2034 + result1184 = _t2031 + self.record_span(span_start1183, "Data") + return result1184 def parse_edb(self) -> logic_pb2.EDB: - span_start1180 = self.span_start() + span_start1188 = self.span_start() self.consume_literal("(") self.consume_literal("edb") - _t2029 = self.parse_relation_id() - relation_id1177 = _t2029 - _t2030 = self.parse_edb_path() - edb_path1178 = _t2030 - _t2031 = self.parse_edb_types() - edb_types1179 = _t2031 + _t2043 = self.parse_relation_id() + relation_id1185 = _t2043 + _t2044 = self.parse_edb_path() + edb_path1186 = _t2044 + _t2045 = self.parse_edb_types() + edb_types1187 = _t2045 self.consume_literal(")") - _t2032 = logic_pb2.EDB(target_id=relation_id1177, path=edb_path1178, types=edb_types1179) - result1181 = _t2032 - self.record_span(span_start1180, "EDB") - return result1181 + _t2046 = logic_pb2.EDB(target_id=relation_id1185, path=edb_path1186, types=edb_types1187) + result1189 = _t2046 + self.record_span(span_start1188, "EDB") + return result1189 def parse_edb_path(self) -> Sequence[str]: self.consume_literal("[") - xs1182 = [] - cond1183 = self.match_lookahead_terminal("STRING", 0) - while cond1183: - item1184 = self.consume_terminal("STRING") - xs1182.append(item1184) - cond1183 = self.match_lookahead_terminal("STRING", 0) - strings1185 = xs1182 + xs1190 = [] + cond1191 = self.match_lookahead_terminal("STRING", 0) + while cond1191: + item1192 = self.consume_terminal("STRING") + xs1190.append(item1192) + cond1191 = self.match_lookahead_terminal("STRING", 0) + strings1193 = xs1190 self.consume_literal("]") - return strings1185 + return strings1193 def parse_edb_types(self) -> Sequence[logic_pb2.Type]: self.consume_literal("[") - xs1186 = [] - cond1187 = (((((((((((((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 cond1187: - _t2033 = self.parse_type() - item1188 = _t2033 - xs1186.append(item1188) - cond1187 = (((((((((((((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)) - types1189 = xs1186 + xs1194 = [] + cond1195 = (((((((((((((self.match_lookahead_literal("(", 0) or self.match_lookahead_literal("BOOLEAN", 0)) or self.match_lookahead_literal("DATE", 0)) or self.match_lookahead_literal("DATETIME", 0)) or self.match_lookahead_literal("FLOAT", 0)) or self.match_lookahead_literal("FLOAT32", 0)) or self.match_lookahead_literal("INT", 0)) or self.match_lookahead_literal("INT128", 0)) or self.match_lookahead_literal("INT32", 0)) or self.match_lookahead_literal("MISSING", 0)) or self.match_lookahead_literal("STRING", 0)) or self.match_lookahead_literal("UINT128", 0)) or self.match_lookahead_literal("UINT32", 0)) or self.match_lookahead_literal("UNKNOWN", 0)) + while cond1195: + _t2047 = self.parse_type() + item1196 = _t2047 + xs1194.append(item1196) + cond1195 = (((((((((((((self.match_lookahead_literal("(", 0) or self.match_lookahead_literal("BOOLEAN", 0)) or self.match_lookahead_literal("DATE", 0)) or self.match_lookahead_literal("DATETIME", 0)) or self.match_lookahead_literal("FLOAT", 0)) or self.match_lookahead_literal("FLOAT32", 0)) or self.match_lookahead_literal("INT", 0)) or self.match_lookahead_literal("INT128", 0)) or self.match_lookahead_literal("INT32", 0)) or self.match_lookahead_literal("MISSING", 0)) or self.match_lookahead_literal("STRING", 0)) or self.match_lookahead_literal("UINT128", 0)) or self.match_lookahead_literal("UINT32", 0)) or self.match_lookahead_literal("UNKNOWN", 0)) + types1197 = xs1194 self.consume_literal("]") - return types1189 + return types1197 def parse_betree_relation(self) -> logic_pb2.BeTreeRelation: - span_start1192 = self.span_start() + span_start1200 = self.span_start() self.consume_literal("(") self.consume_literal("betree_relation") - _t2034 = self.parse_relation_id() - relation_id1190 = _t2034 - _t2035 = self.parse_betree_info() - betree_info1191 = _t2035 + _t2048 = self.parse_relation_id() + relation_id1198 = _t2048 + _t2049 = self.parse_betree_info() + betree_info1199 = _t2049 self.consume_literal(")") - _t2036 = logic_pb2.BeTreeRelation(name=relation_id1190, relation_info=betree_info1191) - result1193 = _t2036 - self.record_span(span_start1192, "BeTreeRelation") - return result1193 + _t2050 = logic_pb2.BeTreeRelation(name=relation_id1198, relation_info=betree_info1199) + result1201 = _t2050 + self.record_span(span_start1200, "BeTreeRelation") + return result1201 def parse_betree_info(self) -> logic_pb2.BeTreeInfo: - span_start1197 = self.span_start() + span_start1205 = self.span_start() self.consume_literal("(") self.consume_literal("betree_info") - _t2037 = self.parse_betree_info_key_types() - betree_info_key_types1194 = _t2037 - _t2038 = self.parse_betree_info_value_types() - betree_info_value_types1195 = _t2038 - _t2039 = self.parse_config_dict() - config_dict1196 = _t2039 + _t2051 = self.parse_betree_info_key_types() + betree_info_key_types1202 = _t2051 + _t2052 = self.parse_betree_info_value_types() + betree_info_value_types1203 = _t2052 + _t2053 = self.parse_config_dict() + config_dict1204 = _t2053 self.consume_literal(")") - _t2040 = self.construct_betree_info(betree_info_key_types1194, betree_info_value_types1195, config_dict1196) - result1198 = _t2040 - self.record_span(span_start1197, "BeTreeInfo") - return result1198 + _t2054 = self.construct_betree_info(betree_info_key_types1202, betree_info_value_types1203, config_dict1204) + result1206 = _t2054 + self.record_span(span_start1205, "BeTreeInfo") + return result1206 def parse_betree_info_key_types(self) -> Sequence[logic_pb2.Type]: self.consume_literal("(") self.consume_literal("key_types") - xs1199 = [] - cond1200 = (((((((((((((self.match_lookahead_literal("(", 0) or self.match_lookahead_literal("BOOLEAN", 0)) or self.match_lookahead_literal("DATE", 0)) or self.match_lookahead_literal("DATETIME", 0)) or self.match_lookahead_literal("FLOAT", 0)) or self.match_lookahead_literal("FLOAT32", 0)) or self.match_lookahead_literal("INT", 0)) or self.match_lookahead_literal("INT128", 0)) or self.match_lookahead_literal("INT32", 0)) or self.match_lookahead_literal("MISSING", 0)) or self.match_lookahead_literal("STRING", 0)) or self.match_lookahead_literal("UINT128", 0)) or self.match_lookahead_literal("UINT32", 0)) or self.match_lookahead_literal("UNKNOWN", 0)) - while cond1200: - _t2041 = self.parse_type() - item1201 = _t2041 - xs1199.append(item1201) - cond1200 = (((((((((((((self.match_lookahead_literal("(", 0) or self.match_lookahead_literal("BOOLEAN", 0)) or self.match_lookahead_literal("DATE", 0)) or self.match_lookahead_literal("DATETIME", 0)) or self.match_lookahead_literal("FLOAT", 0)) or self.match_lookahead_literal("FLOAT32", 0)) or self.match_lookahead_literal("INT", 0)) or self.match_lookahead_literal("INT128", 0)) or self.match_lookahead_literal("INT32", 0)) or self.match_lookahead_literal("MISSING", 0)) or self.match_lookahead_literal("STRING", 0)) or self.match_lookahead_literal("UINT128", 0)) or self.match_lookahead_literal("UINT32", 0)) or self.match_lookahead_literal("UNKNOWN", 0)) - types1202 = xs1199 + xs1207 = [] + cond1208 = (((((((((((((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 cond1208: + _t2055 = self.parse_type() + item1209 = _t2055 + xs1207.append(item1209) + cond1208 = (((((((((((((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)) + types1210 = xs1207 self.consume_literal(")") - return types1202 + return types1210 def parse_betree_info_value_types(self) -> Sequence[logic_pb2.Type]: self.consume_literal("(") self.consume_literal("value_types") - xs1203 = [] - cond1204 = (((((((((((((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 cond1204: - _t2042 = self.parse_type() - item1205 = _t2042 - xs1203.append(item1205) - cond1204 = (((((((((((((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)) - types1206 = xs1203 + xs1211 = [] + cond1212 = (((((((((((((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 cond1212: + _t2056 = self.parse_type() + item1213 = _t2056 + xs1211.append(item1213) + cond1212 = (((((((((((((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)) + types1214 = xs1211 self.consume_literal(")") - return types1206 + return types1214 def parse_csv_data(self) -> logic_pb2.CSVData: - span_start1212 = self.span_start() + span_start1220 = self.span_start() self.consume_literal("(") self.consume_literal("csv_data") - _t2043 = self.parse_csvlocator() - csvlocator1207 = _t2043 - _t2044 = self.parse_csv_config() - csv_config1208 = _t2044 + _t2057 = self.parse_csvlocator() + csvlocator1215 = _t2057 + _t2058 = self.parse_csv_config() + csv_config1216 = _t2058 if (self.match_lookahead_literal("(", 0) and self.match_lookahead_literal("columns", 1)): - _t2046 = self.parse_gnf_columns() - _t2045 = _t2046 + _t2060 = self.parse_gnf_columns() + _t2059 = _t2060 else: - _t2045 = None - gnf_columns1209 = _t2045 + _t2059 = None + gnf_columns1217 = _t2059 if (self.match_lookahead_literal("(", 0) and self.match_lookahead_literal("relations", 1)): - _t2048 = self.parse_target_relations() - _t2047 = _t2048 + _t2062 = self.parse_target_relations() + _t2061 = _t2062 else: - _t2047 = None - target_relations1210 = _t2047 - _t2049 = self.parse_csv_asof() - csv_asof1211 = _t2049 + _t2061 = None + target_relations1218 = _t2061 + _t2063 = self.parse_csv_asof() + csv_asof1219 = _t2063 self.consume_literal(")") - _t2050 = self.construct_csv_data(csvlocator1207, csv_config1208, gnf_columns1209, target_relations1210, csv_asof1211) - result1213 = _t2050 - self.record_span(span_start1212, "CSVData") - return result1213 + _t2064 = self.construct_csv_data(csvlocator1215, csv_config1216, gnf_columns1217, target_relations1218, csv_asof1219) + result1221 = _t2064 + self.record_span(span_start1220, "CSVData") + return result1221 def parse_csvlocator(self) -> logic_pb2.CSVLocator: - span_start1216 = self.span_start() + span_start1224 = self.span_start() self.consume_literal("(") self.consume_literal("csv_locator") if (self.match_lookahead_literal("(", 0) and self.match_lookahead_literal("paths", 1)): - _t2052 = self.parse_csv_locator_paths() - _t2051 = _t2052 + _t2066 = self.parse_csv_locator_paths() + _t2065 = _t2066 else: - _t2051 = None - csv_locator_paths1214 = _t2051 + _t2065 = None + csv_locator_paths1222 = _t2065 if self.match_lookahead_literal("(", 0): - _t2054 = self.parse_csv_locator_inline_data() - _t2053 = _t2054 + _t2068 = self.parse_csv_locator_inline_data() + _t2067 = _t2068 else: - _t2053 = None - csv_locator_inline_data1215 = _t2053 + _t2067 = None + csv_locator_inline_data1223 = _t2067 self.consume_literal(")") - _t2055 = logic_pb2.CSVLocator(paths=(csv_locator_paths1214 if csv_locator_paths1214 is not None else []), inline_data=(csv_locator_inline_data1215 if csv_locator_inline_data1215 is not None else "").encode()) - result1217 = _t2055 - self.record_span(span_start1216, "CSVLocator") - return result1217 + _t2069 = logic_pb2.CSVLocator(paths=(csv_locator_paths1222 if csv_locator_paths1222 is not None else []), inline_data=(csv_locator_inline_data1223 if csv_locator_inline_data1223 is not None else "").encode()) + result1225 = _t2069 + self.record_span(span_start1224, "CSVLocator") + return result1225 def parse_csv_locator_paths(self) -> Sequence[str]: self.consume_literal("(") self.consume_literal("paths") - xs1218 = [] - cond1219 = self.match_lookahead_terminal("STRING", 0) - while cond1219: - item1220 = self.consume_terminal("STRING") - xs1218.append(item1220) - cond1219 = self.match_lookahead_terminal("STRING", 0) - strings1221 = xs1218 + xs1226 = [] + cond1227 = self.match_lookahead_terminal("STRING", 0) + while cond1227: + item1228 = self.consume_terminal("STRING") + xs1226.append(item1228) + cond1227 = self.match_lookahead_terminal("STRING", 0) + strings1229 = xs1226 self.consume_literal(")") - return strings1221 + return strings1229 def parse_csv_locator_inline_data(self) -> str: self.consume_literal("(") self.consume_literal("inline_data") - formatted_string1222 = self.consume_terminal("STRING") + formatted_string1230 = self.consume_terminal("STRING") self.consume_literal(")") - return formatted_string1222 + return formatted_string1230 def parse_csv_config(self) -> logic_pb2.CSVConfig: - span_start1225 = self.span_start() + span_start1233 = self.span_start() self.consume_literal("(") self.consume_literal("csv_config") - _t2056 = self.parse_config_dict() - config_dict1223 = _t2056 + _t2070 = self.parse_config_dict() + config_dict1231 = _t2070 if self.match_lookahead_literal("(", 0): - _t2058 = self.parse__storage_integration() - _t2057 = _t2058 + _t2072 = self.parse__storage_integration() + _t2071 = _t2072 else: - _t2057 = None - _storage_integration1224 = _t2057 + _t2071 = None + _storage_integration1232 = _t2071 self.consume_literal(")") - _t2059 = self.construct_csv_config(config_dict1223, _storage_integration1224) - result1226 = _t2059 - self.record_span(span_start1225, "CSVConfig") - return result1226 + _t2073 = self.construct_csv_config(config_dict1231, _storage_integration1232) + result1234 = _t2073 + self.record_span(span_start1233, "CSVConfig") + return result1234 def parse__storage_integration(self) -> Sequence[tuple[str, logic_pb2.Value]]: self.consume_literal("(") self.consume_literal("storage_integration") - _t2060 = self.parse_config_dict() - config_dict1227 = _t2060 + _t2074 = self.parse_config_dict() + config_dict1235 = _t2074 self.consume_literal(")") - return config_dict1227 + return config_dict1235 def parse_gnf_columns(self) -> Sequence[logic_pb2.GNFColumn]: self.consume_literal("(") self.consume_literal("columns") - xs1228 = [] - cond1229 = self.match_lookahead_literal("(", 0) - while cond1229: - _t2061 = self.parse_gnf_column() - item1230 = _t2061 - xs1228.append(item1230) - cond1229 = self.match_lookahead_literal("(", 0) - gnf_columns1231 = xs1228 + xs1236 = [] + cond1237 = self.match_lookahead_literal("(", 0) + while cond1237: + _t2075 = self.parse_gnf_column() + item1238 = _t2075 + xs1236.append(item1238) + cond1237 = self.match_lookahead_literal("(", 0) + gnf_columns1239 = xs1236 self.consume_literal(")") - return gnf_columns1231 + return gnf_columns1239 def parse_gnf_column(self) -> logic_pb2.GNFColumn: - span_start1238 = self.span_start() + span_start1246 = self.span_start() self.consume_literal("(") self.consume_literal("column") - _t2062 = self.parse_gnf_column_path() - gnf_column_path1232 = _t2062 + _t2076 = self.parse_gnf_column_path() + gnf_column_path1240 = _t2076 if (self.match_lookahead_literal(":", 0) or self.match_lookahead_terminal("UINT128", 0)): - _t2064 = self.parse_relation_id() - _t2063 = _t2064 + _t2078 = self.parse_relation_id() + _t2077 = _t2078 else: - _t2063 = None - relation_id1233 = _t2063 + _t2077 = None + relation_id1241 = _t2077 self.consume_literal("[") - xs1234 = [] - cond1235 = (((((((((((((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 cond1235: - _t2065 = self.parse_type() - item1236 = _t2065 - xs1234.append(item1236) - cond1235 = (((((((((((((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)) - types1237 = xs1234 + xs1242 = [] + cond1243 = (((((((((((((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 cond1243: + _t2079 = self.parse_type() + item1244 = _t2079 + xs1242.append(item1244) + cond1243 = (((((((((((((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)) + types1245 = xs1242 self.consume_literal("]") self.consume_literal(")") - _t2066 = logic_pb2.GNFColumn(column_path=gnf_column_path1232, target_id=relation_id1233, types=types1237) - result1239 = _t2066 - self.record_span(span_start1238, "GNFColumn") - return result1239 + _t2080 = logic_pb2.GNFColumn(column_path=gnf_column_path1240, target_id=relation_id1241, types=types1245) + result1247 = _t2080 + self.record_span(span_start1246, "GNFColumn") + return result1247 def parse_gnf_column_path(self) -> Sequence[str]: if self.match_lookahead_literal("[", 0): - _t2067 = 1 + _t2081 = 1 else: if self.match_lookahead_terminal("STRING", 0): - _t2068 = 0 + _t2082 = 0 else: - _t2068 = -1 - _t2067 = _t2068 - prediction1240 = _t2067 - if prediction1240 == 1: + _t2082 = -1 + _t2081 = _t2082 + prediction1248 = _t2081 + if prediction1248 == 1: self.consume_literal("[") - xs1242 = [] - cond1243 = self.match_lookahead_terminal("STRING", 0) - while cond1243: - item1244 = self.consume_terminal("STRING") - xs1242.append(item1244) - cond1243 = self.match_lookahead_terminal("STRING", 0) - strings1245 = xs1242 + xs1250 = [] + cond1251 = self.match_lookahead_terminal("STRING", 0) + while cond1251: + item1252 = self.consume_terminal("STRING") + xs1250.append(item1252) + cond1251 = self.match_lookahead_terminal("STRING", 0) + strings1253 = xs1250 self.consume_literal("]") - _t2069 = strings1245 + _t2083 = strings1253 else: - if prediction1240 == 0: - string1241 = self.consume_terminal("STRING") - _t2070 = [string1241] + if prediction1248 == 0: + string1249 = self.consume_terminal("STRING") + _t2084 = [string1249] else: raise ParseError("Unexpected token in gnf_column_path" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t2069 = _t2070 - return _t2069 + _t2083 = _t2084 + return _t2083 def parse_target_relations(self) -> logic_pb2.TargetRelations: - span_start1249 = self.span_start() + span_start1257 = self.span_start() self.consume_literal("(") self.consume_literal("relations") - _t2071 = self.parse_relation_keys() - relation_keys1246 = _t2071 - _t2072 = self.parse_relation_body() - relation_body1247 = _t2072 + _t2085 = self.parse_relation_keys() + relation_keys1254 = _t2085 + _t2086 = self.parse_relation_body() + relation_body1255 = _t2086 if self.match_lookahead_literal("(", 0): - _t2074 = self.parse_load_errors() - _t2073 = _t2074 + _t2088 = self.parse_load_errors() + _t2087 = _t2088 else: - _t2073 = None - load_errors1248 = _t2073 + _t2087 = None + load_errors1256 = _t2087 self.consume_literal(")") - _t2075 = self.construct_relations(relation_keys1246, relation_body1247, load_errors1248) - result1250 = _t2075 - self.record_span(span_start1249, "TargetRelations") - return result1250 + _t2089 = self.construct_relations(relation_keys1254, relation_body1255, load_errors1256) + result1258 = _t2089 + self.record_span(span_start1257, "TargetRelations") + return result1258 def parse_relation_keys(self) -> tuple[Sequence[logic_pb2.NamedColumn], bool]: if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("keys", 1): if self.match_lookahead_literal("synthetic", 2): - _t2078 = 1 + _t2092 = 1 else: if self.match_lookahead_literal(")", 2): - _t2079 = 0 + _t2093 = 0 else: if self.match_lookahead_literal("(", 2): - _t2080 = 0 + _t2094 = 0 else: - _t2080 = -1 - _t2079 = _t2080 - _t2078 = _t2079 - _t2077 = _t2078 + _t2094 = -1 + _t2093 = _t2094 + _t2092 = _t2093 + _t2091 = _t2092 else: - _t2077 = -1 - _t2076 = _t2077 + _t2091 = -1 + _t2090 = _t2091 else: - _t2076 = -1 - prediction1251 = _t2076 - if prediction1251 == 1: + _t2090 = -1 + prediction1259 = _t2090 + if prediction1259 == 1: self.consume_literal("(") self.consume_literal("keys") self.consume_literal("synthetic") self.consume_literal(")") - _t2081 = ([], True,) + _t2095 = ([], True,) else: - if prediction1251 == 0: + if prediction1259 == 0: self.consume_literal("(") self.consume_literal("keys") - xs1252 = [] - cond1253 = self.match_lookahead_literal("(", 0) - while cond1253: - _t2083 = self.parse_named_column() - item1254 = _t2083 - xs1252.append(item1254) - cond1253 = self.match_lookahead_literal("(", 0) - named_columns1255 = xs1252 + xs1260 = [] + cond1261 = self.match_lookahead_literal("(", 0) + while cond1261: + _t2097 = self.parse_named_column() + item1262 = _t2097 + xs1260.append(item1262) + cond1261 = self.match_lookahead_literal("(", 0) + named_columns1263 = xs1260 self.consume_literal(")") - _t2082 = (named_columns1255, False,) + _t2096 = (named_columns1263, False,) else: raise ParseError("Unexpected token in relation_keys" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t2081 = _t2082 - return _t2081 + _t2095 = _t2096 + return _t2095 def parse_named_column(self) -> logic_pb2.NamedColumn: - span_start1258 = self.span_start() + span_start1266 = self.span_start() self.consume_literal("(") self.consume_literal("column") - string1256 = self.consume_terminal("STRING") - _t2084 = self.parse_type() - type1257 = _t2084 + string1264 = self.consume_terminal("STRING") + _t2098 = self.parse_type() + type1265 = _t2098 self.consume_literal(")") - _t2085 = logic_pb2.NamedColumn(name=string1256, type=type1257) - result1259 = _t2085 - self.record_span(span_start1258, "NamedColumn") - return result1259 + _t2099 = logic_pb2.NamedColumn(name=string1264, type=type1265) + result1267 = _t2099 + self.record_span(span_start1266, "NamedColumn") + return result1267 def parse_relation_body(self) -> logic_pb2.TargetRelations: - span_start1264 = self.span_start() + span_start1272 = self.span_start() if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("relation", 1): - _t2087 = 0 + _t2101 = 0 else: if self.match_lookahead_literal("inserts", 1): - _t2088 = 1 + _t2102 = 1 else: - _t2088 = 0 - _t2087 = _t2088 - _t2086 = _t2087 + _t2102 = 0 + _t2101 = _t2102 + _t2100 = _t2101 else: - _t2086 = 0 - prediction1260 = _t2086 - if prediction1260 == 1: - _t2090 = self.parse_cdc_inserts() - cdc_inserts1262 = _t2090 - _t2091 = self.parse_cdc_deletes() - cdc_deletes1263 = _t2091 - _t2092 = self.construct_cdc_relations(cdc_inserts1262, cdc_deletes1263) - _t2089 = _t2092 + _t2100 = 0 + prediction1268 = _t2100 + if prediction1268 == 1: + _t2104 = self.parse_cdc_inserts() + cdc_inserts1270 = _t2104 + _t2105 = self.parse_cdc_deletes() + cdc_deletes1271 = _t2105 + _t2106 = self.construct_cdc_relations(cdc_inserts1270, cdc_deletes1271) + _t2103 = _t2106 else: - if prediction1260 == 0: - _t2094 = self.parse_non_cdc_relations() - non_cdc_relations1261 = _t2094 - _t2095 = self.construct_non_cdc_relations(non_cdc_relations1261) - _t2093 = _t2095 + if prediction1268 == 0: + _t2108 = self.parse_non_cdc_relations() + non_cdc_relations1269 = _t2108 + _t2109 = self.construct_non_cdc_relations(non_cdc_relations1269) + _t2107 = _t2109 else: raise ParseError("Unexpected token in relation_body" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t2089 = _t2093 - result1265 = _t2089 - self.record_span(span_start1264, "TargetRelations") - return result1265 + _t2103 = _t2107 + result1273 = _t2103 + self.record_span(span_start1272, "TargetRelations") + return result1273 def parse_non_cdc_relations(self) -> Sequence[logic_pb2.TargetRelation]: - xs1266 = [] - cond1267 = (self.match_lookahead_literal("(", 0) and self.match_lookahead_literal("relation", 1)) - while cond1267: - _t2096 = self.parse_target_relation() - item1268 = _t2096 - xs1266.append(item1268) - cond1267 = (self.match_lookahead_literal("(", 0) and self.match_lookahead_literal("relation", 1)) - return xs1266 + xs1274 = [] + cond1275 = (self.match_lookahead_literal("(", 0) and self.match_lookahead_literal("relation", 1)) + while cond1275: + _t2110 = self.parse_target_relation() + item1276 = _t2110 + xs1274.append(item1276) + cond1275 = (self.match_lookahead_literal("(", 0) and self.match_lookahead_literal("relation", 1)) + return xs1274 def parse_target_relation(self) -> logic_pb2.TargetRelation: - span_start1274 = self.span_start() + span_start1282 = self.span_start() self.consume_literal("(") self.consume_literal("relation") - _t2097 = self.parse_relation_id() - relation_id1269 = _t2097 - xs1270 = [] - cond1271 = self.match_lookahead_literal("(", 0) - while cond1271: - _t2098 = self.parse_named_column() - item1272 = _t2098 - xs1270.append(item1272) - cond1271 = self.match_lookahead_literal("(", 0) - named_columns1273 = xs1270 + _t2111 = self.parse_relation_id() + relation_id1277 = _t2111 + xs1278 = [] + cond1279 = self.match_lookahead_literal("(", 0) + while cond1279: + _t2112 = self.parse_named_column() + item1280 = _t2112 + xs1278.append(item1280) + cond1279 = self.match_lookahead_literal("(", 0) + named_columns1281 = xs1278 self.consume_literal(")") - _t2099 = logic_pb2.TargetRelation(target_id=relation_id1269, values=named_columns1273) - result1275 = _t2099 - self.record_span(span_start1274, "TargetRelation") - return result1275 + _t2113 = logic_pb2.TargetRelation(target_id=relation_id1277, values=named_columns1281) + result1283 = _t2113 + self.record_span(span_start1282, "TargetRelation") + return result1283 def parse_cdc_inserts(self) -> Sequence[logic_pb2.TargetRelation]: self.consume_literal("(") self.consume_literal("inserts") - xs1276 = [] - cond1277 = self.match_lookahead_literal("(", 0) - while cond1277: - _t2100 = self.parse_target_relation() - item1278 = _t2100 - xs1276.append(item1278) - cond1277 = self.match_lookahead_literal("(", 0) - target_relations1279 = xs1276 + xs1284 = [] + cond1285 = self.match_lookahead_literal("(", 0) + while cond1285: + _t2114 = self.parse_target_relation() + item1286 = _t2114 + xs1284.append(item1286) + cond1285 = self.match_lookahead_literal("(", 0) + target_relations1287 = xs1284 self.consume_literal(")") - return target_relations1279 + return target_relations1287 def parse_cdc_deletes(self) -> Sequence[logic_pb2.TargetRelation]: self.consume_literal("(") self.consume_literal("deletes") - xs1280 = [] - cond1281 = self.match_lookahead_literal("(", 0) - while cond1281: - _t2101 = self.parse_target_relation() - item1282 = _t2101 - xs1280.append(item1282) - cond1281 = self.match_lookahead_literal("(", 0) - target_relations1283 = xs1280 + xs1288 = [] + cond1289 = self.match_lookahead_literal("(", 0) + while cond1289: + _t2115 = self.parse_target_relation() + item1290 = _t2115 + xs1288.append(item1290) + cond1289 = self.match_lookahead_literal("(", 0) + target_relations1291 = xs1288 self.consume_literal(")") - return target_relations1283 + return target_relations1291 def parse_load_errors(self) -> logic_pb2.RelationId: - span_start1285 = self.span_start() + span_start1293 = self.span_start() self.consume_literal("(") self.consume_literal("load_errors") - _t2102 = self.parse_relation_id() - relation_id1284 = _t2102 + _t2116 = self.parse_relation_id() + relation_id1292 = _t2116 self.consume_literal(")") - result1286 = relation_id1284 - self.record_span(span_start1285, "RelationId") - return result1286 + result1294 = relation_id1292 + self.record_span(span_start1293, "RelationId") + return result1294 def parse_csv_asof(self) -> str: self.consume_literal("(") self.consume_literal("asof") - string1287 = self.consume_terminal("STRING") + string1295 = self.consume_terminal("STRING") self.consume_literal(")") - return string1287 + return string1295 def parse_iceberg_data(self) -> logic_pb2.IcebergData: - span_start1294 = self.span_start() + span_start1302 = self.span_start() self.consume_literal("(") self.consume_literal("iceberg_data") - _t2103 = self.parse_iceberg_locator() - iceberg_locator1288 = _t2103 - _t2104 = self.parse_iceberg_catalog_config() - iceberg_catalog_config1289 = _t2104 - _t2105 = self.parse_gnf_columns() - gnf_columns1290 = _t2105 + _t2117 = self.parse_iceberg_locator() + iceberg_locator1296 = _t2117 + _t2118 = self.parse_iceberg_catalog_config() + iceberg_catalog_config1297 = _t2118 + _t2119 = self.parse_gnf_columns() + gnf_columns1298 = _t2119 if (self.match_lookahead_literal("(", 0) and self.match_lookahead_literal("from_snapshot", 1)): - _t2107 = self.parse_iceberg_from_snapshot() - _t2106 = _t2107 + _t2121 = self.parse_iceberg_from_snapshot() + _t2120 = _t2121 else: - _t2106 = None - iceberg_from_snapshot1291 = _t2106 + _t2120 = None + iceberg_from_snapshot1299 = _t2120 if self.match_lookahead_literal("(", 0): - _t2109 = self.parse_iceberg_to_snapshot() - _t2108 = _t2109 + _t2123 = self.parse_iceberg_to_snapshot() + _t2122 = _t2123 else: - _t2108 = None - iceberg_to_snapshot1292 = _t2108 - _t2110 = self.parse_boolean_value() - boolean_value1293 = _t2110 + _t2122 = None + iceberg_to_snapshot1300 = _t2122 + _t2124 = self.parse_boolean_value() + boolean_value1301 = _t2124 self.consume_literal(")") - _t2111 = self.construct_iceberg_data(iceberg_locator1288, iceberg_catalog_config1289, gnf_columns1290, iceberg_from_snapshot1291, iceberg_to_snapshot1292, boolean_value1293) - result1295 = _t2111 - self.record_span(span_start1294, "IcebergData") - return result1295 + _t2125 = self.construct_iceberg_data(iceberg_locator1296, iceberg_catalog_config1297, gnf_columns1298, iceberg_from_snapshot1299, iceberg_to_snapshot1300, boolean_value1301) + result1303 = _t2125 + self.record_span(span_start1302, "IcebergData") + return result1303 def parse_iceberg_locator(self) -> logic_pb2.IcebergLocator: - span_start1299 = self.span_start() + span_start1307 = self.span_start() self.consume_literal("(") self.consume_literal("iceberg_locator") - _t2112 = self.parse_iceberg_locator_table_name() - iceberg_locator_table_name1296 = _t2112 - _t2113 = self.parse_iceberg_locator_namespace() - iceberg_locator_namespace1297 = _t2113 - _t2114 = self.parse_iceberg_locator_warehouse() - iceberg_locator_warehouse1298 = _t2114 + _t2126 = self.parse_iceberg_locator_table_name() + iceberg_locator_table_name1304 = _t2126 + _t2127 = self.parse_iceberg_locator_namespace() + iceberg_locator_namespace1305 = _t2127 + _t2128 = self.parse_iceberg_locator_warehouse() + iceberg_locator_warehouse1306 = _t2128 self.consume_literal(")") - _t2115 = logic_pb2.IcebergLocator(table_name=iceberg_locator_table_name1296, namespace=iceberg_locator_namespace1297, warehouse=iceberg_locator_warehouse1298) - result1300 = _t2115 - self.record_span(span_start1299, "IcebergLocator") - return result1300 + _t2129 = logic_pb2.IcebergLocator(table_name=iceberg_locator_table_name1304, namespace=iceberg_locator_namespace1305, warehouse=iceberg_locator_warehouse1306) + result1308 = _t2129 + self.record_span(span_start1307, "IcebergLocator") + return result1308 def parse_iceberg_locator_table_name(self) -> str: self.consume_literal("(") self.consume_literal("table_name") - string1301 = self.consume_terminal("STRING") + string1309 = self.consume_terminal("STRING") self.consume_literal(")") - return string1301 + return string1309 def parse_iceberg_locator_namespace(self) -> Sequence[str]: self.consume_literal("(") self.consume_literal("namespace") - xs1302 = [] - cond1303 = self.match_lookahead_terminal("STRING", 0) - while cond1303: - item1304 = self.consume_terminal("STRING") - xs1302.append(item1304) - cond1303 = self.match_lookahead_terminal("STRING", 0) - strings1305 = xs1302 + xs1310 = [] + cond1311 = self.match_lookahead_terminal("STRING", 0) + while cond1311: + item1312 = self.consume_terminal("STRING") + xs1310.append(item1312) + cond1311 = self.match_lookahead_terminal("STRING", 0) + strings1313 = xs1310 self.consume_literal(")") - return strings1305 + return strings1313 def parse_iceberg_locator_warehouse(self) -> str: self.consume_literal("(") self.consume_literal("warehouse") - string1306 = self.consume_terminal("STRING") + string1314 = self.consume_terminal("STRING") self.consume_literal(")") - return string1306 + return string1314 def parse_iceberg_catalog_config(self) -> logic_pb2.IcebergCatalogConfig: - span_start1311 = self.span_start() + span_start1319 = self.span_start() self.consume_literal("(") self.consume_literal("iceberg_catalog_config") - _t2116 = self.parse_iceberg_catalog_uri() - iceberg_catalog_uri1307 = _t2116 + _t2130 = self.parse_iceberg_catalog_uri() + iceberg_catalog_uri1315 = _t2130 if (self.match_lookahead_literal("(", 0) and self.match_lookahead_literal("scope", 1)): - _t2118 = self.parse_iceberg_catalog_config_scope() - _t2117 = _t2118 + _t2132 = self.parse_iceberg_catalog_config_scope() + _t2131 = _t2132 else: - _t2117 = None - iceberg_catalog_config_scope1308 = _t2117 - _t2119 = self.parse_iceberg_properties() - iceberg_properties1309 = _t2119 - _t2120 = self.parse_iceberg_auth_properties() - iceberg_auth_properties1310 = _t2120 + _t2131 = None + iceberg_catalog_config_scope1316 = _t2131 + _t2133 = self.parse_iceberg_properties() + iceberg_properties1317 = _t2133 + _t2134 = self.parse_iceberg_auth_properties() + iceberg_auth_properties1318 = _t2134 self.consume_literal(")") - _t2121 = self.construct_iceberg_catalog_config(iceberg_catalog_uri1307, iceberg_catalog_config_scope1308, iceberg_properties1309, iceberg_auth_properties1310) - result1312 = _t2121 - self.record_span(span_start1311, "IcebergCatalogConfig") - return result1312 + _t2135 = self.construct_iceberg_catalog_config(iceberg_catalog_uri1315, iceberg_catalog_config_scope1316, iceberg_properties1317, iceberg_auth_properties1318) + result1320 = _t2135 + self.record_span(span_start1319, "IcebergCatalogConfig") + return result1320 def parse_iceberg_catalog_uri(self) -> str: self.consume_literal("(") self.consume_literal("catalog_uri") - string1313 = self.consume_terminal("STRING") + string1321 = self.consume_terminal("STRING") self.consume_literal(")") - return string1313 + return string1321 def parse_iceberg_catalog_config_scope(self) -> str: self.consume_literal("(") self.consume_literal("scope") - string1314 = self.consume_terminal("STRING") + string1322 = self.consume_terminal("STRING") self.consume_literal(")") - return string1314 + return string1322 def parse_iceberg_properties(self) -> Sequence[tuple[str, str]]: self.consume_literal("(") self.consume_literal("properties") - xs1315 = [] - cond1316 = self.match_lookahead_literal("(", 0) - while cond1316: - _t2122 = self.parse_iceberg_property_entry() - item1317 = _t2122 - xs1315.append(item1317) - cond1316 = self.match_lookahead_literal("(", 0) - iceberg_property_entrys1318 = xs1315 + xs1323 = [] + cond1324 = self.match_lookahead_literal("(", 0) + while cond1324: + _t2136 = self.parse_iceberg_property_entry() + item1325 = _t2136 + xs1323.append(item1325) + cond1324 = self.match_lookahead_literal("(", 0) + iceberg_property_entrys1326 = xs1323 self.consume_literal(")") - return iceberg_property_entrys1318 + return iceberg_property_entrys1326 def parse_iceberg_property_entry(self) -> tuple[str, str]: self.consume_literal("(") self.consume_literal("prop") - string1319 = self.consume_terminal("STRING") - string_31320 = self.consume_terminal("STRING") + string1327 = self.consume_terminal("STRING") + string_31328 = self.consume_terminal("STRING") self.consume_literal(")") - return (string1319, string_31320,) + return (string1327, string_31328,) def parse_iceberg_auth_properties(self) -> Sequence[tuple[str, str]]: self.consume_literal("(") self.consume_literal("auth_properties") - xs1321 = [] - cond1322 = self.match_lookahead_literal("(", 0) - while cond1322: - _t2123 = self.parse_iceberg_masked_property_entry() - item1323 = _t2123 - xs1321.append(item1323) - cond1322 = self.match_lookahead_literal("(", 0) - iceberg_masked_property_entrys1324 = xs1321 + xs1329 = [] + cond1330 = self.match_lookahead_literal("(", 0) + while cond1330: + _t2137 = self.parse_iceberg_masked_property_entry() + item1331 = _t2137 + xs1329.append(item1331) + cond1330 = self.match_lookahead_literal("(", 0) + iceberg_masked_property_entrys1332 = xs1329 self.consume_literal(")") - return iceberg_masked_property_entrys1324 + return iceberg_masked_property_entrys1332 def parse_iceberg_masked_property_entry(self) -> tuple[str, str]: self.consume_literal("(") self.consume_literal("prop") - string1325 = self.consume_terminal("STRING") - string_31326 = self.consume_terminal("STRING") + string1333 = self.consume_terminal("STRING") + string_31334 = self.consume_terminal("STRING") self.consume_literal(")") - return (string1325, string_31326,) + return (string1333, string_31334,) def parse_iceberg_from_snapshot(self) -> str: self.consume_literal("(") self.consume_literal("from_snapshot") - string1327 = self.consume_terminal("STRING") + string1335 = self.consume_terminal("STRING") self.consume_literal(")") - return string1327 + return string1335 def parse_iceberg_to_snapshot(self) -> str: self.consume_literal("(") self.consume_literal("to_snapshot") - string1328 = self.consume_terminal("STRING") + string1336 = self.consume_terminal("STRING") self.consume_literal(")") - return string1328 + return string1336 def parse_undefine(self) -> transactions_pb2.Undefine: - span_start1330 = self.span_start() + span_start1338 = self.span_start() self.consume_literal("(") self.consume_literal("undefine") - _t2124 = self.parse_fragment_id() - fragment_id1329 = _t2124 + _t2138 = self.parse_fragment_id() + fragment_id1337 = _t2138 self.consume_literal(")") - _t2125 = transactions_pb2.Undefine(fragment_id=fragment_id1329) - result1331 = _t2125 - self.record_span(span_start1330, "Undefine") - return result1331 + _t2139 = transactions_pb2.Undefine(fragment_id=fragment_id1337) + result1339 = _t2139 + self.record_span(span_start1338, "Undefine") + return result1339 def parse_context(self) -> transactions_pb2.Context: - span_start1336 = self.span_start() + span_start1344 = self.span_start() self.consume_literal("(") self.consume_literal("context") - xs1332 = [] - cond1333 = (self.match_lookahead_literal(":", 0) or self.match_lookahead_terminal("UINT128", 0)) - while cond1333: - _t2126 = self.parse_relation_id() - item1334 = _t2126 - xs1332.append(item1334) - cond1333 = (self.match_lookahead_literal(":", 0) or self.match_lookahead_terminal("UINT128", 0)) - relation_ids1335 = xs1332 + xs1340 = [] + cond1341 = (self.match_lookahead_literal(":", 0) or self.match_lookahead_terminal("UINT128", 0)) + while cond1341: + _t2140 = self.parse_relation_id() + item1342 = _t2140 + xs1340.append(item1342) + cond1341 = (self.match_lookahead_literal(":", 0) or self.match_lookahead_terminal("UINT128", 0)) + relation_ids1343 = xs1340 self.consume_literal(")") - _t2127 = transactions_pb2.Context(relations=relation_ids1335) - result1337 = _t2127 - self.record_span(span_start1336, "Context") - return result1337 + _t2141 = transactions_pb2.Context(relations=relation_ids1343) + result1345 = _t2141 + self.record_span(span_start1344, "Context") + return result1345 def parse_snapshot(self) -> transactions_pb2.Snapshot: - span_start1343 = self.span_start() + span_start1351 = self.span_start() self.consume_literal("(") self.consume_literal("snapshot") - _t2128 = self.parse_edb_path() - edb_path1338 = _t2128 - xs1339 = [] - cond1340 = self.match_lookahead_literal("[", 0) - while cond1340: - _t2129 = self.parse_snapshot_mapping() - item1341 = _t2129 - xs1339.append(item1341) - cond1340 = self.match_lookahead_literal("[", 0) - snapshot_mappings1342 = xs1339 + _t2142 = self.parse_edb_path() + edb_path1346 = _t2142 + xs1347 = [] + cond1348 = self.match_lookahead_literal("[", 0) + while cond1348: + _t2143 = self.parse_snapshot_mapping() + item1349 = _t2143 + xs1347.append(item1349) + cond1348 = self.match_lookahead_literal("[", 0) + snapshot_mappings1350 = xs1347 self.consume_literal(")") - _t2130 = transactions_pb2.Snapshot(prefix=edb_path1338, mappings=snapshot_mappings1342) - result1344 = _t2130 - self.record_span(span_start1343, "Snapshot") - return result1344 + _t2144 = transactions_pb2.Snapshot(prefix=edb_path1346, mappings=snapshot_mappings1350) + result1352 = _t2144 + self.record_span(span_start1351, "Snapshot") + return result1352 def parse_snapshot_mapping(self) -> transactions_pb2.SnapshotMapping: - span_start1347 = self.span_start() - _t2131 = self.parse_edb_path() - edb_path1345 = _t2131 - _t2132 = self.parse_relation_id() - relation_id1346 = _t2132 - _t2133 = transactions_pb2.SnapshotMapping(destination_path=edb_path1345, source_relation=relation_id1346) - result1348 = _t2133 - self.record_span(span_start1347, "SnapshotMapping") - return result1348 + span_start1355 = self.span_start() + _t2145 = self.parse_edb_path() + edb_path1353 = _t2145 + _t2146 = self.parse_relation_id() + relation_id1354 = _t2146 + _t2147 = transactions_pb2.SnapshotMapping(destination_path=edb_path1353, source_relation=relation_id1354) + result1356 = _t2147 + self.record_span(span_start1355, "SnapshotMapping") + return result1356 def parse_epoch_reads(self) -> Sequence[transactions_pb2.Read]: self.consume_literal("(") self.consume_literal("reads") - xs1349 = [] - cond1350 = self.match_lookahead_literal("(", 0) - while cond1350: - _t2134 = self.parse_read() - item1351 = _t2134 - xs1349.append(item1351) - cond1350 = self.match_lookahead_literal("(", 0) - reads1352 = xs1349 + xs1357 = [] + cond1358 = self.match_lookahead_literal("(", 0) + while cond1358: + _t2148 = self.parse_read() + item1359 = _t2148 + xs1357.append(item1359) + cond1358 = self.match_lookahead_literal("(", 0) + reads1360 = xs1357 self.consume_literal(")") - return reads1352 + return reads1360 def parse_read(self) -> transactions_pb2.Read: - span_start1359 = self.span_start() + span_start1367 = self.span_start() if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("what_if", 1): - _t2136 = 2 + _t2150 = 2 else: if self.match_lookahead_literal("output", 1): - _t2137 = 1 + _t2151 = 1 else: if self.match_lookahead_literal("export_iceberg", 1): - _t2138 = 4 + _t2152 = 4 else: if self.match_lookahead_literal("export", 1): - _t2139 = 4 + _t2153 = 4 else: if self.match_lookahead_literal("demand", 1): - _t2140 = 0 + _t2154 = 0 else: if self.match_lookahead_literal("abort", 1): - _t2141 = 3 + _t2155 = 3 else: - _t2141 = -1 - _t2140 = _t2141 - _t2139 = _t2140 - _t2138 = _t2139 - _t2137 = _t2138 - _t2136 = _t2137 - _t2135 = _t2136 + _t2155 = -1 + _t2154 = _t2155 + _t2153 = _t2154 + _t2152 = _t2153 + _t2151 = _t2152 + _t2150 = _t2151 + _t2149 = _t2150 else: - _t2135 = -1 - prediction1353 = _t2135 - if prediction1353 == 4: - _t2143 = self.parse_export() - export1358 = _t2143 - _t2144 = transactions_pb2.Read(export=export1358) - _t2142 = _t2144 + _t2149 = -1 + prediction1361 = _t2149 + if prediction1361 == 4: + _t2157 = self.parse_export() + export1366 = _t2157 + _t2158 = transactions_pb2.Read(export=export1366) + _t2156 = _t2158 else: - if prediction1353 == 3: - _t2146 = self.parse_abort() - abort1357 = _t2146 - _t2147 = transactions_pb2.Read(abort=abort1357) - _t2145 = _t2147 + if prediction1361 == 3: + _t2160 = self.parse_abort() + abort1365 = _t2160 + _t2161 = transactions_pb2.Read(abort=abort1365) + _t2159 = _t2161 else: - if prediction1353 == 2: - _t2149 = self.parse_what_if() - what_if1356 = _t2149 - _t2150 = transactions_pb2.Read(what_if=what_if1356) - _t2148 = _t2150 + if prediction1361 == 2: + _t2163 = self.parse_what_if() + what_if1364 = _t2163 + _t2164 = transactions_pb2.Read(what_if=what_if1364) + _t2162 = _t2164 else: - if prediction1353 == 1: - _t2152 = self.parse_output() - output1355 = _t2152 - _t2153 = transactions_pb2.Read(output=output1355) - _t2151 = _t2153 + if prediction1361 == 1: + _t2166 = self.parse_output() + output1363 = _t2166 + _t2167 = transactions_pb2.Read(output=output1363) + _t2165 = _t2167 else: - if prediction1353 == 0: - _t2155 = self.parse_demand() - demand1354 = _t2155 - _t2156 = transactions_pb2.Read(demand=demand1354) - _t2154 = _t2156 + if prediction1361 == 0: + _t2169 = self.parse_demand() + demand1362 = _t2169 + _t2170 = transactions_pb2.Read(demand=demand1362) + _t2168 = _t2170 else: raise ParseError("Unexpected token in read" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t2151 = _t2154 - _t2148 = _t2151 - _t2145 = _t2148 - _t2142 = _t2145 - result1360 = _t2142 - self.record_span(span_start1359, "Read") - return result1360 + _t2165 = _t2168 + _t2162 = _t2165 + _t2159 = _t2162 + _t2156 = _t2159 + result1368 = _t2156 + self.record_span(span_start1367, "Read") + return result1368 def parse_demand(self) -> transactions_pb2.Demand: - span_start1362 = self.span_start() + span_start1370 = self.span_start() self.consume_literal("(") self.consume_literal("demand") - _t2157 = self.parse_relation_id() - relation_id1361 = _t2157 + _t2171 = self.parse_relation_id() + relation_id1369 = _t2171 self.consume_literal(")") - _t2158 = transactions_pb2.Demand(relation_id=relation_id1361) - result1363 = _t2158 - self.record_span(span_start1362, "Demand") - return result1363 + _t2172 = transactions_pb2.Demand(relation_id=relation_id1369) + result1371 = _t2172 + self.record_span(span_start1370, "Demand") + return result1371 def parse_output(self) -> transactions_pb2.Output: - span_start1366 = self.span_start() + span_start1374 = self.span_start() self.consume_literal("(") self.consume_literal("output") - _t2159 = self.parse_name() - name1364 = _t2159 - _t2160 = self.parse_relation_id() - relation_id1365 = _t2160 + _t2173 = self.parse_name() + name1372 = _t2173 + _t2174 = self.parse_relation_id() + relation_id1373 = _t2174 self.consume_literal(")") - _t2161 = transactions_pb2.Output(name=name1364, relation_id=relation_id1365) - result1367 = _t2161 - self.record_span(span_start1366, "Output") - return result1367 + _t2175 = transactions_pb2.Output(name=name1372, relation_id=relation_id1373) + result1375 = _t2175 + self.record_span(span_start1374, "Output") + return result1375 def parse_what_if(self) -> transactions_pb2.WhatIf: - span_start1370 = self.span_start() + span_start1378 = self.span_start() self.consume_literal("(") self.consume_literal("what_if") - _t2162 = self.parse_name() - name1368 = _t2162 - _t2163 = self.parse_epoch() - epoch1369 = _t2163 + _t2176 = self.parse_name() + name1376 = _t2176 + _t2177 = self.parse_epoch() + epoch1377 = _t2177 self.consume_literal(")") - _t2164 = transactions_pb2.WhatIf(branch=name1368, epoch=epoch1369) - result1371 = _t2164 - self.record_span(span_start1370, "WhatIf") - return result1371 + _t2178 = transactions_pb2.WhatIf(branch=name1376, epoch=epoch1377) + result1379 = _t2178 + self.record_span(span_start1378, "WhatIf") + return result1379 def parse_abort(self) -> transactions_pb2.Abort: - span_start1374 = self.span_start() + span_start1382 = self.span_start() self.consume_literal("(") self.consume_literal("abort") if (self.match_lookahead_literal(":", 0) and self.match_lookahead_terminal("SYMBOL", 1)): - _t2166 = self.parse_name() - _t2165 = _t2166 + _t2180 = self.parse_name() + _t2179 = _t2180 else: - _t2165 = None - name1372 = _t2165 - _t2167 = self.parse_relation_id() - relation_id1373 = _t2167 + _t2179 = None + name1380 = _t2179 + _t2181 = self.parse_relation_id() + relation_id1381 = _t2181 self.consume_literal(")") - _t2168 = transactions_pb2.Abort(name=(name1372 if name1372 is not None else "abort"), relation_id=relation_id1373) - result1375 = _t2168 - self.record_span(span_start1374, "Abort") - return result1375 + _t2182 = transactions_pb2.Abort(name=(name1380 if name1380 is not None else "abort"), relation_id=relation_id1381) + result1383 = _t2182 + self.record_span(span_start1382, "Abort") + return result1383 def parse_export(self) -> transactions_pb2.Export: - span_start1379 = self.span_start() + span_start1387 = self.span_start() if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("export_iceberg", 1): - _t2170 = 1 + _t2184 = 1 else: if self.match_lookahead_literal("export", 1): - _t2171 = 0 + _t2185 = 0 else: - _t2171 = -1 - _t2170 = _t2171 - _t2169 = _t2170 + _t2185 = -1 + _t2184 = _t2185 + _t2183 = _t2184 else: - _t2169 = -1 - prediction1376 = _t2169 - if prediction1376 == 1: + _t2183 = -1 + prediction1384 = _t2183 + if prediction1384 == 1: self.consume_literal("(") self.consume_literal("export_iceberg") - _t2173 = self.parse_export_iceberg_config() - export_iceberg_config1378 = _t2173 + _t2187 = self.parse_export_iceberg_config() + export_iceberg_config1386 = _t2187 self.consume_literal(")") - _t2174 = transactions_pb2.Export(iceberg_config=export_iceberg_config1378) - _t2172 = _t2174 + _t2188 = transactions_pb2.Export(iceberg_config=export_iceberg_config1386) + _t2186 = _t2188 else: - if prediction1376 == 0: + if prediction1384 == 0: self.consume_literal("(") self.consume_literal("export") - _t2176 = self.parse_export_csv_config() - export_csv_config1377 = _t2176 + _t2190 = self.parse_export_csv_config() + export_csv_config1385 = _t2190 self.consume_literal(")") - _t2177 = transactions_pb2.Export(csv_config=export_csv_config1377) - _t2175 = _t2177 + _t2191 = transactions_pb2.Export(csv_config=export_csv_config1385) + _t2189 = _t2191 else: raise ParseError("Unexpected token in export" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t2172 = _t2175 - result1380 = _t2172 - self.record_span(span_start1379, "Export") - return result1380 + _t2186 = _t2189 + result1388 = _t2186 + self.record_span(span_start1387, "Export") + return result1388 def parse_export_csv_config(self) -> transactions_pb2.ExportCSVConfig: - span_start1388 = self.span_start() + span_start1396 = self.span_start() if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("export_csv_config_v2", 1): - _t2179 = 0 + _t2193 = 0 else: if self.match_lookahead_literal("export_csv_config", 1): - _t2180 = 1 + _t2194 = 1 else: - _t2180 = -1 - _t2179 = _t2180 - _t2178 = _t2179 + _t2194 = -1 + _t2193 = _t2194 + _t2192 = _t2193 else: - _t2178 = -1 - prediction1381 = _t2178 - if prediction1381 == 1: + _t2192 = -1 + prediction1389 = _t2192 + if prediction1389 == 1: self.consume_literal("(") self.consume_literal("export_csv_config") - _t2182 = self.parse_export_csv_path() - export_csv_path1385 = _t2182 - _t2183 = self.parse_export_csv_columns_list() - export_csv_columns_list1386 = _t2183 - _t2184 = self.parse_config_dict() - config_dict1387 = _t2184 + _t2196 = self.parse_export_csv_path() + export_csv_path1393 = _t2196 + _t2197 = self.parse_export_csv_columns_list() + export_csv_columns_list1394 = _t2197 + _t2198 = self.parse_config_dict() + config_dict1395 = _t2198 self.consume_literal(")") - _t2185 = self.construct_export_csv_config(export_csv_path1385, export_csv_columns_list1386, config_dict1387) - _t2181 = _t2185 + _t2199 = self.construct_export_csv_config(export_csv_path1393, export_csv_columns_list1394, config_dict1395) + _t2195 = _t2199 else: - if prediction1381 == 0: + if prediction1389 == 0: self.consume_literal("(") self.consume_literal("export_csv_config_v2") - _t2187 = self.parse_export_csv_output_location() - export_csv_output_location1382 = _t2187 - _t2188 = self.parse_export_csv_source() - export_csv_source1383 = _t2188 - _t2189 = self.parse_csv_config() - csv_config1384 = _t2189 + _t2201 = self.parse_export_csv_output_location() + export_csv_output_location1390 = _t2201 + _t2202 = self.parse_export_csv_source() + export_csv_source1391 = _t2202 + _t2203 = self.parse_csv_config() + csv_config1392 = _t2203 self.consume_literal(")") - _t2190 = self.construct_export_csv_config_with_location(export_csv_output_location1382, export_csv_source1383, csv_config1384) - _t2186 = _t2190 + _t2204 = self.construct_export_csv_config_with_location(export_csv_output_location1390, export_csv_source1391, csv_config1392) + _t2200 = _t2204 else: raise ParseError("Unexpected token in export_csv_config" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t2181 = _t2186 - result1389 = _t2181 - self.record_span(span_start1388, "ExportCSVConfig") - return result1389 + _t2195 = _t2200 + result1397 = _t2195 + self.record_span(span_start1396, "ExportCSVConfig") + return result1397 def parse_export_csv_output_location(self) -> tuple[str, str]: if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("transaction_output_name", 1): - _t2192 = 1 + _t2206 = 1 else: if self.match_lookahead_literal("path", 1): - _t2193 = 0 + _t2207 = 0 else: - _t2193 = -1 - _t2192 = _t2193 - _t2191 = _t2192 + _t2207 = -1 + _t2206 = _t2207 + _t2205 = _t2206 else: - _t2191 = -1 - prediction1390 = _t2191 - if prediction1390 == 1: + _t2205 = -1 + prediction1398 = _t2205 + if prediction1398 == 1: self.consume_literal("(") self.consume_literal("transaction_output_name") - _t2195 = self.parse_name() - name1392 = _t2195 + _t2209 = self.parse_name() + name1400 = _t2209 self.consume_literal(")") - _t2194 = ("", name1392,) + _t2208 = ("", name1400,) else: - if prediction1390 == 0: + if prediction1398 == 0: self.consume_literal("(") self.consume_literal("path") - string1391 = self.consume_terminal("STRING") + string1399 = self.consume_terminal("STRING") self.consume_literal(")") - _t2196 = (string1391, "",) + _t2210 = (string1399, "",) else: raise ParseError("Unexpected token in export_csv_output_location" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t2194 = _t2196 - return _t2194 + _t2208 = _t2210 + return _t2208 def parse_export_csv_source(self) -> transactions_pb2.ExportCSVSource: - span_start1399 = self.span_start() + span_start1407 = self.span_start() if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("table_def", 1): - _t2198 = 1 + _t2212 = 1 else: if self.match_lookahead_literal("gnf_columns", 1): - _t2199 = 0 + _t2213 = 0 else: - _t2199 = -1 - _t2198 = _t2199 - _t2197 = _t2198 + _t2213 = -1 + _t2212 = _t2213 + _t2211 = _t2212 else: - _t2197 = -1 - prediction1393 = _t2197 - if prediction1393 == 1: + _t2211 = -1 + prediction1401 = _t2211 + if prediction1401 == 1: self.consume_literal("(") self.consume_literal("table_def") - _t2201 = self.parse_relation_id() - relation_id1398 = _t2201 + _t2215 = self.parse_relation_id() + relation_id1406 = _t2215 self.consume_literal(")") - _t2202 = transactions_pb2.ExportCSVSource(table_def=relation_id1398) - _t2200 = _t2202 + _t2216 = transactions_pb2.ExportCSVSource(table_def=relation_id1406) + _t2214 = _t2216 else: - if prediction1393 == 0: + if prediction1401 == 0: self.consume_literal("(") self.consume_literal("gnf_columns") - xs1394 = [] - cond1395 = self.match_lookahead_literal("(", 0) - while cond1395: - _t2204 = self.parse_export_csv_column() - item1396 = _t2204 - xs1394.append(item1396) - cond1395 = self.match_lookahead_literal("(", 0) - export_csv_columns1397 = xs1394 + xs1402 = [] + cond1403 = self.match_lookahead_literal("(", 0) + while cond1403: + _t2218 = self.parse_export_csv_column() + item1404 = _t2218 + xs1402.append(item1404) + cond1403 = self.match_lookahead_literal("(", 0) + export_csv_columns1405 = xs1402 self.consume_literal(")") - _t2205 = transactions_pb2.ExportCSVColumns(columns=export_csv_columns1397) - _t2206 = transactions_pb2.ExportCSVSource(gnf_columns=_t2205) - _t2203 = _t2206 + _t2219 = transactions_pb2.ExportCSVColumns(columns=export_csv_columns1405) + _t2220 = transactions_pb2.ExportCSVSource(gnf_columns=_t2219) + _t2217 = _t2220 else: raise ParseError("Unexpected token in export_csv_source" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t2200 = _t2203 - result1400 = _t2200 - self.record_span(span_start1399, "ExportCSVSource") - return result1400 + _t2214 = _t2217 + result1408 = _t2214 + self.record_span(span_start1407, "ExportCSVSource") + return result1408 def parse_export_csv_column(self) -> transactions_pb2.ExportCSVColumn: - span_start1403 = self.span_start() + span_start1411 = self.span_start() self.consume_literal("(") self.consume_literal("column") - string1401 = self.consume_terminal("STRING") - _t2207 = self.parse_relation_id() - relation_id1402 = _t2207 + string1409 = self.consume_terminal("STRING") + _t2221 = self.parse_relation_id() + relation_id1410 = _t2221 self.consume_literal(")") - _t2208 = transactions_pb2.ExportCSVColumn(column_name=string1401, column_data=relation_id1402) - result1404 = _t2208 - self.record_span(span_start1403, "ExportCSVColumn") - return result1404 + _t2222 = transactions_pb2.ExportCSVColumn(column_name=string1409, column_data=relation_id1410) + result1412 = _t2222 + self.record_span(span_start1411, "ExportCSVColumn") + return result1412 def parse_export_csv_path(self) -> str: self.consume_literal("(") self.consume_literal("path") - string1405 = self.consume_terminal("STRING") + string1413 = self.consume_terminal("STRING") self.consume_literal(")") - return string1405 + return string1413 def parse_export_csv_columns_list(self) -> Sequence[transactions_pb2.ExportCSVColumn]: self.consume_literal("(") self.consume_literal("columns") - xs1406 = [] - cond1407 = self.match_lookahead_literal("(", 0) - while cond1407: - _t2209 = self.parse_export_csv_column() - item1408 = _t2209 - xs1406.append(item1408) - cond1407 = self.match_lookahead_literal("(", 0) - export_csv_columns1409 = xs1406 + xs1414 = [] + cond1415 = self.match_lookahead_literal("(", 0) + while cond1415: + _t2223 = self.parse_export_csv_column() + item1416 = _t2223 + xs1414.append(item1416) + cond1415 = self.match_lookahead_literal("(", 0) + export_csv_columns1417 = xs1414 self.consume_literal(")") - return export_csv_columns1409 + return export_csv_columns1417 def parse_export_iceberg_config(self) -> transactions_pb2.ExportIcebergConfig: - span_start1415 = self.span_start() + span_start1423 = self.span_start() self.consume_literal("(") self.consume_literal("export_iceberg_config") - _t2210 = self.parse_iceberg_locator() - iceberg_locator1410 = _t2210 - _t2211 = self.parse_iceberg_catalog_config() - iceberg_catalog_config1411 = _t2211 - _t2212 = self.parse_export_iceberg_table_def() - export_iceberg_table_def1412 = _t2212 - _t2213 = self.parse_iceberg_table_properties() - iceberg_table_properties1413 = _t2213 + _t2224 = self.parse_iceberg_locator() + iceberg_locator1418 = _t2224 + _t2225 = self.parse_iceberg_catalog_config() + iceberg_catalog_config1419 = _t2225 + _t2226 = self.parse_export_iceberg_table_def() + export_iceberg_table_def1420 = _t2226 + _t2227 = self.parse_iceberg_table_properties() + iceberg_table_properties1421 = _t2227 if self.match_lookahead_literal("{", 0): - _t2215 = self.parse_config_dict() - _t2214 = _t2215 + _t2229 = self.parse_config_dict() + _t2228 = _t2229 else: - _t2214 = None - config_dict1414 = _t2214 + _t2228 = None + config_dict1422 = _t2228 self.consume_literal(")") - _t2216 = self.construct_export_iceberg_config_full(iceberg_locator1410, iceberg_catalog_config1411, export_iceberg_table_def1412, iceberg_table_properties1413, config_dict1414) - result1416 = _t2216 - self.record_span(span_start1415, "ExportIcebergConfig") - return result1416 + _t2230 = self.construct_export_iceberg_config_full(iceberg_locator1418, iceberg_catalog_config1419, export_iceberg_table_def1420, iceberg_table_properties1421, config_dict1422) + result1424 = _t2230 + self.record_span(span_start1423, "ExportIcebergConfig") + return result1424 def parse_export_iceberg_table_def(self) -> logic_pb2.RelationId: - span_start1418 = self.span_start() + span_start1426 = self.span_start() self.consume_literal("(") self.consume_literal("table_def") - _t2217 = self.parse_relation_id() - relation_id1417 = _t2217 + _t2231 = self.parse_relation_id() + relation_id1425 = _t2231 self.consume_literal(")") - result1419 = relation_id1417 - self.record_span(span_start1418, "RelationId") - return result1419 + result1427 = relation_id1425 + self.record_span(span_start1426, "RelationId") + return result1427 def parse_iceberg_table_properties(self) -> Sequence[tuple[str, str]]: self.consume_literal("(") self.consume_literal("table_properties") - xs1420 = [] - cond1421 = self.match_lookahead_literal("(", 0) - while cond1421: - _t2218 = self.parse_iceberg_property_entry() - item1422 = _t2218 - xs1420.append(item1422) - cond1421 = self.match_lookahead_literal("(", 0) - iceberg_property_entrys1423 = xs1420 + xs1428 = [] + cond1429 = self.match_lookahead_literal("(", 0) + while cond1429: + _t2232 = self.parse_iceberg_property_entry() + item1430 = _t2232 + xs1428.append(item1430) + cond1429 = self.match_lookahead_literal("(", 0) + iceberg_property_entrys1431 = xs1428 self.consume_literal(")") - return iceberg_property_entrys1423 + return iceberg_property_entrys1431 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 33ff59c3..892460a9 100644 --- a/sdks/python/src/lqp/gen/pretty.py +++ b/sdks/python/src/lqp/gen/pretty.py @@ -224,14 +224,14 @@ def deconstruct_load_errors_optional(self, msg: logic_pb2.TargetRelations) -> lo assert msg.load_errors is not None return msg.load_errors else: - _t1863 = None + _t1874 = None return None def deconstruct_csv_data_columns_optional(self, msg: logic_pb2.CSVData) -> Sequence[logic_pb2.GNFColumn] | None: if msg.HasField("relations"): return None else: - _t1864 = None + _t1875 = None return msg.columns def deconstruct_csv_data_relations_optional(self, msg: logic_pb2.CSVData) -> logic_pb2.TargetRelations | None: @@ -239,168 +239,168 @@ def deconstruct_csv_data_relations_optional(self, msg: logic_pb2.CSVData) -> log assert msg.relations is not None return msg.relations else: - _t1865 = None + _t1876 = None return None def deconstruct_export_csv_output_location(self, msg: transactions_pb2.ExportCSVConfig) -> tuple[str, str]: return (msg.path, msg.transaction_output_name,) def _make_value_int32(self, v: int) -> logic_pb2.Value: - _t1866 = logic_pb2.Value(int32_value=v) - return _t1866 + _t1877 = logic_pb2.Value(int32_value=v) + return _t1877 def _make_value_int64(self, v: int) -> logic_pb2.Value: - _t1867 = logic_pb2.Value(int_value=v) - return _t1867 + _t1878 = logic_pb2.Value(int_value=v) + return _t1878 def _make_value_float64(self, v: float) -> logic_pb2.Value: - _t1868 = logic_pb2.Value(float_value=v) - return _t1868 + _t1879 = logic_pb2.Value(float_value=v) + return _t1879 def _make_value_string(self, v: str) -> logic_pb2.Value: - _t1869 = logic_pb2.Value(string_value=v) - return _t1869 + _t1880 = logic_pb2.Value(string_value=v) + return _t1880 def _make_value_boolean(self, v: bool) -> logic_pb2.Value: - _t1870 = logic_pb2.Value(boolean_value=v) - return _t1870 + _t1881 = logic_pb2.Value(boolean_value=v) + return _t1881 def _make_value_uint128(self, v: logic_pb2.UInt128Value) -> logic_pb2.Value: - _t1871 = logic_pb2.Value(uint128_value=v) - return _t1871 + _t1882 = logic_pb2.Value(uint128_value=v) + return _t1882 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: - _t1872 = self._make_value_string("auto") - result.append(("ivm.maintenance_level", _t1872,)) + _t1883 = self._make_value_string("auto") + result.append(("ivm.maintenance_level", _t1883,)) else: if msg.ivm_config.level == transactions_pb2.MaintenanceLevel.MAINTENANCE_LEVEL_ALL: - _t1873 = self._make_value_string("all") - result.append(("ivm.maintenance_level", _t1873,)) + _t1884 = self._make_value_string("all") + result.append(("ivm.maintenance_level", _t1884,)) else: if msg.ivm_config.level == transactions_pb2.MaintenanceLevel.MAINTENANCE_LEVEL_OFF: - _t1874 = self._make_value_string("off") - result.append(("ivm.maintenance_level", _t1874,)) - _t1875 = self._make_value_int64(msg.semantics_version) - result.append(("semantics_version", _t1875,)) + _t1885 = self._make_value_string("off") + result.append(("ivm.maintenance_level", _t1885,)) + _t1886 = self._make_value_int64(msg.semantics_version) + result.append(("semantics_version", _t1886,)) for pair in sorted(msg.configuration_values.items()): result.append(pair) return sorted(result) def deconstruct_csv_config(self, msg: logic_pb2.CSVConfig) -> list[tuple[str, logic_pb2.Value]]: result = [] - _t1876 = self._make_value_int32(msg.header_row) - result.append(("csv_header_row", _t1876,)) - _t1877 = self._make_value_int64(msg.skip) - result.append(("csv_skip", _t1877,)) + _t1887 = self._make_value_int32(msg.header_row) + result.append(("csv_header_row", _t1887,)) + _t1888 = self._make_value_int64(msg.skip) + result.append(("csv_skip", _t1888,)) if msg.new_line != "": - _t1878 = self._make_value_string(msg.new_line) - result.append(("csv_new_line", _t1878,)) - _t1879 = self._make_value_string(msg.delimiter) - result.append(("csv_delimiter", _t1879,)) - _t1880 = self._make_value_string(msg.quotechar) - result.append(("csv_quotechar", _t1880,)) - _t1881 = self._make_value_string(msg.escapechar) - result.append(("csv_escapechar", _t1881,)) + _t1889 = self._make_value_string(msg.new_line) + result.append(("csv_new_line", _t1889,)) + _t1890 = self._make_value_string(msg.delimiter) + result.append(("csv_delimiter", _t1890,)) + _t1891 = self._make_value_string(msg.quotechar) + result.append(("csv_quotechar", _t1891,)) + _t1892 = self._make_value_string(msg.escapechar) + result.append(("csv_escapechar", _t1892,)) if msg.comment != "": - _t1882 = self._make_value_string(msg.comment) - result.append(("csv_comment", _t1882,)) + _t1893 = self._make_value_string(msg.comment) + result.append(("csv_comment", _t1893,)) for missing_string in msg.missing_strings: - _t1883 = self._make_value_string(missing_string) - result.append(("csv_missing_strings", _t1883,)) - _t1884 = self._make_value_string(msg.decimal_separator) - result.append(("csv_decimal_separator", _t1884,)) - _t1885 = self._make_value_string(msg.encoding) - result.append(("csv_encoding", _t1885,)) - _t1886 = self._make_value_string(msg.compression) - result.append(("csv_compression", _t1886,)) + _t1894 = self._make_value_string(missing_string) + result.append(("csv_missing_strings", _t1894,)) + _t1895 = self._make_value_string(msg.decimal_separator) + result.append(("csv_decimal_separator", _t1895,)) + _t1896 = self._make_value_string(msg.encoding) + result.append(("csv_encoding", _t1896,)) + _t1897 = self._make_value_string(msg.compression) + result.append(("csv_compression", _t1897,)) if msg.partition_size_mb != 0: - _t1887 = self._make_value_int64(msg.partition_size_mb) - result.append(("csv_partition_size_mb", _t1887,)) + _t1898 = self._make_value_int64(msg.partition_size_mb) + result.append(("csv_partition_size_mb", _t1898,)) return sorted(result) def deconstruct_csv_storage_integration_optional(self, msg: logic_pb2.CSVConfig) -> Sequence[tuple[str, logic_pb2.Value]] | None: if not msg.HasField("storage_integration"): return None else: - _t1888 = None + _t1899 = None assert msg.storage_integration is not None si = msg.storage_integration result = [] if si.provider != "": - _t1889 = self._make_value_string(si.provider) - result.append(("provider", _t1889,)) + _t1900 = self._make_value_string(si.provider) + result.append(("provider", _t1900,)) if si.azure_sas_token != "": - _t1890 = self._make_value_string("***") - result.append(("azure_sas_token", _t1890,)) + _t1901 = self._make_value_string("***") + result.append(("azure_sas_token", _t1901,)) if si.s3_region != "": - _t1891 = self._make_value_string(si.s3_region) - result.append(("s3_region", _t1891,)) + _t1902 = self._make_value_string(si.s3_region) + result.append(("s3_region", _t1902,)) if si.s3_access_key_id != "": - _t1892 = self._make_value_string("***") - result.append(("s3_access_key_id", _t1892,)) + _t1903 = self._make_value_string("***") + result.append(("s3_access_key_id", _t1903,)) if si.s3_secret_access_key != "": - _t1893 = self._make_value_string("***") - result.append(("s3_secret_access_key", _t1893,)) + _t1904 = self._make_value_string("***") + result.append(("s3_secret_access_key", _t1904,)) return sorted(result) def deconstruct_betree_info_config(self, msg: logic_pb2.BeTreeInfo) -> list[tuple[str, logic_pb2.Value]]: result = [] - _t1894 = self._make_value_float64(msg.storage_config.epsilon) - result.append(("betree_config_epsilon", _t1894,)) - _t1895 = self._make_value_int64(msg.storage_config.max_pivots) - result.append(("betree_config_max_pivots", _t1895,)) - _t1896 = self._make_value_int64(msg.storage_config.max_deltas) - result.append(("betree_config_max_deltas", _t1896,)) - _t1897 = self._make_value_int64(msg.storage_config.max_leaf) - result.append(("betree_config_max_leaf", _t1897,)) + _t1905 = self._make_value_float64(msg.storage_config.epsilon) + result.append(("betree_config_epsilon", _t1905,)) + _t1906 = self._make_value_int64(msg.storage_config.max_pivots) + result.append(("betree_config_max_pivots", _t1906,)) + _t1907 = self._make_value_int64(msg.storage_config.max_deltas) + result.append(("betree_config_max_deltas", _t1907,)) + _t1908 = self._make_value_int64(msg.storage_config.max_leaf) + result.append(("betree_config_max_leaf", _t1908,)) 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 - _t1898 = self._make_value_uint128(msg.relation_locator.root_pageid) - result.append(("betree_locator_root_pageid", _t1898,)) + _t1909 = self._make_value_uint128(msg.relation_locator.root_pageid) + result.append(("betree_locator_root_pageid", _t1909,)) 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 - _t1899 = self._make_value_string(msg.relation_locator.inline_data.decode('utf-8')) - result.append(("betree_locator_inline_data", _t1899,)) - _t1900 = self._make_value_int64(msg.relation_locator.element_count) - result.append(("betree_locator_element_count", _t1900,)) - _t1901 = self._make_value_int64(msg.relation_locator.tree_height) - result.append(("betree_locator_tree_height", _t1901,)) + _t1910 = self._make_value_string(msg.relation_locator.inline_data.decode('utf-8')) + result.append(("betree_locator_inline_data", _t1910,)) + _t1911 = self._make_value_int64(msg.relation_locator.element_count) + result.append(("betree_locator_element_count", _t1911,)) + _t1912 = self._make_value_int64(msg.relation_locator.tree_height) + result.append(("betree_locator_tree_height", _t1912,)) 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 - _t1902 = self._make_value_int64(msg.partition_size) - result.append(("partition_size", _t1902,)) + _t1913 = self._make_value_int64(msg.partition_size) + result.append(("partition_size", _t1913,)) if msg.compression is not None: assert msg.compression is not None - _t1903 = self._make_value_string(msg.compression) - result.append(("compression", _t1903,)) + _t1914 = self._make_value_string(msg.compression) + result.append(("compression", _t1914,)) if msg.syntax_header_row is not None: assert msg.syntax_header_row is not None - _t1904 = self._make_value_boolean(msg.syntax_header_row) - result.append(("syntax_header_row", _t1904,)) + _t1915 = self._make_value_boolean(msg.syntax_header_row) + result.append(("syntax_header_row", _t1915,)) if msg.syntax_missing_string is not None: assert msg.syntax_missing_string is not None - _t1905 = self._make_value_string(msg.syntax_missing_string) - result.append(("syntax_missing_string", _t1905,)) + _t1916 = self._make_value_string(msg.syntax_missing_string) + result.append(("syntax_missing_string", _t1916,)) if msg.syntax_delim is not None: assert msg.syntax_delim is not None - _t1906 = self._make_value_string(msg.syntax_delim) - result.append(("syntax_delim", _t1906,)) + _t1917 = self._make_value_string(msg.syntax_delim) + result.append(("syntax_delim", _t1917,)) if msg.syntax_quotechar is not None: assert msg.syntax_quotechar is not None - _t1907 = self._make_value_string(msg.syntax_quotechar) - result.append(("syntax_quotechar", _t1907,)) + _t1918 = self._make_value_string(msg.syntax_quotechar) + result.append(("syntax_quotechar", _t1918,)) if msg.syntax_escapechar is not None: assert msg.syntax_escapechar is not None - _t1908 = self._make_value_string(msg.syntax_escapechar) - result.append(("syntax_escapechar", _t1908,)) + _t1919 = self._make_value_string(msg.syntax_escapechar) + result.append(("syntax_escapechar", _t1919,)) return sorted(result) def mask_secret_value(self, pair: tuple[str, str]) -> str: @@ -412,7 +412,7 @@ def deconstruct_iceberg_catalog_config_scope_optional(self, msg: logic_pb2.Icebe assert msg.scope is not None return msg.scope else: - _t1909 = None + _t1920 = None return None def deconstruct_iceberg_data_from_snapshot_optional(self, msg: logic_pb2.IcebergData) -> str | None: @@ -421,7 +421,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: - _t1910 = None + _t1921 = None return None def deconstruct_iceberg_data_to_snapshot_optional(self, msg: logic_pb2.IcebergData) -> str | None: @@ -430,7 +430,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: - _t1911 = None + _t1922 = None return None def deconstruct_export_iceberg_config_optional(self, msg: transactions_pb2.ExportIcebergConfig) -> Sequence[tuple[str, logic_pb2.Value]] | None: @@ -438,20 +438,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 - _t1912 = self._make_value_string(msg.prefix) - result.append(("prefix", _t1912,)) + _t1923 = self._make_value_string(msg.prefix) + result.append(("prefix", _t1923,)) 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 - _t1913 = self._make_value_int64(msg.target_file_size_bytes) - result.append(("target_file_size_bytes", _t1913,)) + _t1924 = self._make_value_int64(msg.target_file_size_bytes) + result.append(("target_file_size_bytes", _t1924,)) if msg.compression != "": - _t1914 = self._make_value_string(msg.compression) - result.append(("compression", _t1914,)) + _t1925 = self._make_value_string(msg.compression) + result.append(("compression", _t1925,)) if len(result) == 0: return None else: - _t1915 = None + _t1926 = None return sorted(result) def deconstruct_relation_id_string(self, msg: logic_pb2.RelationId) -> str: @@ -464,7 +464,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: - _t1916 = None + _t1927 = None return None def deconstruct_bindings(self, abs: logic_pb2.Abstraction) -> tuple[Sequence[logic_pb2.Binding], Sequence[logic_pb2.Binding]]: @@ -479,3186 +479,3215 @@ def deconstruct_bindings_with_arity(self, abs: logic_pb2.Abstraction, value_arit # --- Pretty-print methods --- def pretty_transaction(self, msg: transactions_pb2.Transaction): - flat863 = self._try_flat(msg, self.pretty_transaction) - if flat863 is not None: - assert flat863 is not None - self.write(flat863) + flat868 = self._try_flat(msg, self.pretty_transaction) + if flat868 is not None: + assert flat868 is not None + self.write(flat868) return None else: _dollar_dollar = msg if _dollar_dollar.HasField("configure"): - _t1708 = _dollar_dollar.configure + _t1718 = _dollar_dollar.configure else: - _t1708 = None + _t1718 = None if _dollar_dollar.HasField("sync"): - _t1709 = _dollar_dollar.sync + _t1719 = _dollar_dollar.sync else: - _t1709 = None - fields854 = (_t1708, _t1709, _dollar_dollar.epochs,) - assert fields854 is not None - unwrapped_fields855 = fields854 + _t1719 = None + fields859 = (_t1718, _t1719, _dollar_dollar.epochs,) + assert fields859 is not None + unwrapped_fields860 = fields859 self.write("(transaction") self.indent_sexp() - field856 = unwrapped_fields855[0] - if field856 is not None: + field861 = unwrapped_fields860[0] + if field861 is not None: self.newline() - assert field856 is not None - opt_val857 = field856 - self.pretty_configure(opt_val857) - field858 = unwrapped_fields855[1] - if field858 is not None: + assert field861 is not None + opt_val862 = field861 + self.pretty_configure(opt_val862) + field863 = unwrapped_fields860[1] + if field863 is not None: self.newline() - assert field858 is not None - opt_val859 = field858 - self.pretty_sync(opt_val859) - field860 = unwrapped_fields855[2] - if not len(field860) == 0: + assert field863 is not None + opt_val864 = field863 + self.pretty_sync(opt_val864) + field865 = unwrapped_fields860[2] + if not len(field865) == 0: self.newline() - for i862, elem861 in enumerate(field860): - if (i862 > 0): + for i867, elem866 in enumerate(field865): + if (i867 > 0): self.newline() - self.pretty_epoch(elem861) + self.pretty_epoch(elem866) self.dedent() self.write(")") def pretty_configure(self, msg: transactions_pb2.Configure): - flat866 = self._try_flat(msg, self.pretty_configure) - if flat866 is not None: - assert flat866 is not None - self.write(flat866) + flat871 = self._try_flat(msg, self.pretty_configure) + if flat871 is not None: + assert flat871 is not None + self.write(flat871) return None else: _dollar_dollar = msg - _t1710 = self.deconstruct_configure(_dollar_dollar) - fields864 = _t1710 - assert fields864 is not None - unwrapped_fields865 = fields864 + _t1720 = self.deconstruct_configure(_dollar_dollar) + fields869 = _t1720 + assert fields869 is not None + unwrapped_fields870 = fields869 self.write("(configure") self.indent_sexp() self.newline() - self.pretty_config_dict(unwrapped_fields865) + self.pretty_config_dict(unwrapped_fields870) self.dedent() self.write(")") def pretty_config_dict(self, msg: Sequence[tuple[str, logic_pb2.Value]]): - flat870 = self._try_flat(msg, self.pretty_config_dict) - if flat870 is not None: - assert flat870 is not None - self.write(flat870) + flat875 = self._try_flat(msg, self.pretty_config_dict) + if flat875 is not None: + assert flat875 is not None + self.write(flat875) return None else: - fields867 = msg + fields872 = msg self.write("{") self.indent() - if not len(fields867) == 0: + if not len(fields872) == 0: self.newline() - for i869, elem868 in enumerate(fields867): - if (i869 > 0): + for i874, elem873 in enumerate(fields872): + if (i874 > 0): self.newline() - self.pretty_config_key_value(elem868) + self.pretty_config_key_value(elem873) self.dedent() self.write("}") def pretty_config_key_value(self, msg: tuple[str, logic_pb2.Value]): - flat875 = self._try_flat(msg, self.pretty_config_key_value) - if flat875 is not None: - assert flat875 is not None - self.write(flat875) + flat880 = self._try_flat(msg, self.pretty_config_key_value) + if flat880 is not None: + assert flat880 is not None + self.write(flat880) return None else: _dollar_dollar = msg - fields871 = (_dollar_dollar[0], _dollar_dollar[1],) - assert fields871 is not None - unwrapped_fields872 = fields871 + fields876 = (_dollar_dollar[0], _dollar_dollar[1],) + assert fields876 is not None + unwrapped_fields877 = fields876 self.write(":") - field873 = unwrapped_fields872[0] - self.write(field873) + field878 = unwrapped_fields877[0] + self.write(field878) self.write(" ") - field874 = unwrapped_fields872[1] - self.pretty_raw_value(field874) + field879 = unwrapped_fields877[1] + self.pretty_raw_value(field879) def pretty_raw_value(self, msg: logic_pb2.Value): - flat901 = self._try_flat(msg, self.pretty_raw_value) - if flat901 is not None: - assert flat901 is not None - self.write(flat901) + flat906 = self._try_flat(msg, self.pretty_raw_value) + if flat906 is not None: + assert flat906 is not None + self.write(flat906) return None else: _dollar_dollar = msg if _dollar_dollar.HasField("date_value"): - _t1711 = _dollar_dollar.date_value + _t1721 = _dollar_dollar.date_value else: - _t1711 = None - deconstruct_result899 = _t1711 - if deconstruct_result899 is not None: - assert deconstruct_result899 is not None - unwrapped900 = deconstruct_result899 - self.pretty_raw_date(unwrapped900) + _t1721 = None + deconstruct_result904 = _t1721 + if deconstruct_result904 is not None: + assert deconstruct_result904 is not None + unwrapped905 = deconstruct_result904 + self.pretty_raw_date(unwrapped905) else: _dollar_dollar = msg if _dollar_dollar.HasField("datetime_value"): - _t1712 = _dollar_dollar.datetime_value + _t1722 = _dollar_dollar.datetime_value else: - _t1712 = None - deconstruct_result897 = _t1712 - if deconstruct_result897 is not None: - assert deconstruct_result897 is not None - unwrapped898 = deconstruct_result897 - self.pretty_raw_datetime(unwrapped898) + _t1722 = None + deconstruct_result902 = _t1722 + if deconstruct_result902 is not None: + assert deconstruct_result902 is not None + unwrapped903 = deconstruct_result902 + self.pretty_raw_datetime(unwrapped903) else: _dollar_dollar = msg if _dollar_dollar.HasField("string_value"): - _t1713 = _dollar_dollar.string_value + _t1723 = _dollar_dollar.string_value else: - _t1713 = None - deconstruct_result895 = _t1713 - if deconstruct_result895 is not None: - assert deconstruct_result895 is not None - unwrapped896 = deconstruct_result895 - self.write(self.format_string_value(unwrapped896)) + _t1723 = None + deconstruct_result900 = _t1723 + if deconstruct_result900 is not None: + assert deconstruct_result900 is not None + unwrapped901 = deconstruct_result900 + self.write(self.format_string_value(unwrapped901)) else: _dollar_dollar = msg if _dollar_dollar.HasField("int32_value"): - _t1714 = _dollar_dollar.int32_value + _t1724 = _dollar_dollar.int32_value else: - _t1714 = None - deconstruct_result893 = _t1714 - if deconstruct_result893 is not None: - assert deconstruct_result893 is not None - unwrapped894 = deconstruct_result893 - self.write((str(unwrapped894) + 'i32')) + _t1724 = None + deconstruct_result898 = _t1724 + if deconstruct_result898 is not None: + assert deconstruct_result898 is not None + unwrapped899 = deconstruct_result898 + self.write((str(unwrapped899) + 'i32')) else: _dollar_dollar = msg if _dollar_dollar.HasField("int_value"): - _t1715 = _dollar_dollar.int_value + _t1725 = _dollar_dollar.int_value else: - _t1715 = None - deconstruct_result891 = _t1715 - if deconstruct_result891 is not None: - assert deconstruct_result891 is not None - unwrapped892 = deconstruct_result891 - self.write(str(unwrapped892)) + _t1725 = None + deconstruct_result896 = _t1725 + if deconstruct_result896 is not None: + assert deconstruct_result896 is not None + unwrapped897 = deconstruct_result896 + self.write(str(unwrapped897)) else: _dollar_dollar = msg if _dollar_dollar.HasField("float32_value"): - _t1716 = _dollar_dollar.float32_value + _t1726 = _dollar_dollar.float32_value else: - _t1716 = None - deconstruct_result889 = _t1716 - if deconstruct_result889 is not None: - assert deconstruct_result889 is not None - unwrapped890 = deconstruct_result889 - self.write(self.format_float32_literal(unwrapped890)) + _t1726 = None + deconstruct_result894 = _t1726 + if deconstruct_result894 is not None: + assert deconstruct_result894 is not None + unwrapped895 = deconstruct_result894 + self.write(self.format_float32_literal(unwrapped895)) else: _dollar_dollar = msg if _dollar_dollar.HasField("float_value"): - _t1717 = _dollar_dollar.float_value + _t1727 = _dollar_dollar.float_value else: - _t1717 = None - deconstruct_result887 = _t1717 - if deconstruct_result887 is not None: - assert deconstruct_result887 is not None - unwrapped888 = deconstruct_result887 - self.write(str(unwrapped888)) + _t1727 = None + deconstruct_result892 = _t1727 + if deconstruct_result892 is not None: + assert deconstruct_result892 is not None + unwrapped893 = deconstruct_result892 + self.write(str(unwrapped893)) else: _dollar_dollar = msg if _dollar_dollar.HasField("uint32_value"): - _t1718 = _dollar_dollar.uint32_value + _t1728 = _dollar_dollar.uint32_value else: - _t1718 = None - deconstruct_result885 = _t1718 - if deconstruct_result885 is not None: - assert deconstruct_result885 is not None - unwrapped886 = deconstruct_result885 - self.write((str(unwrapped886) + 'u32')) + _t1728 = None + deconstruct_result890 = _t1728 + if deconstruct_result890 is not None: + assert deconstruct_result890 is not None + unwrapped891 = deconstruct_result890 + self.write((str(unwrapped891) + 'u32')) else: _dollar_dollar = msg if _dollar_dollar.HasField("uint128_value"): - _t1719 = _dollar_dollar.uint128_value + _t1729 = _dollar_dollar.uint128_value else: - _t1719 = None - deconstruct_result883 = _t1719 - if deconstruct_result883 is not None: - assert deconstruct_result883 is not None - unwrapped884 = deconstruct_result883 - self.write(self.format_uint128(unwrapped884)) + _t1729 = None + deconstruct_result888 = _t1729 + if deconstruct_result888 is not None: + assert deconstruct_result888 is not None + unwrapped889 = deconstruct_result888 + self.write(self.format_uint128(unwrapped889)) else: _dollar_dollar = msg if _dollar_dollar.HasField("int128_value"): - _t1720 = _dollar_dollar.int128_value + _t1730 = _dollar_dollar.int128_value else: - _t1720 = None - deconstruct_result881 = _t1720 - if deconstruct_result881 is not None: - assert deconstruct_result881 is not None - unwrapped882 = deconstruct_result881 - self.write(self.format_int128(unwrapped882)) + _t1730 = None + deconstruct_result886 = _t1730 + if deconstruct_result886 is not None: + assert deconstruct_result886 is not None + unwrapped887 = deconstruct_result886 + self.write(self.format_int128(unwrapped887)) else: _dollar_dollar = msg if _dollar_dollar.HasField("decimal_value"): - _t1721 = _dollar_dollar.decimal_value + _t1731 = _dollar_dollar.decimal_value else: - _t1721 = None - deconstruct_result879 = _t1721 - if deconstruct_result879 is not None: - assert deconstruct_result879 is not None - unwrapped880 = deconstruct_result879 - self.write(self.format_decimal(unwrapped880)) + _t1731 = None + deconstruct_result884 = _t1731 + if deconstruct_result884 is not None: + assert deconstruct_result884 is not None + unwrapped885 = deconstruct_result884 + self.write(self.format_decimal(unwrapped885)) else: _dollar_dollar = msg if _dollar_dollar.HasField("boolean_value"): - _t1722 = _dollar_dollar.boolean_value + _t1732 = _dollar_dollar.boolean_value else: - _t1722 = None - deconstruct_result877 = _t1722 - if deconstruct_result877 is not None: - assert deconstruct_result877 is not None - unwrapped878 = deconstruct_result877 - self.pretty_boolean_value(unwrapped878) + _t1732 = None + deconstruct_result882 = _t1732 + if deconstruct_result882 is not None: + assert deconstruct_result882 is not None + unwrapped883 = deconstruct_result882 + self.pretty_boolean_value(unwrapped883) else: - fields876 = msg + fields881 = msg self.write("missing") def pretty_raw_date(self, msg: logic_pb2.DateValue): - flat907 = self._try_flat(msg, self.pretty_raw_date) - if flat907 is not None: - assert flat907 is not None - self.write(flat907) + flat912 = self._try_flat(msg, self.pretty_raw_date) + if flat912 is not None: + assert flat912 is not None + self.write(flat912) return None else: _dollar_dollar = msg - fields902 = (int(_dollar_dollar.year), int(_dollar_dollar.month), int(_dollar_dollar.day),) - assert fields902 is not None - unwrapped_fields903 = fields902 + fields907 = (int(_dollar_dollar.year), int(_dollar_dollar.month), int(_dollar_dollar.day),) + assert fields907 is not None + unwrapped_fields908 = fields907 self.write("(date") self.indent_sexp() self.newline() - field904 = unwrapped_fields903[0] - self.write(str(field904)) + field909 = unwrapped_fields908[0] + self.write(str(field909)) self.newline() - field905 = unwrapped_fields903[1] - self.write(str(field905)) + field910 = unwrapped_fields908[1] + self.write(str(field910)) self.newline() - field906 = unwrapped_fields903[2] - self.write(str(field906)) + field911 = unwrapped_fields908[2] + self.write(str(field911)) self.dedent() self.write(")") def pretty_raw_datetime(self, msg: logic_pb2.DateTimeValue): - flat918 = self._try_flat(msg, self.pretty_raw_datetime) - if flat918 is not None: - assert flat918 is not None - self.write(flat918) + flat923 = self._try_flat(msg, self.pretty_raw_datetime) + if flat923 is not None: + assert flat923 is not None + self.write(flat923) return None else: _dollar_dollar = msg - fields908 = (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 fields908 is not None - unwrapped_fields909 = fields908 + fields913 = (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 fields913 is not None + unwrapped_fields914 = fields913 self.write("(datetime") self.indent_sexp() self.newline() - field910 = unwrapped_fields909[0] - self.write(str(field910)) + field915 = unwrapped_fields914[0] + self.write(str(field915)) self.newline() - field911 = unwrapped_fields909[1] - self.write(str(field911)) + field916 = unwrapped_fields914[1] + self.write(str(field916)) self.newline() - field912 = unwrapped_fields909[2] - self.write(str(field912)) + field917 = unwrapped_fields914[2] + self.write(str(field917)) self.newline() - field913 = unwrapped_fields909[3] - self.write(str(field913)) + field918 = unwrapped_fields914[3] + self.write(str(field918)) self.newline() - field914 = unwrapped_fields909[4] - self.write(str(field914)) + field919 = unwrapped_fields914[4] + self.write(str(field919)) self.newline() - field915 = unwrapped_fields909[5] - self.write(str(field915)) - field916 = unwrapped_fields909[6] - if field916 is not None: + field920 = unwrapped_fields914[5] + self.write(str(field920)) + field921 = unwrapped_fields914[6] + if field921 is not None: self.newline() - assert field916 is not None - opt_val917 = field916 - self.write(str(opt_val917)) + assert field921 is not None + opt_val922 = field921 + self.write(str(opt_val922)) self.dedent() self.write(")") def pretty_boolean_value(self, msg: bool): _dollar_dollar = msg if _dollar_dollar: - _t1723 = () + _t1733 = () else: - _t1723 = None - deconstruct_result921 = _t1723 - if deconstruct_result921 is not None: - assert deconstruct_result921 is not None - unwrapped922 = deconstruct_result921 + _t1733 = None + deconstruct_result926 = _t1733 + if deconstruct_result926 is not None: + assert deconstruct_result926 is not None + unwrapped927 = deconstruct_result926 self.write("true") else: _dollar_dollar = msg if not _dollar_dollar: - _t1724 = () + _t1734 = () else: - _t1724 = None - deconstruct_result919 = _t1724 - if deconstruct_result919 is not None: - assert deconstruct_result919 is not None - unwrapped920 = deconstruct_result919 + _t1734 = None + deconstruct_result924 = _t1734 + if deconstruct_result924 is not None: + assert deconstruct_result924 is not None + unwrapped925 = deconstruct_result924 self.write("false") else: raise ParseError("No matching rule for boolean_value") def pretty_sync(self, msg: transactions_pb2.Sync): - flat927 = self._try_flat(msg, self.pretty_sync) - if flat927 is not None: - assert flat927 is not None - self.write(flat927) + flat932 = self._try_flat(msg, self.pretty_sync) + if flat932 is not None: + assert flat932 is not None + self.write(flat932) return None else: _dollar_dollar = msg - fields923 = _dollar_dollar.fragments - assert fields923 is not None - unwrapped_fields924 = fields923 + fields928 = _dollar_dollar.fragments + assert fields928 is not None + unwrapped_fields929 = fields928 self.write("(sync") self.indent_sexp() - if not len(unwrapped_fields924) == 0: + if not len(unwrapped_fields929) == 0: self.newline() - for i926, elem925 in enumerate(unwrapped_fields924): - if (i926 > 0): + for i931, elem930 in enumerate(unwrapped_fields929): + if (i931 > 0): self.newline() - self.pretty_fragment_id(elem925) + self.pretty_fragment_id(elem930) self.dedent() self.write(")") def pretty_fragment_id(self, msg: fragments_pb2.FragmentId): - flat930 = self._try_flat(msg, self.pretty_fragment_id) - if flat930 is not None: - assert flat930 is not None - self.write(flat930) + flat935 = self._try_flat(msg, self.pretty_fragment_id) + if flat935 is not None: + assert flat935 is not None + self.write(flat935) return None else: _dollar_dollar = msg - fields928 = self.fragment_id_to_string(_dollar_dollar) - assert fields928 is not None - unwrapped_fields929 = fields928 + fields933 = self.fragment_id_to_string(_dollar_dollar) + assert fields933 is not None + unwrapped_fields934 = fields933 self.write(":") - self.write(unwrapped_fields929) + self.write(unwrapped_fields934) def pretty_epoch(self, msg: transactions_pb2.Epoch): - flat937 = self._try_flat(msg, self.pretty_epoch) - if flat937 is not None: - assert flat937 is not None - self.write(flat937) + flat942 = self._try_flat(msg, self.pretty_epoch) + if flat942 is not None: + assert flat942 is not None + self.write(flat942) return None else: _dollar_dollar = msg if not len(_dollar_dollar.writes) == 0: - _t1725 = _dollar_dollar.writes + _t1735 = _dollar_dollar.writes else: - _t1725 = None + _t1735 = None if not len(_dollar_dollar.reads) == 0: - _t1726 = _dollar_dollar.reads + _t1736 = _dollar_dollar.reads else: - _t1726 = None - fields931 = (_t1725, _t1726,) - assert fields931 is not None - unwrapped_fields932 = fields931 + _t1736 = None + fields936 = (_t1735, _t1736,) + assert fields936 is not None + unwrapped_fields937 = fields936 self.write("(epoch") self.indent_sexp() - field933 = unwrapped_fields932[0] - if field933 is not None: + field938 = unwrapped_fields937[0] + if field938 is not None: self.newline() - assert field933 is not None - opt_val934 = field933 - self.pretty_epoch_writes(opt_val934) - field935 = unwrapped_fields932[1] - if field935 is not None: + assert field938 is not None + opt_val939 = field938 + self.pretty_epoch_writes(opt_val939) + field940 = unwrapped_fields937[1] + if field940 is not None: self.newline() - assert field935 is not None - opt_val936 = field935 - self.pretty_epoch_reads(opt_val936) + assert field940 is not None + opt_val941 = field940 + self.pretty_epoch_reads(opt_val941) self.dedent() self.write(")") def pretty_epoch_writes(self, msg: Sequence[transactions_pb2.Write]): - flat941 = self._try_flat(msg, self.pretty_epoch_writes) - if flat941 is not None: - assert flat941 is not None - self.write(flat941) + flat946 = self._try_flat(msg, self.pretty_epoch_writes) + if flat946 is not None: + assert flat946 is not None + self.write(flat946) return None else: - fields938 = msg + fields943 = msg self.write("(writes") self.indent_sexp() - if not len(fields938) == 0: + if not len(fields943) == 0: self.newline() - for i940, elem939 in enumerate(fields938): - if (i940 > 0): + for i945, elem944 in enumerate(fields943): + if (i945 > 0): self.newline() - self.pretty_write(elem939) + self.pretty_write(elem944) self.dedent() self.write(")") def pretty_write(self, msg: transactions_pb2.Write): - flat950 = self._try_flat(msg, self.pretty_write) - if flat950 is not None: - assert flat950 is not None - self.write(flat950) + flat955 = self._try_flat(msg, self.pretty_write) + if flat955 is not None: + assert flat955 is not None + self.write(flat955) return None else: _dollar_dollar = msg if _dollar_dollar.HasField("define"): - _t1727 = _dollar_dollar.define + _t1737 = _dollar_dollar.define else: - _t1727 = None - deconstruct_result948 = _t1727 - if deconstruct_result948 is not None: - assert deconstruct_result948 is not None - unwrapped949 = deconstruct_result948 - self.pretty_define(unwrapped949) + _t1737 = None + deconstruct_result953 = _t1737 + if deconstruct_result953 is not None: + assert deconstruct_result953 is not None + unwrapped954 = deconstruct_result953 + self.pretty_define(unwrapped954) else: _dollar_dollar = msg if _dollar_dollar.HasField("undefine"): - _t1728 = _dollar_dollar.undefine + _t1738 = _dollar_dollar.undefine else: - _t1728 = None - deconstruct_result946 = _t1728 - if deconstruct_result946 is not None: - assert deconstruct_result946 is not None - unwrapped947 = deconstruct_result946 - self.pretty_undefine(unwrapped947) + _t1738 = None + deconstruct_result951 = _t1738 + if deconstruct_result951 is not None: + assert deconstruct_result951 is not None + unwrapped952 = deconstruct_result951 + self.pretty_undefine(unwrapped952) else: _dollar_dollar = msg if _dollar_dollar.HasField("context"): - _t1729 = _dollar_dollar.context + _t1739 = _dollar_dollar.context else: - _t1729 = None - deconstruct_result944 = _t1729 - if deconstruct_result944 is not None: - assert deconstruct_result944 is not None - unwrapped945 = deconstruct_result944 - self.pretty_context(unwrapped945) + _t1739 = None + deconstruct_result949 = _t1739 + if deconstruct_result949 is not None: + assert deconstruct_result949 is not None + unwrapped950 = deconstruct_result949 + self.pretty_context(unwrapped950) else: _dollar_dollar = msg if _dollar_dollar.HasField("snapshot"): - _t1730 = _dollar_dollar.snapshot + _t1740 = _dollar_dollar.snapshot else: - _t1730 = None - deconstruct_result942 = _t1730 - if deconstruct_result942 is not None: - assert deconstruct_result942 is not None - unwrapped943 = deconstruct_result942 - self.pretty_snapshot(unwrapped943) + _t1740 = None + deconstruct_result947 = _t1740 + if deconstruct_result947 is not None: + assert deconstruct_result947 is not None + unwrapped948 = deconstruct_result947 + self.pretty_snapshot(unwrapped948) else: raise ParseError("No matching rule for write") def pretty_define(self, msg: transactions_pb2.Define): - flat953 = self._try_flat(msg, self.pretty_define) - if flat953 is not None: - assert flat953 is not None - self.write(flat953) + flat958 = self._try_flat(msg, self.pretty_define) + if flat958 is not None: + assert flat958 is not None + self.write(flat958) return None else: _dollar_dollar = msg - fields951 = _dollar_dollar.fragment - assert fields951 is not None - unwrapped_fields952 = fields951 + fields956 = _dollar_dollar.fragment + assert fields956 is not None + unwrapped_fields957 = fields956 self.write("(define") self.indent_sexp() self.newline() - self.pretty_fragment(unwrapped_fields952) + self.pretty_fragment(unwrapped_fields957) self.dedent() self.write(")") def pretty_fragment(self, msg: fragments_pb2.Fragment): - flat960 = self._try_flat(msg, self.pretty_fragment) - if flat960 is not None: - assert flat960 is not None - self.write(flat960) + flat965 = self._try_flat(msg, self.pretty_fragment) + if flat965 is not None: + assert flat965 is not None + self.write(flat965) return None else: _dollar_dollar = msg self.start_pretty_fragment(_dollar_dollar) - fields954 = (_dollar_dollar.id, _dollar_dollar.declarations,) - assert fields954 is not None - unwrapped_fields955 = fields954 + fields959 = (_dollar_dollar.id, _dollar_dollar.declarations,) + assert fields959 is not None + unwrapped_fields960 = fields959 self.write("(fragment") self.indent_sexp() self.newline() - field956 = unwrapped_fields955[0] - self.pretty_new_fragment_id(field956) - field957 = unwrapped_fields955[1] - if not len(field957) == 0: + field961 = unwrapped_fields960[0] + self.pretty_new_fragment_id(field961) + field962 = unwrapped_fields960[1] + if not len(field962) == 0: self.newline() - for i959, elem958 in enumerate(field957): - if (i959 > 0): + for i964, elem963 in enumerate(field962): + if (i964 > 0): self.newline() - self.pretty_declaration(elem958) + self.pretty_declaration(elem963) self.dedent() self.write(")") def pretty_new_fragment_id(self, msg: fragments_pb2.FragmentId): - flat962 = self._try_flat(msg, self.pretty_new_fragment_id) - if flat962 is not None: - assert flat962 is not None - self.write(flat962) + flat967 = self._try_flat(msg, self.pretty_new_fragment_id) + if flat967 is not None: + assert flat967 is not None + self.write(flat967) return None else: - fields961 = msg - self.pretty_fragment_id(fields961) + fields966 = msg + self.pretty_fragment_id(fields966) def pretty_declaration(self, msg: logic_pb2.Declaration): - flat971 = self._try_flat(msg, self.pretty_declaration) - if flat971 is not None: - assert flat971 is not None - self.write(flat971) + flat976 = self._try_flat(msg, self.pretty_declaration) + if flat976 is not None: + assert flat976 is not None + self.write(flat976) return None else: _dollar_dollar = msg if _dollar_dollar.HasField("def"): - _t1731 = getattr(_dollar_dollar, 'def') + _t1741 = getattr(_dollar_dollar, 'def') else: - _t1731 = None - deconstruct_result969 = _t1731 - if deconstruct_result969 is not None: - assert deconstruct_result969 is not None - unwrapped970 = deconstruct_result969 - self.pretty_def(unwrapped970) + _t1741 = None + deconstruct_result974 = _t1741 + if deconstruct_result974 is not None: + assert deconstruct_result974 is not None + unwrapped975 = deconstruct_result974 + self.pretty_def(unwrapped975) else: _dollar_dollar = msg if _dollar_dollar.HasField("algorithm"): - _t1732 = _dollar_dollar.algorithm + _t1742 = _dollar_dollar.algorithm else: - _t1732 = None - deconstruct_result967 = _t1732 - if deconstruct_result967 is not None: - assert deconstruct_result967 is not None - unwrapped968 = deconstruct_result967 - self.pretty_algorithm(unwrapped968) + _t1742 = None + deconstruct_result972 = _t1742 + if deconstruct_result972 is not None: + assert deconstruct_result972 is not None + unwrapped973 = deconstruct_result972 + self.pretty_algorithm(unwrapped973) else: _dollar_dollar = msg if _dollar_dollar.HasField("constraint"): - _t1733 = _dollar_dollar.constraint + _t1743 = _dollar_dollar.constraint else: - _t1733 = None - deconstruct_result965 = _t1733 - if deconstruct_result965 is not None: - assert deconstruct_result965 is not None - unwrapped966 = deconstruct_result965 - self.pretty_constraint(unwrapped966) + _t1743 = None + deconstruct_result970 = _t1743 + if deconstruct_result970 is not None: + assert deconstruct_result970 is not None + unwrapped971 = deconstruct_result970 + self.pretty_constraint(unwrapped971) else: _dollar_dollar = msg if _dollar_dollar.HasField("data"): - _t1734 = _dollar_dollar.data + _t1744 = _dollar_dollar.data else: - _t1734 = None - deconstruct_result963 = _t1734 - if deconstruct_result963 is not None: - assert deconstruct_result963 is not None - unwrapped964 = deconstruct_result963 - self.pretty_data(unwrapped964) + _t1744 = None + deconstruct_result968 = _t1744 + if deconstruct_result968 is not None: + assert deconstruct_result968 is not None + unwrapped969 = deconstruct_result968 + self.pretty_data(unwrapped969) else: raise ParseError("No matching rule for declaration") def pretty_def(self, msg: logic_pb2.Def): - flat978 = self._try_flat(msg, self.pretty_def) - if flat978 is not None: - assert flat978 is not None - self.write(flat978) + flat983 = self._try_flat(msg, self.pretty_def) + if flat983 is not None: + assert flat983 is not None + self.write(flat983) return None else: _dollar_dollar = msg if not len(_dollar_dollar.attrs) == 0: - _t1735 = _dollar_dollar.attrs + _t1745 = _dollar_dollar.attrs else: - _t1735 = None - fields972 = (_dollar_dollar.name, _dollar_dollar.body, _t1735,) - assert fields972 is not None - unwrapped_fields973 = fields972 + _t1745 = None + fields977 = (_dollar_dollar.name, _dollar_dollar.body, _t1745,) + assert fields977 is not None + unwrapped_fields978 = fields977 self.write("(def") self.indent_sexp() self.newline() - field974 = unwrapped_fields973[0] - self.pretty_relation_id(field974) + field979 = unwrapped_fields978[0] + self.pretty_relation_id(field979) self.newline() - field975 = unwrapped_fields973[1] - self.pretty_abstraction(field975) - field976 = unwrapped_fields973[2] - if field976 is not None: + field980 = unwrapped_fields978[1] + self.pretty_abstraction(field980) + field981 = unwrapped_fields978[2] + if field981 is not None: self.newline() - assert field976 is not None - opt_val977 = field976 - self.pretty_attrs(opt_val977) + assert field981 is not None + opt_val982 = field981 + self.pretty_attrs(opt_val982) self.dedent() self.write(")") def pretty_relation_id(self, msg: logic_pb2.RelationId): - flat983 = self._try_flat(msg, self.pretty_relation_id) - if flat983 is not None: - assert flat983 is not None - self.write(flat983) + flat988 = self._try_flat(msg, self.pretty_relation_id) + if flat988 is not None: + assert flat988 is not None + self.write(flat988) return None else: _dollar_dollar = msg if self.relation_id_to_string(_dollar_dollar) is not None: - _t1737 = self.deconstruct_relation_id_string(_dollar_dollar) - _t1736 = _t1737 + _t1747 = self.deconstruct_relation_id_string(_dollar_dollar) + _t1746 = _t1747 else: - _t1736 = None - deconstruct_result981 = _t1736 - if deconstruct_result981 is not None: - assert deconstruct_result981 is not None - unwrapped982 = deconstruct_result981 + _t1746 = None + deconstruct_result986 = _t1746 + if deconstruct_result986 is not None: + assert deconstruct_result986 is not None + unwrapped987 = deconstruct_result986 self.write(":") - self.write(unwrapped982) + self.write(unwrapped987) else: _dollar_dollar = msg - _t1738 = self.deconstruct_relation_id_uint128(_dollar_dollar) - deconstruct_result979 = _t1738 - if deconstruct_result979 is not None: - assert deconstruct_result979 is not None - unwrapped980 = deconstruct_result979 - self.write(self.format_uint128(unwrapped980)) + _t1748 = self.deconstruct_relation_id_uint128(_dollar_dollar) + deconstruct_result984 = _t1748 + if deconstruct_result984 is not None: + assert deconstruct_result984 is not None + unwrapped985 = deconstruct_result984 + self.write(self.format_uint128(unwrapped985)) else: raise ParseError("No matching rule for relation_id") def pretty_abstraction(self, msg: logic_pb2.Abstraction): - flat988 = self._try_flat(msg, self.pretty_abstraction) - if flat988 is not None: - assert flat988 is not None - self.write(flat988) + flat993 = self._try_flat(msg, self.pretty_abstraction) + if flat993 is not None: + assert flat993 is not None + self.write(flat993) return None else: _dollar_dollar = msg - _t1739 = self.deconstruct_bindings(_dollar_dollar) - fields984 = (_t1739, _dollar_dollar.value,) - assert fields984 is not None - unwrapped_fields985 = fields984 + _t1749 = self.deconstruct_bindings(_dollar_dollar) + fields989 = (_t1749, _dollar_dollar.value,) + assert fields989 is not None + unwrapped_fields990 = fields989 self.write("(") self.indent() - field986 = unwrapped_fields985[0] - self.pretty_bindings(field986) + field991 = unwrapped_fields990[0] + self.pretty_bindings(field991) self.newline() - field987 = unwrapped_fields985[1] - self.pretty_formula(field987) + field992 = unwrapped_fields990[1] + self.pretty_formula(field992) self.dedent() self.write(")") def pretty_bindings(self, msg: tuple[Sequence[logic_pb2.Binding], Sequence[logic_pb2.Binding]]): - flat996 = self._try_flat(msg, self.pretty_bindings) - if flat996 is not None: - assert flat996 is not None - self.write(flat996) + flat1001 = self._try_flat(msg, self.pretty_bindings) + if flat1001 is not None: + assert flat1001 is not None + self.write(flat1001) return None else: _dollar_dollar = msg if not len(_dollar_dollar[1]) == 0: - _t1740 = _dollar_dollar[1] + _t1750 = _dollar_dollar[1] else: - _t1740 = None - fields989 = (_dollar_dollar[0], _t1740,) - assert fields989 is not None - unwrapped_fields990 = fields989 + _t1750 = None + fields994 = (_dollar_dollar[0], _t1750,) + assert fields994 is not None + unwrapped_fields995 = fields994 self.write("[") self.indent() - field991 = unwrapped_fields990[0] - for i993, elem992 in enumerate(field991): - if (i993 > 0): + field996 = unwrapped_fields995[0] + for i998, elem997 in enumerate(field996): + if (i998 > 0): self.newline() - self.pretty_binding(elem992) - field994 = unwrapped_fields990[1] - if field994 is not None: + self.pretty_binding(elem997) + field999 = unwrapped_fields995[1] + if field999 is not None: self.newline() - assert field994 is not None - opt_val995 = field994 - self.pretty_value_bindings(opt_val995) + assert field999 is not None + opt_val1000 = field999 + self.pretty_value_bindings(opt_val1000) self.dedent() self.write("]") def pretty_binding(self, msg: logic_pb2.Binding): - flat1001 = self._try_flat(msg, self.pretty_binding) - if flat1001 is not None: - assert flat1001 is not None - self.write(flat1001) + flat1006 = self._try_flat(msg, self.pretty_binding) + if flat1006 is not None: + assert flat1006 is not None + self.write(flat1006) return None else: _dollar_dollar = msg - fields997 = (_dollar_dollar.var.name, _dollar_dollar.type,) - assert fields997 is not None - unwrapped_fields998 = fields997 - field999 = unwrapped_fields998[0] - self.write(field999) + fields1002 = (_dollar_dollar.var.name, _dollar_dollar.type,) + assert fields1002 is not None + unwrapped_fields1003 = fields1002 + field1004 = unwrapped_fields1003[0] + self.write(field1004) self.write("::") - field1000 = unwrapped_fields998[1] - self.pretty_type(field1000) + field1005 = unwrapped_fields1003[1] + self.pretty_type(field1005) def pretty_type(self, msg: logic_pb2.Type): - flat1030 = self._try_flat(msg, self.pretty_type) - if flat1030 is not None: - assert flat1030 is not None - self.write(flat1030) + flat1037 = self._try_flat(msg, self.pretty_type) + if flat1037 is not None: + assert flat1037 is not None + self.write(flat1037) return None else: _dollar_dollar = msg if _dollar_dollar.HasField("unspecified_type"): - _t1741 = _dollar_dollar.unspecified_type + _t1751 = _dollar_dollar.unspecified_type else: - _t1741 = None - deconstruct_result1028 = _t1741 - if deconstruct_result1028 is not None: - assert deconstruct_result1028 is not None - unwrapped1029 = deconstruct_result1028 - self.pretty_unspecified_type(unwrapped1029) + _t1751 = None + deconstruct_result1035 = _t1751 + if deconstruct_result1035 is not None: + assert deconstruct_result1035 is not None + unwrapped1036 = deconstruct_result1035 + self.pretty_unspecified_type(unwrapped1036) else: _dollar_dollar = msg if _dollar_dollar.HasField("string_type"): - _t1742 = _dollar_dollar.string_type + _t1752 = _dollar_dollar.string_type else: - _t1742 = None - deconstruct_result1026 = _t1742 - if deconstruct_result1026 is not None: - assert deconstruct_result1026 is not None - unwrapped1027 = deconstruct_result1026 - self.pretty_string_type(unwrapped1027) + _t1752 = None + deconstruct_result1033 = _t1752 + if deconstruct_result1033 is not None: + assert deconstruct_result1033 is not None + unwrapped1034 = deconstruct_result1033 + self.pretty_string_type(unwrapped1034) else: _dollar_dollar = msg if _dollar_dollar.HasField("int_type"): - _t1743 = _dollar_dollar.int_type + _t1753 = _dollar_dollar.int_type else: - _t1743 = None - deconstruct_result1024 = _t1743 - if deconstruct_result1024 is not None: - assert deconstruct_result1024 is not None - unwrapped1025 = deconstruct_result1024 - self.pretty_int_type(unwrapped1025) + _t1753 = None + deconstruct_result1031 = _t1753 + if deconstruct_result1031 is not None: + assert deconstruct_result1031 is not None + unwrapped1032 = deconstruct_result1031 + self.pretty_int_type(unwrapped1032) else: _dollar_dollar = msg if _dollar_dollar.HasField("float_type"): - _t1744 = _dollar_dollar.float_type + _t1754 = _dollar_dollar.float_type else: - _t1744 = None - deconstruct_result1022 = _t1744 - if deconstruct_result1022 is not None: - assert deconstruct_result1022 is not None - unwrapped1023 = deconstruct_result1022 - self.pretty_float_type(unwrapped1023) + _t1754 = None + deconstruct_result1029 = _t1754 + if deconstruct_result1029 is not None: + assert deconstruct_result1029 is not None + unwrapped1030 = deconstruct_result1029 + self.pretty_float_type(unwrapped1030) else: _dollar_dollar = msg if _dollar_dollar.HasField("uint128_type"): - _t1745 = _dollar_dollar.uint128_type + _t1755 = _dollar_dollar.uint128_type else: - _t1745 = None - deconstruct_result1020 = _t1745 - if deconstruct_result1020 is not None: - assert deconstruct_result1020 is not None - unwrapped1021 = deconstruct_result1020 - self.pretty_uint128_type(unwrapped1021) + _t1755 = None + deconstruct_result1027 = _t1755 + if deconstruct_result1027 is not None: + assert deconstruct_result1027 is not None + unwrapped1028 = deconstruct_result1027 + self.pretty_uint128_type(unwrapped1028) else: _dollar_dollar = msg if _dollar_dollar.HasField("int128_type"): - _t1746 = _dollar_dollar.int128_type + _t1756 = _dollar_dollar.int128_type else: - _t1746 = None - deconstruct_result1018 = _t1746 - if deconstruct_result1018 is not None: - assert deconstruct_result1018 is not None - unwrapped1019 = deconstruct_result1018 - self.pretty_int128_type(unwrapped1019) + _t1756 = None + deconstruct_result1025 = _t1756 + if deconstruct_result1025 is not None: + assert deconstruct_result1025 is not None + unwrapped1026 = deconstruct_result1025 + self.pretty_int128_type(unwrapped1026) else: _dollar_dollar = msg if _dollar_dollar.HasField("date_type"): - _t1747 = _dollar_dollar.date_type + _t1757 = _dollar_dollar.date_type else: - _t1747 = None - deconstruct_result1016 = _t1747 - if deconstruct_result1016 is not None: - assert deconstruct_result1016 is not None - unwrapped1017 = deconstruct_result1016 - self.pretty_date_type(unwrapped1017) + _t1757 = None + deconstruct_result1023 = _t1757 + if deconstruct_result1023 is not None: + assert deconstruct_result1023 is not None + unwrapped1024 = deconstruct_result1023 + self.pretty_date_type(unwrapped1024) else: _dollar_dollar = msg if _dollar_dollar.HasField("datetime_type"): - _t1748 = _dollar_dollar.datetime_type + _t1758 = _dollar_dollar.datetime_type else: - _t1748 = None - deconstruct_result1014 = _t1748 - if deconstruct_result1014 is not None: - assert deconstruct_result1014 is not None - unwrapped1015 = deconstruct_result1014 - self.pretty_datetime_type(unwrapped1015) + _t1758 = None + deconstruct_result1021 = _t1758 + if deconstruct_result1021 is not None: + assert deconstruct_result1021 is not None + unwrapped1022 = deconstruct_result1021 + self.pretty_datetime_type(unwrapped1022) else: _dollar_dollar = msg if _dollar_dollar.HasField("missing_type"): - _t1749 = _dollar_dollar.missing_type + _t1759 = _dollar_dollar.missing_type else: - _t1749 = None - deconstruct_result1012 = _t1749 - if deconstruct_result1012 is not None: - assert deconstruct_result1012 is not None - unwrapped1013 = deconstruct_result1012 - self.pretty_missing_type(unwrapped1013) + _t1759 = None + deconstruct_result1019 = _t1759 + if deconstruct_result1019 is not None: + assert deconstruct_result1019 is not None + unwrapped1020 = deconstruct_result1019 + self.pretty_missing_type(unwrapped1020) else: _dollar_dollar = msg if _dollar_dollar.HasField("decimal_type"): - _t1750 = _dollar_dollar.decimal_type + _t1760 = _dollar_dollar.decimal_type else: - _t1750 = None - deconstruct_result1010 = _t1750 - if deconstruct_result1010 is not None: - assert deconstruct_result1010 is not None - unwrapped1011 = deconstruct_result1010 - self.pretty_decimal_type(unwrapped1011) + _t1760 = None + deconstruct_result1017 = _t1760 + if deconstruct_result1017 is not None: + assert deconstruct_result1017 is not None + unwrapped1018 = deconstruct_result1017 + self.pretty_decimal_type(unwrapped1018) else: _dollar_dollar = msg if _dollar_dollar.HasField("boolean_type"): - _t1751 = _dollar_dollar.boolean_type + _t1761 = _dollar_dollar.boolean_type else: - _t1751 = None - deconstruct_result1008 = _t1751 - if deconstruct_result1008 is not None: - assert deconstruct_result1008 is not None - unwrapped1009 = deconstruct_result1008 - self.pretty_boolean_type(unwrapped1009) + _t1761 = None + deconstruct_result1015 = _t1761 + if deconstruct_result1015 is not None: + assert deconstruct_result1015 is not None + unwrapped1016 = deconstruct_result1015 + self.pretty_boolean_type(unwrapped1016) else: _dollar_dollar = msg if _dollar_dollar.HasField("int32_type"): - _t1752 = _dollar_dollar.int32_type + _t1762 = _dollar_dollar.int32_type else: - _t1752 = None - deconstruct_result1006 = _t1752 - if deconstruct_result1006 is not None: - assert deconstruct_result1006 is not None - unwrapped1007 = deconstruct_result1006 - self.pretty_int32_type(unwrapped1007) + _t1762 = None + deconstruct_result1013 = _t1762 + if deconstruct_result1013 is not None: + assert deconstruct_result1013 is not None + unwrapped1014 = deconstruct_result1013 + self.pretty_int32_type(unwrapped1014) else: _dollar_dollar = msg if _dollar_dollar.HasField("float32_type"): - _t1753 = _dollar_dollar.float32_type + _t1763 = _dollar_dollar.float32_type else: - _t1753 = None - deconstruct_result1004 = _t1753 - if deconstruct_result1004 is not None: - assert deconstruct_result1004 is not None - unwrapped1005 = deconstruct_result1004 - self.pretty_float32_type(unwrapped1005) + _t1763 = None + deconstruct_result1011 = _t1763 + if deconstruct_result1011 is not None: + assert deconstruct_result1011 is not None + unwrapped1012 = deconstruct_result1011 + self.pretty_float32_type(unwrapped1012) else: _dollar_dollar = msg if _dollar_dollar.HasField("uint32_type"): - _t1754 = _dollar_dollar.uint32_type + _t1764 = _dollar_dollar.uint32_type else: - _t1754 = None - deconstruct_result1002 = _t1754 - if deconstruct_result1002 is not None: - assert deconstruct_result1002 is not None - unwrapped1003 = deconstruct_result1002 - self.pretty_uint32_type(unwrapped1003) + _t1764 = None + deconstruct_result1009 = _t1764 + if deconstruct_result1009 is not None: + assert deconstruct_result1009 is not None + unwrapped1010 = deconstruct_result1009 + self.pretty_uint32_type(unwrapped1010) else: - raise ParseError("No matching rule for type") + _dollar_dollar = msg + if _dollar_dollar.HasField("fixed_type"): + _t1765 = _dollar_dollar.fixed_type + else: + _t1765 = None + deconstruct_result1007 = _t1765 + if deconstruct_result1007 is not None: + assert deconstruct_result1007 is not None + unwrapped1008 = deconstruct_result1007 + self.pretty_fixed_type(unwrapped1008) + else: + raise ParseError("No matching rule for type") def pretty_unspecified_type(self, msg: logic_pb2.UnspecifiedType): - fields1031 = msg + fields1038 = msg self.write("UNKNOWN") def pretty_string_type(self, msg: logic_pb2.StringType): - fields1032 = msg + fields1039 = msg self.write("STRING") def pretty_int_type(self, msg: logic_pb2.IntType): - fields1033 = msg + fields1040 = msg self.write("INT") def pretty_float_type(self, msg: logic_pb2.FloatType): - fields1034 = msg + fields1041 = msg self.write("FLOAT") def pretty_uint128_type(self, msg: logic_pb2.UInt128Type): - fields1035 = msg + fields1042 = msg self.write("UINT128") def pretty_int128_type(self, msg: logic_pb2.Int128Type): - fields1036 = msg + fields1043 = msg self.write("INT128") def pretty_date_type(self, msg: logic_pb2.DateType): - fields1037 = msg + fields1044 = msg self.write("DATE") def pretty_datetime_type(self, msg: logic_pb2.DateTimeType): - fields1038 = msg + fields1045 = msg self.write("DATETIME") def pretty_missing_type(self, msg: logic_pb2.MissingType): - fields1039 = msg + fields1046 = msg self.write("MISSING") def pretty_decimal_type(self, msg: logic_pb2.DecimalType): - flat1044 = self._try_flat(msg, self.pretty_decimal_type) - if flat1044 is not None: - assert flat1044 is not None - self.write(flat1044) + flat1051 = self._try_flat(msg, self.pretty_decimal_type) + if flat1051 is not None: + assert flat1051 is not None + self.write(flat1051) return None else: _dollar_dollar = msg - fields1040 = (int(_dollar_dollar.precision), int(_dollar_dollar.scale),) - assert fields1040 is not None - unwrapped_fields1041 = fields1040 + fields1047 = (int(_dollar_dollar.precision), int(_dollar_dollar.scale),) + assert fields1047 is not None + unwrapped_fields1048 = fields1047 self.write("(DECIMAL") self.indent_sexp() self.newline() - field1042 = unwrapped_fields1041[0] - self.write(str(field1042)) + field1049 = unwrapped_fields1048[0] + self.write(str(field1049)) self.newline() - field1043 = unwrapped_fields1041[1] - self.write(str(field1043)) + field1050 = unwrapped_fields1048[1] + self.write(str(field1050)) self.dedent() self.write(")") def pretty_boolean_type(self, msg: logic_pb2.BooleanType): - fields1045 = msg + fields1052 = msg self.write("BOOLEAN") def pretty_int32_type(self, msg: logic_pb2.Int32Type): - fields1046 = msg + fields1053 = msg self.write("INT32") def pretty_float32_type(self, msg: logic_pb2.Float32Type): - fields1047 = msg + fields1054 = msg self.write("FLOAT32") def pretty_uint32_type(self, msg: logic_pb2.UInt32Type): - fields1048 = msg + fields1055 = msg self.write("UINT32") + def pretty_fixed_type(self, msg: logic_pb2.FixedType): + flat1058 = self._try_flat(msg, self.pretty_fixed_type) + if flat1058 is not None: + assert flat1058 is not None + self.write(flat1058) + return None + else: + _dollar_dollar = msg + fields1056 = int(_dollar_dollar.length) + assert fields1056 is not None + unwrapped_fields1057 = fields1056 + self.write("(FIXED") + self.indent_sexp() + self.newline() + self.write(str(unwrapped_fields1057)) + self.dedent() + self.write(")") + def pretty_value_bindings(self, msg: Sequence[logic_pb2.Binding]): - flat1052 = self._try_flat(msg, self.pretty_value_bindings) - if flat1052 is not None: - assert flat1052 is not None - self.write(flat1052) + flat1062 = self._try_flat(msg, self.pretty_value_bindings) + if flat1062 is not None: + assert flat1062 is not None + self.write(flat1062) return None else: - fields1049 = msg + fields1059 = msg self.write("|") - if not len(fields1049) == 0: + if not len(fields1059) == 0: self.write(" ") - for i1051, elem1050 in enumerate(fields1049): - if (i1051 > 0): + for i1061, elem1060 in enumerate(fields1059): + if (i1061 > 0): self.newline() - self.pretty_binding(elem1050) + self.pretty_binding(elem1060) def pretty_formula(self, msg: logic_pb2.Formula): - flat1079 = self._try_flat(msg, self.pretty_formula) - if flat1079 is not None: - assert flat1079 is not None - self.write(flat1079) + flat1089 = self._try_flat(msg, self.pretty_formula) + if flat1089 is not None: + assert flat1089 is not None + self.write(flat1089) return None else: _dollar_dollar = msg if (_dollar_dollar.HasField("conjunction") and len(_dollar_dollar.conjunction.args) == 0): - _t1755 = _dollar_dollar.conjunction + _t1766 = _dollar_dollar.conjunction else: - _t1755 = None - deconstruct_result1077 = _t1755 - if deconstruct_result1077 is not None: - assert deconstruct_result1077 is not None - unwrapped1078 = deconstruct_result1077 - self.pretty_true(unwrapped1078) + _t1766 = None + deconstruct_result1087 = _t1766 + if deconstruct_result1087 is not None: + assert deconstruct_result1087 is not None + unwrapped1088 = deconstruct_result1087 + self.pretty_true(unwrapped1088) else: _dollar_dollar = msg if (_dollar_dollar.HasField("disjunction") and len(_dollar_dollar.disjunction.args) == 0): - _t1756 = _dollar_dollar.disjunction + _t1767 = _dollar_dollar.disjunction else: - _t1756 = None - deconstruct_result1075 = _t1756 - if deconstruct_result1075 is not None: - assert deconstruct_result1075 is not None - unwrapped1076 = deconstruct_result1075 - self.pretty_false(unwrapped1076) + _t1767 = None + deconstruct_result1085 = _t1767 + if deconstruct_result1085 is not None: + assert deconstruct_result1085 is not None + unwrapped1086 = deconstruct_result1085 + self.pretty_false(unwrapped1086) else: _dollar_dollar = msg if _dollar_dollar.HasField("exists"): - _t1757 = _dollar_dollar.exists + _t1768 = _dollar_dollar.exists else: - _t1757 = None - deconstruct_result1073 = _t1757 - if deconstruct_result1073 is not None: - assert deconstruct_result1073 is not None - unwrapped1074 = deconstruct_result1073 - self.pretty_exists(unwrapped1074) + _t1768 = None + deconstruct_result1083 = _t1768 + if deconstruct_result1083 is not None: + assert deconstruct_result1083 is not None + unwrapped1084 = deconstruct_result1083 + self.pretty_exists(unwrapped1084) else: _dollar_dollar = msg if _dollar_dollar.HasField("reduce"): - _t1758 = _dollar_dollar.reduce + _t1769 = _dollar_dollar.reduce else: - _t1758 = None - deconstruct_result1071 = _t1758 - if deconstruct_result1071 is not None: - assert deconstruct_result1071 is not None - unwrapped1072 = deconstruct_result1071 - self.pretty_reduce(unwrapped1072) + _t1769 = None + deconstruct_result1081 = _t1769 + if deconstruct_result1081 is not None: + assert deconstruct_result1081 is not None + unwrapped1082 = deconstruct_result1081 + self.pretty_reduce(unwrapped1082) else: _dollar_dollar = msg if (_dollar_dollar.HasField("conjunction") and not len(_dollar_dollar.conjunction.args) == 0): - _t1759 = _dollar_dollar.conjunction + _t1770 = _dollar_dollar.conjunction else: - _t1759 = None - deconstruct_result1069 = _t1759 - if deconstruct_result1069 is not None: - assert deconstruct_result1069 is not None - unwrapped1070 = deconstruct_result1069 - self.pretty_conjunction(unwrapped1070) + _t1770 = None + deconstruct_result1079 = _t1770 + if deconstruct_result1079 is not None: + assert deconstruct_result1079 is not None + unwrapped1080 = deconstruct_result1079 + self.pretty_conjunction(unwrapped1080) else: _dollar_dollar = msg if (_dollar_dollar.HasField("disjunction") and not len(_dollar_dollar.disjunction.args) == 0): - _t1760 = _dollar_dollar.disjunction + _t1771 = _dollar_dollar.disjunction else: - _t1760 = None - deconstruct_result1067 = _t1760 - if deconstruct_result1067 is not None: - assert deconstruct_result1067 is not None - unwrapped1068 = deconstruct_result1067 - self.pretty_disjunction(unwrapped1068) + _t1771 = None + deconstruct_result1077 = _t1771 + if deconstruct_result1077 is not None: + assert deconstruct_result1077 is not None + unwrapped1078 = deconstruct_result1077 + self.pretty_disjunction(unwrapped1078) else: _dollar_dollar = msg if _dollar_dollar.HasField("not"): - _t1761 = getattr(_dollar_dollar, 'not') + _t1772 = getattr(_dollar_dollar, 'not') else: - _t1761 = None - deconstruct_result1065 = _t1761 - if deconstruct_result1065 is not None: - assert deconstruct_result1065 is not None - unwrapped1066 = deconstruct_result1065 - self.pretty_not(unwrapped1066) + _t1772 = None + deconstruct_result1075 = _t1772 + if deconstruct_result1075 is not None: + assert deconstruct_result1075 is not None + unwrapped1076 = deconstruct_result1075 + self.pretty_not(unwrapped1076) else: _dollar_dollar = msg if _dollar_dollar.HasField("ffi"): - _t1762 = _dollar_dollar.ffi + _t1773 = _dollar_dollar.ffi else: - _t1762 = None - deconstruct_result1063 = _t1762 - if deconstruct_result1063 is not None: - assert deconstruct_result1063 is not None - unwrapped1064 = deconstruct_result1063 - self.pretty_ffi(unwrapped1064) + _t1773 = None + deconstruct_result1073 = _t1773 + if deconstruct_result1073 is not None: + assert deconstruct_result1073 is not None + unwrapped1074 = deconstruct_result1073 + self.pretty_ffi(unwrapped1074) else: _dollar_dollar = msg if _dollar_dollar.HasField("atom"): - _t1763 = _dollar_dollar.atom + _t1774 = _dollar_dollar.atom else: - _t1763 = None - deconstruct_result1061 = _t1763 - if deconstruct_result1061 is not None: - assert deconstruct_result1061 is not None - unwrapped1062 = deconstruct_result1061 - self.pretty_atom(unwrapped1062) + _t1774 = None + deconstruct_result1071 = _t1774 + if deconstruct_result1071 is not None: + assert deconstruct_result1071 is not None + unwrapped1072 = deconstruct_result1071 + self.pretty_atom(unwrapped1072) else: _dollar_dollar = msg if _dollar_dollar.HasField("pragma"): - _t1764 = _dollar_dollar.pragma + _t1775 = _dollar_dollar.pragma else: - _t1764 = None - deconstruct_result1059 = _t1764 - if deconstruct_result1059 is not None: - assert deconstruct_result1059 is not None - unwrapped1060 = deconstruct_result1059 - self.pretty_pragma(unwrapped1060) + _t1775 = None + deconstruct_result1069 = _t1775 + if deconstruct_result1069 is not None: + assert deconstruct_result1069 is not None + unwrapped1070 = deconstruct_result1069 + self.pretty_pragma(unwrapped1070) else: _dollar_dollar = msg if _dollar_dollar.HasField("primitive"): - _t1765 = _dollar_dollar.primitive + _t1776 = _dollar_dollar.primitive else: - _t1765 = None - deconstruct_result1057 = _t1765 - if deconstruct_result1057 is not None: - assert deconstruct_result1057 is not None - unwrapped1058 = deconstruct_result1057 - self.pretty_primitive(unwrapped1058) + _t1776 = None + deconstruct_result1067 = _t1776 + if deconstruct_result1067 is not None: + assert deconstruct_result1067 is not None + unwrapped1068 = deconstruct_result1067 + self.pretty_primitive(unwrapped1068) else: _dollar_dollar = msg if _dollar_dollar.HasField("rel_atom"): - _t1766 = _dollar_dollar.rel_atom + _t1777 = _dollar_dollar.rel_atom else: - _t1766 = None - deconstruct_result1055 = _t1766 - if deconstruct_result1055 is not None: - assert deconstruct_result1055 is not None - unwrapped1056 = deconstruct_result1055 - self.pretty_rel_atom(unwrapped1056) + _t1777 = None + deconstruct_result1065 = _t1777 + if deconstruct_result1065 is not None: + assert deconstruct_result1065 is not None + unwrapped1066 = deconstruct_result1065 + self.pretty_rel_atom(unwrapped1066) else: _dollar_dollar = msg if _dollar_dollar.HasField("cast"): - _t1767 = _dollar_dollar.cast + _t1778 = _dollar_dollar.cast else: - _t1767 = None - deconstruct_result1053 = _t1767 - if deconstruct_result1053 is not None: - assert deconstruct_result1053 is not None - unwrapped1054 = deconstruct_result1053 - self.pretty_cast(unwrapped1054) + _t1778 = None + deconstruct_result1063 = _t1778 + if deconstruct_result1063 is not None: + assert deconstruct_result1063 is not None + unwrapped1064 = deconstruct_result1063 + self.pretty_cast(unwrapped1064) else: raise ParseError("No matching rule for formula") def pretty_true(self, msg: logic_pb2.Conjunction): - fields1080 = msg + fields1090 = msg self.write("(true)") def pretty_false(self, msg: logic_pb2.Disjunction): - fields1081 = msg + fields1091 = msg self.write("(false)") def pretty_exists(self, msg: logic_pb2.Exists): - flat1086 = self._try_flat(msg, self.pretty_exists) - if flat1086 is not None: - assert flat1086 is not None - self.write(flat1086) + flat1096 = self._try_flat(msg, self.pretty_exists) + if flat1096 is not None: + assert flat1096 is not None + self.write(flat1096) return None else: _dollar_dollar = msg - _t1768 = self.deconstruct_bindings(_dollar_dollar.body) - fields1082 = (_t1768, _dollar_dollar.body.value,) - assert fields1082 is not None - unwrapped_fields1083 = fields1082 + _t1779 = self.deconstruct_bindings(_dollar_dollar.body) + fields1092 = (_t1779, _dollar_dollar.body.value,) + assert fields1092 is not None + unwrapped_fields1093 = fields1092 self.write("(exists") self.indent_sexp() self.newline() - field1084 = unwrapped_fields1083[0] - self.pretty_bindings(field1084) + field1094 = unwrapped_fields1093[0] + self.pretty_bindings(field1094) self.newline() - field1085 = unwrapped_fields1083[1] - self.pretty_formula(field1085) + field1095 = unwrapped_fields1093[1] + self.pretty_formula(field1095) self.dedent() self.write(")") def pretty_reduce(self, msg: logic_pb2.Reduce): - flat1092 = self._try_flat(msg, self.pretty_reduce) - if flat1092 is not None: - assert flat1092 is not None - self.write(flat1092) + flat1102 = self._try_flat(msg, self.pretty_reduce) + if flat1102 is not None: + assert flat1102 is not None + self.write(flat1102) return None else: _dollar_dollar = msg - fields1087 = (_dollar_dollar.op, _dollar_dollar.body, _dollar_dollar.terms,) - assert fields1087 is not None - unwrapped_fields1088 = fields1087 + fields1097 = (_dollar_dollar.op, _dollar_dollar.body, _dollar_dollar.terms,) + assert fields1097 is not None + unwrapped_fields1098 = fields1097 self.write("(reduce") self.indent_sexp() self.newline() - field1089 = unwrapped_fields1088[0] - self.pretty_abstraction(field1089) + field1099 = unwrapped_fields1098[0] + self.pretty_abstraction(field1099) self.newline() - field1090 = unwrapped_fields1088[1] - self.pretty_abstraction(field1090) + field1100 = unwrapped_fields1098[1] + self.pretty_abstraction(field1100) self.newline() - field1091 = unwrapped_fields1088[2] - self.pretty_terms(field1091) + field1101 = unwrapped_fields1098[2] + self.pretty_terms(field1101) self.dedent() self.write(")") def pretty_terms(self, msg: Sequence[logic_pb2.Term]): - flat1096 = self._try_flat(msg, self.pretty_terms) - if flat1096 is not None: - assert flat1096 is not None - self.write(flat1096) + flat1106 = self._try_flat(msg, self.pretty_terms) + if flat1106 is not None: + assert flat1106 is not None + self.write(flat1106) return None else: - fields1093 = msg + fields1103 = msg self.write("(terms") self.indent_sexp() - if not len(fields1093) == 0: + if not len(fields1103) == 0: self.newline() - for i1095, elem1094 in enumerate(fields1093): - if (i1095 > 0): + for i1105, elem1104 in enumerate(fields1103): + if (i1105 > 0): self.newline() - self.pretty_term(elem1094) + self.pretty_term(elem1104) self.dedent() self.write(")") def pretty_term(self, msg: logic_pb2.Term): - flat1101 = self._try_flat(msg, self.pretty_term) - if flat1101 is not None: - assert flat1101 is not None - self.write(flat1101) + flat1111 = self._try_flat(msg, self.pretty_term) + if flat1111 is not None: + assert flat1111 is not None + self.write(flat1111) return None else: _dollar_dollar = msg if _dollar_dollar.HasField("var"): - _t1769 = _dollar_dollar.var + _t1780 = _dollar_dollar.var else: - _t1769 = None - deconstruct_result1099 = _t1769 - if deconstruct_result1099 is not None: - assert deconstruct_result1099 is not None - unwrapped1100 = deconstruct_result1099 - self.pretty_var(unwrapped1100) + _t1780 = None + deconstruct_result1109 = _t1780 + if deconstruct_result1109 is not None: + assert deconstruct_result1109 is not None + unwrapped1110 = deconstruct_result1109 + self.pretty_var(unwrapped1110) else: _dollar_dollar = msg if _dollar_dollar.HasField("constant"): - _t1770 = _dollar_dollar.constant + _t1781 = _dollar_dollar.constant else: - _t1770 = None - deconstruct_result1097 = _t1770 - if deconstruct_result1097 is not None: - assert deconstruct_result1097 is not None - unwrapped1098 = deconstruct_result1097 - self.pretty_value(unwrapped1098) + _t1781 = None + deconstruct_result1107 = _t1781 + if deconstruct_result1107 is not None: + assert deconstruct_result1107 is not None + unwrapped1108 = deconstruct_result1107 + self.pretty_value(unwrapped1108) else: raise ParseError("No matching rule for term") def pretty_var(self, msg: logic_pb2.Var): - flat1104 = self._try_flat(msg, self.pretty_var) - if flat1104 is not None: - assert flat1104 is not None - self.write(flat1104) + flat1114 = self._try_flat(msg, self.pretty_var) + if flat1114 is not None: + assert flat1114 is not None + self.write(flat1114) return None else: _dollar_dollar = msg - fields1102 = _dollar_dollar.name - assert fields1102 is not None - unwrapped_fields1103 = fields1102 - self.write(unwrapped_fields1103) + fields1112 = _dollar_dollar.name + assert fields1112 is not None + unwrapped_fields1113 = fields1112 + self.write(unwrapped_fields1113) def pretty_value(self, msg: logic_pb2.Value): - flat1130 = self._try_flat(msg, self.pretty_value) - if flat1130 is not None: - assert flat1130 is not None - self.write(flat1130) + flat1140 = self._try_flat(msg, self.pretty_value) + if flat1140 is not None: + assert flat1140 is not None + self.write(flat1140) return None else: _dollar_dollar = msg if _dollar_dollar.HasField("date_value"): - _t1771 = _dollar_dollar.date_value + _t1782 = _dollar_dollar.date_value else: - _t1771 = None - deconstruct_result1128 = _t1771 - if deconstruct_result1128 is not None: - assert deconstruct_result1128 is not None - unwrapped1129 = deconstruct_result1128 - self.pretty_date(unwrapped1129) + _t1782 = None + deconstruct_result1138 = _t1782 + if deconstruct_result1138 is not None: + assert deconstruct_result1138 is not None + unwrapped1139 = deconstruct_result1138 + self.pretty_date(unwrapped1139) else: _dollar_dollar = msg if _dollar_dollar.HasField("datetime_value"): - _t1772 = _dollar_dollar.datetime_value + _t1783 = _dollar_dollar.datetime_value else: - _t1772 = None - deconstruct_result1126 = _t1772 - if deconstruct_result1126 is not None: - assert deconstruct_result1126 is not None - unwrapped1127 = deconstruct_result1126 - self.pretty_datetime(unwrapped1127) + _t1783 = None + deconstruct_result1136 = _t1783 + if deconstruct_result1136 is not None: + assert deconstruct_result1136 is not None + unwrapped1137 = deconstruct_result1136 + self.pretty_datetime(unwrapped1137) else: _dollar_dollar = msg if _dollar_dollar.HasField("string_value"): - _t1773 = _dollar_dollar.string_value + _t1784 = _dollar_dollar.string_value else: - _t1773 = None - deconstruct_result1124 = _t1773 - if deconstruct_result1124 is not None: - assert deconstruct_result1124 is not None - unwrapped1125 = deconstruct_result1124 - self.write(self.format_string_value(unwrapped1125)) + _t1784 = None + deconstruct_result1134 = _t1784 + if deconstruct_result1134 is not None: + assert deconstruct_result1134 is not None + unwrapped1135 = deconstruct_result1134 + self.write(self.format_string_value(unwrapped1135)) else: _dollar_dollar = msg if _dollar_dollar.HasField("int32_value"): - _t1774 = _dollar_dollar.int32_value + _t1785 = _dollar_dollar.int32_value else: - _t1774 = None - deconstruct_result1122 = _t1774 - if deconstruct_result1122 is not None: - assert deconstruct_result1122 is not None - unwrapped1123 = deconstruct_result1122 - self.write((str(unwrapped1123) + 'i32')) + _t1785 = None + deconstruct_result1132 = _t1785 + if deconstruct_result1132 is not None: + assert deconstruct_result1132 is not None + unwrapped1133 = deconstruct_result1132 + self.write((str(unwrapped1133) + 'i32')) else: _dollar_dollar = msg if _dollar_dollar.HasField("int_value"): - _t1775 = _dollar_dollar.int_value + _t1786 = _dollar_dollar.int_value else: - _t1775 = None - deconstruct_result1120 = _t1775 - if deconstruct_result1120 is not None: - assert deconstruct_result1120 is not None - unwrapped1121 = deconstruct_result1120 - self.write(str(unwrapped1121)) + _t1786 = None + deconstruct_result1130 = _t1786 + if deconstruct_result1130 is not None: + assert deconstruct_result1130 is not None + unwrapped1131 = deconstruct_result1130 + self.write(str(unwrapped1131)) else: _dollar_dollar = msg if _dollar_dollar.HasField("float32_value"): - _t1776 = _dollar_dollar.float32_value + _t1787 = _dollar_dollar.float32_value else: - _t1776 = None - deconstruct_result1118 = _t1776 - if deconstruct_result1118 is not None: - assert deconstruct_result1118 is not None - unwrapped1119 = deconstruct_result1118 - self.write(self.format_float32_literal(unwrapped1119)) + _t1787 = None + deconstruct_result1128 = _t1787 + if deconstruct_result1128 is not None: + assert deconstruct_result1128 is not None + unwrapped1129 = deconstruct_result1128 + self.write(self.format_float32_literal(unwrapped1129)) else: _dollar_dollar = msg if _dollar_dollar.HasField("float_value"): - _t1777 = _dollar_dollar.float_value + _t1788 = _dollar_dollar.float_value else: - _t1777 = None - deconstruct_result1116 = _t1777 - if deconstruct_result1116 is not None: - assert deconstruct_result1116 is not None - unwrapped1117 = deconstruct_result1116 - self.write(str(unwrapped1117)) + _t1788 = None + deconstruct_result1126 = _t1788 + if deconstruct_result1126 is not None: + assert deconstruct_result1126 is not None + unwrapped1127 = deconstruct_result1126 + self.write(str(unwrapped1127)) else: _dollar_dollar = msg if _dollar_dollar.HasField("uint32_value"): - _t1778 = _dollar_dollar.uint32_value + _t1789 = _dollar_dollar.uint32_value else: - _t1778 = None - deconstruct_result1114 = _t1778 - if deconstruct_result1114 is not None: - assert deconstruct_result1114 is not None - unwrapped1115 = deconstruct_result1114 - self.write((str(unwrapped1115) + 'u32')) + _t1789 = None + deconstruct_result1124 = _t1789 + if deconstruct_result1124 is not None: + assert deconstruct_result1124 is not None + unwrapped1125 = deconstruct_result1124 + self.write((str(unwrapped1125) + 'u32')) else: _dollar_dollar = msg if _dollar_dollar.HasField("uint128_value"): - _t1779 = _dollar_dollar.uint128_value + _t1790 = _dollar_dollar.uint128_value else: - _t1779 = None - deconstruct_result1112 = _t1779 - if deconstruct_result1112 is not None: - assert deconstruct_result1112 is not None - unwrapped1113 = deconstruct_result1112 - self.write(self.format_uint128(unwrapped1113)) + _t1790 = None + deconstruct_result1122 = _t1790 + if deconstruct_result1122 is not None: + assert deconstruct_result1122 is not None + unwrapped1123 = deconstruct_result1122 + self.write(self.format_uint128(unwrapped1123)) else: _dollar_dollar = msg if _dollar_dollar.HasField("int128_value"): - _t1780 = _dollar_dollar.int128_value + _t1791 = _dollar_dollar.int128_value else: - _t1780 = None - deconstruct_result1110 = _t1780 - if deconstruct_result1110 is not None: - assert deconstruct_result1110 is not None - unwrapped1111 = deconstruct_result1110 - self.write(self.format_int128(unwrapped1111)) + _t1791 = None + deconstruct_result1120 = _t1791 + if deconstruct_result1120 is not None: + assert deconstruct_result1120 is not None + unwrapped1121 = deconstruct_result1120 + self.write(self.format_int128(unwrapped1121)) else: _dollar_dollar = msg if _dollar_dollar.HasField("decimal_value"): - _t1781 = _dollar_dollar.decimal_value + _t1792 = _dollar_dollar.decimal_value else: - _t1781 = None - deconstruct_result1108 = _t1781 - if deconstruct_result1108 is not None: - assert deconstruct_result1108 is not None - unwrapped1109 = deconstruct_result1108 - self.write(self.format_decimal(unwrapped1109)) + _t1792 = None + deconstruct_result1118 = _t1792 + if deconstruct_result1118 is not None: + assert deconstruct_result1118 is not None + unwrapped1119 = deconstruct_result1118 + self.write(self.format_decimal(unwrapped1119)) else: _dollar_dollar = msg if _dollar_dollar.HasField("boolean_value"): - _t1782 = _dollar_dollar.boolean_value + _t1793 = _dollar_dollar.boolean_value else: - _t1782 = None - deconstruct_result1106 = _t1782 - if deconstruct_result1106 is not None: - assert deconstruct_result1106 is not None - unwrapped1107 = deconstruct_result1106 - self.pretty_boolean_value(unwrapped1107) + _t1793 = None + deconstruct_result1116 = _t1793 + if deconstruct_result1116 is not None: + assert deconstruct_result1116 is not None + unwrapped1117 = deconstruct_result1116 + self.pretty_boolean_value(unwrapped1117) else: - fields1105 = msg + fields1115 = msg self.write("missing") def pretty_date(self, msg: logic_pb2.DateValue): - flat1136 = self._try_flat(msg, self.pretty_date) - if flat1136 is not None: - assert flat1136 is not None - self.write(flat1136) + flat1146 = self._try_flat(msg, self.pretty_date) + if flat1146 is not None: + assert flat1146 is not None + self.write(flat1146) return None else: _dollar_dollar = msg - fields1131 = (int(_dollar_dollar.year), int(_dollar_dollar.month), int(_dollar_dollar.day),) - assert fields1131 is not None - unwrapped_fields1132 = fields1131 + fields1141 = (int(_dollar_dollar.year), int(_dollar_dollar.month), int(_dollar_dollar.day),) + assert fields1141 is not None + unwrapped_fields1142 = fields1141 self.write("(date") self.indent_sexp() self.newline() - field1133 = unwrapped_fields1132[0] - self.write(str(field1133)) + field1143 = unwrapped_fields1142[0] + self.write(str(field1143)) self.newline() - field1134 = unwrapped_fields1132[1] - self.write(str(field1134)) + field1144 = unwrapped_fields1142[1] + self.write(str(field1144)) self.newline() - field1135 = unwrapped_fields1132[2] - self.write(str(field1135)) + field1145 = unwrapped_fields1142[2] + self.write(str(field1145)) self.dedent() self.write(")") def pretty_datetime(self, msg: logic_pb2.DateTimeValue): - flat1147 = self._try_flat(msg, self.pretty_datetime) - if flat1147 is not None: - assert flat1147 is not None - self.write(flat1147) + flat1157 = self._try_flat(msg, self.pretty_datetime) + if flat1157 is not None: + assert flat1157 is not None + self.write(flat1157) return None else: _dollar_dollar = msg - fields1137 = (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 fields1137 is not None - unwrapped_fields1138 = fields1137 + fields1147 = (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 fields1147 is not None + unwrapped_fields1148 = fields1147 self.write("(datetime") self.indent_sexp() self.newline() - field1139 = unwrapped_fields1138[0] - self.write(str(field1139)) + field1149 = unwrapped_fields1148[0] + self.write(str(field1149)) self.newline() - field1140 = unwrapped_fields1138[1] - self.write(str(field1140)) + field1150 = unwrapped_fields1148[1] + self.write(str(field1150)) self.newline() - field1141 = unwrapped_fields1138[2] - self.write(str(field1141)) + field1151 = unwrapped_fields1148[2] + self.write(str(field1151)) self.newline() - field1142 = unwrapped_fields1138[3] - self.write(str(field1142)) + field1152 = unwrapped_fields1148[3] + self.write(str(field1152)) self.newline() - field1143 = unwrapped_fields1138[4] - self.write(str(field1143)) + field1153 = unwrapped_fields1148[4] + self.write(str(field1153)) self.newline() - field1144 = unwrapped_fields1138[5] - self.write(str(field1144)) - field1145 = unwrapped_fields1138[6] - if field1145 is not None: + field1154 = unwrapped_fields1148[5] + self.write(str(field1154)) + field1155 = unwrapped_fields1148[6] + if field1155 is not None: self.newline() - assert field1145 is not None - opt_val1146 = field1145 - self.write(str(opt_val1146)) + assert field1155 is not None + opt_val1156 = field1155 + self.write(str(opt_val1156)) self.dedent() self.write(")") def pretty_conjunction(self, msg: logic_pb2.Conjunction): - flat1152 = self._try_flat(msg, self.pretty_conjunction) - if flat1152 is not None: - assert flat1152 is not None - self.write(flat1152) + flat1162 = self._try_flat(msg, self.pretty_conjunction) + if flat1162 is not None: + assert flat1162 is not None + self.write(flat1162) return None else: _dollar_dollar = msg - fields1148 = _dollar_dollar.args - assert fields1148 is not None - unwrapped_fields1149 = fields1148 + fields1158 = _dollar_dollar.args + assert fields1158 is not None + unwrapped_fields1159 = fields1158 self.write("(and") self.indent_sexp() - if not len(unwrapped_fields1149) == 0: + if not len(unwrapped_fields1159) == 0: self.newline() - for i1151, elem1150 in enumerate(unwrapped_fields1149): - if (i1151 > 0): + for i1161, elem1160 in enumerate(unwrapped_fields1159): + if (i1161 > 0): self.newline() - self.pretty_formula(elem1150) + self.pretty_formula(elem1160) self.dedent() self.write(")") def pretty_disjunction(self, msg: logic_pb2.Disjunction): - flat1157 = self._try_flat(msg, self.pretty_disjunction) - if flat1157 is not None: - assert flat1157 is not None - self.write(flat1157) + flat1167 = self._try_flat(msg, self.pretty_disjunction) + if flat1167 is not None: + assert flat1167 is not None + self.write(flat1167) return None else: _dollar_dollar = msg - fields1153 = _dollar_dollar.args - assert fields1153 is not None - unwrapped_fields1154 = fields1153 + fields1163 = _dollar_dollar.args + assert fields1163 is not None + unwrapped_fields1164 = fields1163 self.write("(or") self.indent_sexp() - if not len(unwrapped_fields1154) == 0: + if not len(unwrapped_fields1164) == 0: self.newline() - for i1156, elem1155 in enumerate(unwrapped_fields1154): - if (i1156 > 0): + for i1166, elem1165 in enumerate(unwrapped_fields1164): + if (i1166 > 0): self.newline() - self.pretty_formula(elem1155) + self.pretty_formula(elem1165) self.dedent() self.write(")") def pretty_not(self, msg: logic_pb2.Not): - flat1160 = self._try_flat(msg, self.pretty_not) - if flat1160 is not None: - assert flat1160 is not None - self.write(flat1160) + flat1170 = self._try_flat(msg, self.pretty_not) + if flat1170 is not None: + assert flat1170 is not None + self.write(flat1170) return None else: _dollar_dollar = msg - fields1158 = _dollar_dollar.arg - assert fields1158 is not None - unwrapped_fields1159 = fields1158 + fields1168 = _dollar_dollar.arg + assert fields1168 is not None + unwrapped_fields1169 = fields1168 self.write("(not") self.indent_sexp() self.newline() - self.pretty_formula(unwrapped_fields1159) + self.pretty_formula(unwrapped_fields1169) self.dedent() self.write(")") def pretty_ffi(self, msg: logic_pb2.FFI): - flat1166 = self._try_flat(msg, self.pretty_ffi) - if flat1166 is not None: - assert flat1166 is not None - self.write(flat1166) + flat1176 = self._try_flat(msg, self.pretty_ffi) + if flat1176 is not None: + assert flat1176 is not None + self.write(flat1176) return None else: _dollar_dollar = msg - fields1161 = (_dollar_dollar.name, _dollar_dollar.args, _dollar_dollar.terms,) - assert fields1161 is not None - unwrapped_fields1162 = fields1161 + fields1171 = (_dollar_dollar.name, _dollar_dollar.args, _dollar_dollar.terms,) + assert fields1171 is not None + unwrapped_fields1172 = fields1171 self.write("(ffi") self.indent_sexp() self.newline() - field1163 = unwrapped_fields1162[0] - self.pretty_name(field1163) + field1173 = unwrapped_fields1172[0] + self.pretty_name(field1173) self.newline() - field1164 = unwrapped_fields1162[1] - self.pretty_ffi_args(field1164) + field1174 = unwrapped_fields1172[1] + self.pretty_ffi_args(field1174) self.newline() - field1165 = unwrapped_fields1162[2] - self.pretty_terms(field1165) + field1175 = unwrapped_fields1172[2] + self.pretty_terms(field1175) self.dedent() self.write(")") def pretty_name(self, msg: str): - flat1168 = self._try_flat(msg, self.pretty_name) - if flat1168 is not None: - assert flat1168 is not None - self.write(flat1168) + flat1178 = self._try_flat(msg, self.pretty_name) + if flat1178 is not None: + assert flat1178 is not None + self.write(flat1178) return None else: - fields1167 = msg + fields1177 = msg self.write(":") - self.write(fields1167) + self.write(fields1177) def pretty_ffi_args(self, msg: Sequence[logic_pb2.Abstraction]): - flat1172 = self._try_flat(msg, self.pretty_ffi_args) - if flat1172 is not None: - assert flat1172 is not None - self.write(flat1172) + flat1182 = self._try_flat(msg, self.pretty_ffi_args) + if flat1182 is not None: + assert flat1182 is not None + self.write(flat1182) return None else: - fields1169 = msg + fields1179 = msg self.write("(args") self.indent_sexp() - if not len(fields1169) == 0: + if not len(fields1179) == 0: self.newline() - for i1171, elem1170 in enumerate(fields1169): - if (i1171 > 0): + for i1181, elem1180 in enumerate(fields1179): + if (i1181 > 0): self.newline() - self.pretty_abstraction(elem1170) + self.pretty_abstraction(elem1180) self.dedent() self.write(")") def pretty_atom(self, msg: logic_pb2.Atom): - flat1179 = self._try_flat(msg, self.pretty_atom) - if flat1179 is not None: - assert flat1179 is not None - self.write(flat1179) + flat1189 = self._try_flat(msg, self.pretty_atom) + if flat1189 is not None: + assert flat1189 is not None + self.write(flat1189) return None else: _dollar_dollar = msg - fields1173 = (_dollar_dollar.name, _dollar_dollar.terms,) - assert fields1173 is not None - unwrapped_fields1174 = fields1173 + fields1183 = (_dollar_dollar.name, _dollar_dollar.terms,) + assert fields1183 is not None + unwrapped_fields1184 = fields1183 self.write("(atom") self.indent_sexp() self.newline() - field1175 = unwrapped_fields1174[0] - self.pretty_relation_id(field1175) - field1176 = unwrapped_fields1174[1] - if not len(field1176) == 0: + field1185 = unwrapped_fields1184[0] + self.pretty_relation_id(field1185) + field1186 = unwrapped_fields1184[1] + if not len(field1186) == 0: self.newline() - for i1178, elem1177 in enumerate(field1176): - if (i1178 > 0): + for i1188, elem1187 in enumerate(field1186): + if (i1188 > 0): self.newline() - self.pretty_term(elem1177) + self.pretty_term(elem1187) self.dedent() self.write(")") def pretty_pragma(self, msg: logic_pb2.Pragma): - flat1186 = self._try_flat(msg, self.pretty_pragma) - if flat1186 is not None: - assert flat1186 is not None - self.write(flat1186) + flat1196 = self._try_flat(msg, self.pretty_pragma) + if flat1196 is not None: + assert flat1196 is not None + self.write(flat1196) return None else: _dollar_dollar = msg - fields1180 = (_dollar_dollar.name, _dollar_dollar.terms,) - assert fields1180 is not None - unwrapped_fields1181 = fields1180 + fields1190 = (_dollar_dollar.name, _dollar_dollar.terms,) + assert fields1190 is not None + unwrapped_fields1191 = fields1190 self.write("(pragma") self.indent_sexp() self.newline() - field1182 = unwrapped_fields1181[0] - self.pretty_name(field1182) - field1183 = unwrapped_fields1181[1] - if not len(field1183) == 0: + field1192 = unwrapped_fields1191[0] + self.pretty_name(field1192) + field1193 = unwrapped_fields1191[1] + if not len(field1193) == 0: self.newline() - for i1185, elem1184 in enumerate(field1183): - if (i1185 > 0): + for i1195, elem1194 in enumerate(field1193): + if (i1195 > 0): self.newline() - self.pretty_term(elem1184) + self.pretty_term(elem1194) self.dedent() self.write(")") def pretty_primitive(self, msg: logic_pb2.Primitive): - flat1202 = self._try_flat(msg, self.pretty_primitive) - if flat1202 is not None: - assert flat1202 is not None - self.write(flat1202) + flat1212 = self._try_flat(msg, self.pretty_primitive) + if flat1212 is not None: + assert flat1212 is not None + self.write(flat1212) return None else: _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_eq": - _t1783 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) + _t1794 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) else: - _t1783 = None - guard_result1201 = _t1783 - if guard_result1201 is not None: + _t1794 = None + guard_result1211 = _t1794 + if guard_result1211 is not None: self.pretty_eq(msg) else: _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_lt_monotype": - _t1784 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) + _t1795 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) else: - _t1784 = None - guard_result1200 = _t1784 - if guard_result1200 is not None: + _t1795 = None + guard_result1210 = _t1795 + if guard_result1210 is not None: self.pretty_lt(msg) else: _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_lt_eq_monotype": - _t1785 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) + _t1796 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) else: - _t1785 = None - guard_result1199 = _t1785 - if guard_result1199 is not None: + _t1796 = None + guard_result1209 = _t1796 + if guard_result1209 is not None: self.pretty_lt_eq(msg) else: _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_gt_monotype": - _t1786 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) + _t1797 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) else: - _t1786 = None - guard_result1198 = _t1786 - if guard_result1198 is not None: + _t1797 = None + guard_result1208 = _t1797 + if guard_result1208 is not None: self.pretty_gt(msg) else: _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_gt_eq_monotype": - _t1787 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) + _t1798 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) else: - _t1787 = None - guard_result1197 = _t1787 - if guard_result1197 is not None: + _t1798 = None + guard_result1207 = _t1798 + if guard_result1207 is not None: self.pretty_gt_eq(msg) else: _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_add_monotype": - _t1788 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) + _t1799 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) else: - _t1788 = None - guard_result1196 = _t1788 - if guard_result1196 is not None: + _t1799 = None + guard_result1206 = _t1799 + if guard_result1206 is not None: self.pretty_add(msg) else: _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_subtract_monotype": - _t1789 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) + _t1800 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) else: - _t1789 = None - guard_result1195 = _t1789 - if guard_result1195 is not None: + _t1800 = None + guard_result1205 = _t1800 + if guard_result1205 is not None: self.pretty_minus(msg) else: _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_multiply_monotype": - _t1790 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) + _t1801 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) else: - _t1790 = None - guard_result1194 = _t1790 - if guard_result1194 is not None: + _t1801 = None + guard_result1204 = _t1801 + if guard_result1204 is not None: self.pretty_multiply(msg) else: _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_divide_monotype": - _t1791 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) + _t1802 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) else: - _t1791 = None - guard_result1193 = _t1791 - if guard_result1193 is not None: + _t1802 = None + guard_result1203 = _t1802 + if guard_result1203 is not None: self.pretty_divide(msg) else: _dollar_dollar = msg - fields1187 = (_dollar_dollar.name, _dollar_dollar.terms,) - assert fields1187 is not None - unwrapped_fields1188 = fields1187 + fields1197 = (_dollar_dollar.name, _dollar_dollar.terms,) + assert fields1197 is not None + unwrapped_fields1198 = fields1197 self.write("(primitive") self.indent_sexp() self.newline() - field1189 = unwrapped_fields1188[0] - self.pretty_name(field1189) - field1190 = unwrapped_fields1188[1] - if not len(field1190) == 0: + field1199 = unwrapped_fields1198[0] + self.pretty_name(field1199) + field1200 = unwrapped_fields1198[1] + if not len(field1200) == 0: self.newline() - for i1192, elem1191 in enumerate(field1190): - if (i1192 > 0): + for i1202, elem1201 in enumerate(field1200): + if (i1202 > 0): self.newline() - self.pretty_rel_term(elem1191) + self.pretty_rel_term(elem1201) self.dedent() self.write(")") def pretty_eq(self, msg: logic_pb2.Primitive): - flat1207 = self._try_flat(msg, self.pretty_eq) - if flat1207 is not None: - assert flat1207 is not None - self.write(flat1207) + flat1217 = self._try_flat(msg, self.pretty_eq) + if flat1217 is not None: + assert flat1217 is not None + self.write(flat1217) return None else: _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_eq": - _t1792 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) + _t1803 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) else: - _t1792 = None - fields1203 = _t1792 - assert fields1203 is not None - unwrapped_fields1204 = fields1203 + _t1803 = None + fields1213 = _t1803 + assert fields1213 is not None + unwrapped_fields1214 = fields1213 self.write("(=") self.indent_sexp() self.newline() - field1205 = unwrapped_fields1204[0] - self.pretty_term(field1205) + field1215 = unwrapped_fields1214[0] + self.pretty_term(field1215) self.newline() - field1206 = unwrapped_fields1204[1] - self.pretty_term(field1206) + field1216 = unwrapped_fields1214[1] + self.pretty_term(field1216) self.dedent() self.write(")") def pretty_lt(self, msg: logic_pb2.Primitive): - flat1212 = self._try_flat(msg, self.pretty_lt) - if flat1212 is not None: - assert flat1212 is not None - self.write(flat1212) + flat1222 = self._try_flat(msg, self.pretty_lt) + if flat1222 is not None: + assert flat1222 is not None + self.write(flat1222) return None else: _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_lt_monotype": - _t1793 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) + _t1804 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) else: - _t1793 = None - fields1208 = _t1793 - assert fields1208 is not None - unwrapped_fields1209 = fields1208 + _t1804 = None + fields1218 = _t1804 + assert fields1218 is not None + unwrapped_fields1219 = fields1218 self.write("(<") self.indent_sexp() self.newline() - field1210 = unwrapped_fields1209[0] - self.pretty_term(field1210) + field1220 = unwrapped_fields1219[0] + self.pretty_term(field1220) self.newline() - field1211 = unwrapped_fields1209[1] - self.pretty_term(field1211) + field1221 = unwrapped_fields1219[1] + self.pretty_term(field1221) self.dedent() self.write(")") def pretty_lt_eq(self, msg: logic_pb2.Primitive): - flat1217 = self._try_flat(msg, self.pretty_lt_eq) - if flat1217 is not None: - assert flat1217 is not None - self.write(flat1217) + flat1227 = self._try_flat(msg, self.pretty_lt_eq) + if flat1227 is not None: + assert flat1227 is not None + self.write(flat1227) return None else: _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_lt_eq_monotype": - _t1794 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) + _t1805 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) else: - _t1794 = None - fields1213 = _t1794 - assert fields1213 is not None - unwrapped_fields1214 = fields1213 + _t1805 = None + fields1223 = _t1805 + assert fields1223 is not None + unwrapped_fields1224 = fields1223 self.write("(<=") self.indent_sexp() self.newline() - field1215 = unwrapped_fields1214[0] - self.pretty_term(field1215) + field1225 = unwrapped_fields1224[0] + self.pretty_term(field1225) self.newline() - field1216 = unwrapped_fields1214[1] - self.pretty_term(field1216) + field1226 = unwrapped_fields1224[1] + self.pretty_term(field1226) self.dedent() self.write(")") def pretty_gt(self, msg: logic_pb2.Primitive): - flat1222 = self._try_flat(msg, self.pretty_gt) - if flat1222 is not None: - assert flat1222 is not None - self.write(flat1222) + flat1232 = self._try_flat(msg, self.pretty_gt) + if flat1232 is not None: + assert flat1232 is not None + self.write(flat1232) return None else: _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_gt_monotype": - _t1795 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) + _t1806 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) else: - _t1795 = None - fields1218 = _t1795 - assert fields1218 is not None - unwrapped_fields1219 = fields1218 + _t1806 = None + fields1228 = _t1806 + assert fields1228 is not None + unwrapped_fields1229 = fields1228 self.write("(>") self.indent_sexp() self.newline() - field1220 = unwrapped_fields1219[0] - self.pretty_term(field1220) + field1230 = unwrapped_fields1229[0] + self.pretty_term(field1230) self.newline() - field1221 = unwrapped_fields1219[1] - self.pretty_term(field1221) + field1231 = unwrapped_fields1229[1] + self.pretty_term(field1231) self.dedent() self.write(")") def pretty_gt_eq(self, msg: logic_pb2.Primitive): - flat1227 = self._try_flat(msg, self.pretty_gt_eq) - if flat1227 is not None: - assert flat1227 is not None - self.write(flat1227) + flat1237 = self._try_flat(msg, self.pretty_gt_eq) + if flat1237 is not None: + assert flat1237 is not None + self.write(flat1237) return None else: _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_gt_eq_monotype": - _t1796 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) + _t1807 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) else: - _t1796 = None - fields1223 = _t1796 - assert fields1223 is not None - unwrapped_fields1224 = fields1223 + _t1807 = None + fields1233 = _t1807 + assert fields1233 is not None + unwrapped_fields1234 = fields1233 self.write("(>=") self.indent_sexp() self.newline() - field1225 = unwrapped_fields1224[0] - self.pretty_term(field1225) + field1235 = unwrapped_fields1234[0] + self.pretty_term(field1235) self.newline() - field1226 = unwrapped_fields1224[1] - self.pretty_term(field1226) + field1236 = unwrapped_fields1234[1] + self.pretty_term(field1236) self.dedent() self.write(")") def pretty_add(self, msg: logic_pb2.Primitive): - flat1233 = self._try_flat(msg, self.pretty_add) - if flat1233 is not None: - assert flat1233 is not None - self.write(flat1233) + flat1243 = self._try_flat(msg, self.pretty_add) + if flat1243 is not None: + assert flat1243 is not None + self.write(flat1243) return None else: _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_add_monotype": - _t1797 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) + _t1808 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) else: - _t1797 = None - fields1228 = _t1797 - assert fields1228 is not None - unwrapped_fields1229 = fields1228 + _t1808 = None + fields1238 = _t1808 + assert fields1238 is not None + unwrapped_fields1239 = fields1238 self.write("(+") self.indent_sexp() self.newline() - field1230 = unwrapped_fields1229[0] - self.pretty_term(field1230) + field1240 = unwrapped_fields1239[0] + self.pretty_term(field1240) self.newline() - field1231 = unwrapped_fields1229[1] - self.pretty_term(field1231) + field1241 = unwrapped_fields1239[1] + self.pretty_term(field1241) self.newline() - field1232 = unwrapped_fields1229[2] - self.pretty_term(field1232) + field1242 = unwrapped_fields1239[2] + self.pretty_term(field1242) self.dedent() self.write(")") def pretty_minus(self, msg: logic_pb2.Primitive): - flat1239 = self._try_flat(msg, self.pretty_minus) - if flat1239 is not None: - assert flat1239 is not None - self.write(flat1239) + flat1249 = self._try_flat(msg, self.pretty_minus) + if flat1249 is not None: + assert flat1249 is not None + self.write(flat1249) return None else: _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_subtract_monotype": - _t1798 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) + _t1809 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) else: - _t1798 = None - fields1234 = _t1798 - assert fields1234 is not None - unwrapped_fields1235 = fields1234 + _t1809 = None + fields1244 = _t1809 + assert fields1244 is not None + unwrapped_fields1245 = fields1244 self.write("(-") self.indent_sexp() self.newline() - field1236 = unwrapped_fields1235[0] - self.pretty_term(field1236) + field1246 = unwrapped_fields1245[0] + self.pretty_term(field1246) self.newline() - field1237 = unwrapped_fields1235[1] - self.pretty_term(field1237) + field1247 = unwrapped_fields1245[1] + self.pretty_term(field1247) self.newline() - field1238 = unwrapped_fields1235[2] - self.pretty_term(field1238) + field1248 = unwrapped_fields1245[2] + self.pretty_term(field1248) self.dedent() self.write(")") def pretty_multiply(self, msg: logic_pb2.Primitive): - flat1245 = self._try_flat(msg, self.pretty_multiply) - if flat1245 is not None: - assert flat1245 is not None - self.write(flat1245) + flat1255 = self._try_flat(msg, self.pretty_multiply) + if flat1255 is not None: + assert flat1255 is not None + self.write(flat1255) return None else: _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_multiply_monotype": - _t1799 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) + _t1810 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) else: - _t1799 = None - fields1240 = _t1799 - assert fields1240 is not None - unwrapped_fields1241 = fields1240 + _t1810 = None + fields1250 = _t1810 + assert fields1250 is not None + unwrapped_fields1251 = fields1250 self.write("(*") self.indent_sexp() self.newline() - field1242 = unwrapped_fields1241[0] - self.pretty_term(field1242) + field1252 = unwrapped_fields1251[0] + self.pretty_term(field1252) self.newline() - field1243 = unwrapped_fields1241[1] - self.pretty_term(field1243) + field1253 = unwrapped_fields1251[1] + self.pretty_term(field1253) self.newline() - field1244 = unwrapped_fields1241[2] - self.pretty_term(field1244) + field1254 = unwrapped_fields1251[2] + self.pretty_term(field1254) self.dedent() self.write(")") def pretty_divide(self, msg: logic_pb2.Primitive): - flat1251 = self._try_flat(msg, self.pretty_divide) - if flat1251 is not None: - assert flat1251 is not None - self.write(flat1251) + flat1261 = self._try_flat(msg, self.pretty_divide) + if flat1261 is not None: + assert flat1261 is not None + self.write(flat1261) return None else: _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_divide_monotype": - _t1800 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) + _t1811 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) else: - _t1800 = None - fields1246 = _t1800 - assert fields1246 is not None - unwrapped_fields1247 = fields1246 + _t1811 = None + fields1256 = _t1811 + assert fields1256 is not None + unwrapped_fields1257 = fields1256 self.write("(/") self.indent_sexp() self.newline() - field1248 = unwrapped_fields1247[0] - self.pretty_term(field1248) + field1258 = unwrapped_fields1257[0] + self.pretty_term(field1258) self.newline() - field1249 = unwrapped_fields1247[1] - self.pretty_term(field1249) + field1259 = unwrapped_fields1257[1] + self.pretty_term(field1259) self.newline() - field1250 = unwrapped_fields1247[2] - self.pretty_term(field1250) + field1260 = unwrapped_fields1257[2] + self.pretty_term(field1260) self.dedent() self.write(")") def pretty_rel_term(self, msg: logic_pb2.RelTerm): - flat1256 = self._try_flat(msg, self.pretty_rel_term) - if flat1256 is not None: - assert flat1256 is not None - self.write(flat1256) + flat1266 = self._try_flat(msg, self.pretty_rel_term) + if flat1266 is not None: + assert flat1266 is not None + self.write(flat1266) return None else: _dollar_dollar = msg if _dollar_dollar.HasField("specialized_value"): - _t1801 = _dollar_dollar.specialized_value + _t1812 = _dollar_dollar.specialized_value else: - _t1801 = None - deconstruct_result1254 = _t1801 - if deconstruct_result1254 is not None: - assert deconstruct_result1254 is not None - unwrapped1255 = deconstruct_result1254 - self.pretty_specialized_value(unwrapped1255) + _t1812 = None + deconstruct_result1264 = _t1812 + if deconstruct_result1264 is not None: + assert deconstruct_result1264 is not None + unwrapped1265 = deconstruct_result1264 + self.pretty_specialized_value(unwrapped1265) else: _dollar_dollar = msg if _dollar_dollar.HasField("term"): - _t1802 = _dollar_dollar.term + _t1813 = _dollar_dollar.term else: - _t1802 = None - deconstruct_result1252 = _t1802 - if deconstruct_result1252 is not None: - assert deconstruct_result1252 is not None - unwrapped1253 = deconstruct_result1252 - self.pretty_term(unwrapped1253) + _t1813 = None + deconstruct_result1262 = _t1813 + if deconstruct_result1262 is not None: + assert deconstruct_result1262 is not None + unwrapped1263 = deconstruct_result1262 + self.pretty_term(unwrapped1263) else: raise ParseError("No matching rule for rel_term") def pretty_specialized_value(self, msg: logic_pb2.Value): - flat1258 = self._try_flat(msg, self.pretty_specialized_value) - if flat1258 is not None: - assert flat1258 is not None - self.write(flat1258) + flat1268 = self._try_flat(msg, self.pretty_specialized_value) + if flat1268 is not None: + assert flat1268 is not None + self.write(flat1268) return None else: - fields1257 = msg + fields1267 = msg self.write("#") - self.pretty_raw_value(fields1257) + self.pretty_raw_value(fields1267) def pretty_rel_atom(self, msg: logic_pb2.RelAtom): - flat1265 = self._try_flat(msg, self.pretty_rel_atom) - if flat1265 is not None: - assert flat1265 is not None - self.write(flat1265) + flat1275 = self._try_flat(msg, self.pretty_rel_atom) + if flat1275 is not None: + assert flat1275 is not None + self.write(flat1275) return None else: _dollar_dollar = msg - fields1259 = (_dollar_dollar.name, _dollar_dollar.terms,) - assert fields1259 is not None - unwrapped_fields1260 = fields1259 + fields1269 = (_dollar_dollar.name, _dollar_dollar.terms,) + assert fields1269 is not None + unwrapped_fields1270 = fields1269 self.write("(relatom") self.indent_sexp() self.newline() - field1261 = unwrapped_fields1260[0] - self.pretty_name(field1261) - field1262 = unwrapped_fields1260[1] - if not len(field1262) == 0: + field1271 = unwrapped_fields1270[0] + self.pretty_name(field1271) + field1272 = unwrapped_fields1270[1] + if not len(field1272) == 0: self.newline() - for i1264, elem1263 in enumerate(field1262): - if (i1264 > 0): + for i1274, elem1273 in enumerate(field1272): + if (i1274 > 0): self.newline() - self.pretty_rel_term(elem1263) + self.pretty_rel_term(elem1273) self.dedent() self.write(")") def pretty_cast(self, msg: logic_pb2.Cast): - flat1270 = self._try_flat(msg, self.pretty_cast) - if flat1270 is not None: - assert flat1270 is not None - self.write(flat1270) + flat1280 = self._try_flat(msg, self.pretty_cast) + if flat1280 is not None: + assert flat1280 is not None + self.write(flat1280) return None else: _dollar_dollar = msg - fields1266 = (_dollar_dollar.input, _dollar_dollar.result,) - assert fields1266 is not None - unwrapped_fields1267 = fields1266 + fields1276 = (_dollar_dollar.input, _dollar_dollar.result,) + assert fields1276 is not None + unwrapped_fields1277 = fields1276 self.write("(cast") self.indent_sexp() self.newline() - field1268 = unwrapped_fields1267[0] - self.pretty_term(field1268) + field1278 = unwrapped_fields1277[0] + self.pretty_term(field1278) self.newline() - field1269 = unwrapped_fields1267[1] - self.pretty_term(field1269) + field1279 = unwrapped_fields1277[1] + self.pretty_term(field1279) self.dedent() self.write(")") def pretty_attrs(self, msg: Sequence[logic_pb2.Attribute]): - flat1274 = self._try_flat(msg, self.pretty_attrs) - if flat1274 is not None: - assert flat1274 is not None - self.write(flat1274) + flat1284 = self._try_flat(msg, self.pretty_attrs) + if flat1284 is not None: + assert flat1284 is not None + self.write(flat1284) return None else: - fields1271 = msg + fields1281 = msg self.write("(attrs") self.indent_sexp() - if not len(fields1271) == 0: + if not len(fields1281) == 0: self.newline() - for i1273, elem1272 in enumerate(fields1271): - if (i1273 > 0): + for i1283, elem1282 in enumerate(fields1281): + if (i1283 > 0): self.newline() - self.pretty_attribute(elem1272) + self.pretty_attribute(elem1282) self.dedent() self.write(")") def pretty_attribute(self, msg: logic_pb2.Attribute): - flat1281 = self._try_flat(msg, self.pretty_attribute) - if flat1281 is not None: - assert flat1281 is not None - self.write(flat1281) + flat1291 = self._try_flat(msg, self.pretty_attribute) + if flat1291 is not None: + assert flat1291 is not None + self.write(flat1291) return None else: _dollar_dollar = msg - fields1275 = (_dollar_dollar.name, _dollar_dollar.args,) - assert fields1275 is not None - unwrapped_fields1276 = fields1275 + fields1285 = (_dollar_dollar.name, _dollar_dollar.args,) + assert fields1285 is not None + unwrapped_fields1286 = fields1285 self.write("(attribute") self.indent_sexp() self.newline() - field1277 = unwrapped_fields1276[0] - self.pretty_name(field1277) - field1278 = unwrapped_fields1276[1] - if not len(field1278) == 0: + field1287 = unwrapped_fields1286[0] + self.pretty_name(field1287) + field1288 = unwrapped_fields1286[1] + if not len(field1288) == 0: self.newline() - for i1280, elem1279 in enumerate(field1278): - if (i1280 > 0): + for i1290, elem1289 in enumerate(field1288): + if (i1290 > 0): self.newline() - self.pretty_raw_value(elem1279) + self.pretty_raw_value(elem1289) self.dedent() self.write(")") def pretty_algorithm(self, msg: logic_pb2.Algorithm): - flat1290 = self._try_flat(msg, self.pretty_algorithm) - if flat1290 is not None: - assert flat1290 is not None - self.write(flat1290) + flat1300 = self._try_flat(msg, self.pretty_algorithm) + if flat1300 is not None: + assert flat1300 is not None + self.write(flat1300) return None else: _dollar_dollar = msg if not len(_dollar_dollar.attrs) == 0: - _t1803 = _dollar_dollar.attrs + _t1814 = _dollar_dollar.attrs else: - _t1803 = None - fields1282 = (getattr(_dollar_dollar, 'global'), _dollar_dollar.body, _t1803,) - assert fields1282 is not None - unwrapped_fields1283 = fields1282 + _t1814 = None + fields1292 = (getattr(_dollar_dollar, 'global'), _dollar_dollar.body, _t1814,) + assert fields1292 is not None + unwrapped_fields1293 = fields1292 self.write("(algorithm") self.indent_sexp() - field1284 = unwrapped_fields1283[0] - if not len(field1284) == 0: + field1294 = unwrapped_fields1293[0] + if not len(field1294) == 0: self.newline() - for i1286, elem1285 in enumerate(field1284): - if (i1286 > 0): + for i1296, elem1295 in enumerate(field1294): + if (i1296 > 0): self.newline() - self.pretty_relation_id(elem1285) + self.pretty_relation_id(elem1295) self.newline() - field1287 = unwrapped_fields1283[1] - self.pretty_script(field1287) - field1288 = unwrapped_fields1283[2] - if field1288 is not None: + field1297 = unwrapped_fields1293[1] + self.pretty_script(field1297) + field1298 = unwrapped_fields1293[2] + if field1298 is not None: self.newline() - assert field1288 is not None - opt_val1289 = field1288 - self.pretty_attrs(opt_val1289) + assert field1298 is not None + opt_val1299 = field1298 + self.pretty_attrs(opt_val1299) self.dedent() self.write(")") def pretty_script(self, msg: logic_pb2.Script): - flat1295 = self._try_flat(msg, self.pretty_script) - if flat1295 is not None: - assert flat1295 is not None - self.write(flat1295) + flat1305 = self._try_flat(msg, self.pretty_script) + if flat1305 is not None: + assert flat1305 is not None + self.write(flat1305) return None else: _dollar_dollar = msg - fields1291 = _dollar_dollar.constructs - assert fields1291 is not None - unwrapped_fields1292 = fields1291 + fields1301 = _dollar_dollar.constructs + assert fields1301 is not None + unwrapped_fields1302 = fields1301 self.write("(script") self.indent_sexp() - if not len(unwrapped_fields1292) == 0: + if not len(unwrapped_fields1302) == 0: self.newline() - for i1294, elem1293 in enumerate(unwrapped_fields1292): - if (i1294 > 0): + for i1304, elem1303 in enumerate(unwrapped_fields1302): + if (i1304 > 0): self.newline() - self.pretty_construct(elem1293) + self.pretty_construct(elem1303) self.dedent() self.write(")") def pretty_construct(self, msg: logic_pb2.Construct): - flat1300 = self._try_flat(msg, self.pretty_construct) - if flat1300 is not None: - assert flat1300 is not None - self.write(flat1300) + flat1310 = self._try_flat(msg, self.pretty_construct) + if flat1310 is not None: + assert flat1310 is not None + self.write(flat1310) return None else: _dollar_dollar = msg if _dollar_dollar.HasField("loop"): - _t1804 = _dollar_dollar.loop + _t1815 = _dollar_dollar.loop else: - _t1804 = None - deconstruct_result1298 = _t1804 - if deconstruct_result1298 is not None: - assert deconstruct_result1298 is not None - unwrapped1299 = deconstruct_result1298 - self.pretty_loop(unwrapped1299) + _t1815 = None + deconstruct_result1308 = _t1815 + if deconstruct_result1308 is not None: + assert deconstruct_result1308 is not None + unwrapped1309 = deconstruct_result1308 + self.pretty_loop(unwrapped1309) else: _dollar_dollar = msg if _dollar_dollar.HasField("instruction"): - _t1805 = _dollar_dollar.instruction + _t1816 = _dollar_dollar.instruction else: - _t1805 = None - deconstruct_result1296 = _t1805 - if deconstruct_result1296 is not None: - assert deconstruct_result1296 is not None - unwrapped1297 = deconstruct_result1296 - self.pretty_instruction(unwrapped1297) + _t1816 = None + deconstruct_result1306 = _t1816 + if deconstruct_result1306 is not None: + assert deconstruct_result1306 is not None + unwrapped1307 = deconstruct_result1306 + self.pretty_instruction(unwrapped1307) else: raise ParseError("No matching rule for construct") def pretty_loop(self, msg: logic_pb2.Loop): - flat1307 = self._try_flat(msg, self.pretty_loop) - if flat1307 is not None: - assert flat1307 is not None - self.write(flat1307) + flat1317 = self._try_flat(msg, self.pretty_loop) + if flat1317 is not None: + assert flat1317 is not None + self.write(flat1317) return None else: _dollar_dollar = msg if not len(_dollar_dollar.attrs) == 0: - _t1806 = _dollar_dollar.attrs + _t1817 = _dollar_dollar.attrs else: - _t1806 = None - fields1301 = (_dollar_dollar.init, _dollar_dollar.body, _t1806,) - assert fields1301 is not None - unwrapped_fields1302 = fields1301 + _t1817 = None + fields1311 = (_dollar_dollar.init, _dollar_dollar.body, _t1817,) + assert fields1311 is not None + unwrapped_fields1312 = fields1311 self.write("(loop") self.indent_sexp() self.newline() - field1303 = unwrapped_fields1302[0] - self.pretty_init(field1303) + field1313 = unwrapped_fields1312[0] + self.pretty_init(field1313) self.newline() - field1304 = unwrapped_fields1302[1] - self.pretty_script(field1304) - field1305 = unwrapped_fields1302[2] - if field1305 is not None: + field1314 = unwrapped_fields1312[1] + self.pretty_script(field1314) + field1315 = unwrapped_fields1312[2] + if field1315 is not None: self.newline() - assert field1305 is not None - opt_val1306 = field1305 - self.pretty_attrs(opt_val1306) + assert field1315 is not None + opt_val1316 = field1315 + self.pretty_attrs(opt_val1316) self.dedent() self.write(")") def pretty_init(self, msg: Sequence[logic_pb2.Instruction]): - flat1311 = self._try_flat(msg, self.pretty_init) - if flat1311 is not None: - assert flat1311 is not None - self.write(flat1311) + flat1321 = self._try_flat(msg, self.pretty_init) + if flat1321 is not None: + assert flat1321 is not None + self.write(flat1321) return None else: - fields1308 = msg + fields1318 = msg self.write("(init") self.indent_sexp() - if not len(fields1308) == 0: + if not len(fields1318) == 0: self.newline() - for i1310, elem1309 in enumerate(fields1308): - if (i1310 > 0): + for i1320, elem1319 in enumerate(fields1318): + if (i1320 > 0): self.newline() - self.pretty_instruction(elem1309) + self.pretty_instruction(elem1319) self.dedent() self.write(")") def pretty_instruction(self, msg: logic_pb2.Instruction): - flat1322 = self._try_flat(msg, self.pretty_instruction) - if flat1322 is not None: - assert flat1322 is not None - self.write(flat1322) + flat1332 = self._try_flat(msg, self.pretty_instruction) + if flat1332 is not None: + assert flat1332 is not None + self.write(flat1332) return None else: _dollar_dollar = msg if _dollar_dollar.HasField("assign"): - _t1807 = _dollar_dollar.assign + _t1818 = _dollar_dollar.assign else: - _t1807 = None - deconstruct_result1320 = _t1807 - if deconstruct_result1320 is not None: - assert deconstruct_result1320 is not None - unwrapped1321 = deconstruct_result1320 - self.pretty_assign(unwrapped1321) + _t1818 = None + deconstruct_result1330 = _t1818 + if deconstruct_result1330 is not None: + assert deconstruct_result1330 is not None + unwrapped1331 = deconstruct_result1330 + self.pretty_assign(unwrapped1331) else: _dollar_dollar = msg if _dollar_dollar.HasField("upsert"): - _t1808 = _dollar_dollar.upsert + _t1819 = _dollar_dollar.upsert else: - _t1808 = None - deconstruct_result1318 = _t1808 - if deconstruct_result1318 is not None: - assert deconstruct_result1318 is not None - unwrapped1319 = deconstruct_result1318 - self.pretty_upsert(unwrapped1319) + _t1819 = None + deconstruct_result1328 = _t1819 + if deconstruct_result1328 is not None: + assert deconstruct_result1328 is not None + unwrapped1329 = deconstruct_result1328 + self.pretty_upsert(unwrapped1329) else: _dollar_dollar = msg if _dollar_dollar.HasField("break"): - _t1809 = getattr(_dollar_dollar, 'break') + _t1820 = getattr(_dollar_dollar, 'break') else: - _t1809 = None - deconstruct_result1316 = _t1809 - if deconstruct_result1316 is not None: - assert deconstruct_result1316 is not None - unwrapped1317 = deconstruct_result1316 - self.pretty_break(unwrapped1317) + _t1820 = None + deconstruct_result1326 = _t1820 + if deconstruct_result1326 is not None: + assert deconstruct_result1326 is not None + unwrapped1327 = deconstruct_result1326 + self.pretty_break(unwrapped1327) else: _dollar_dollar = msg if _dollar_dollar.HasField("monoid_def"): - _t1810 = _dollar_dollar.monoid_def + _t1821 = _dollar_dollar.monoid_def else: - _t1810 = None - deconstruct_result1314 = _t1810 - if deconstruct_result1314 is not None: - assert deconstruct_result1314 is not None - unwrapped1315 = deconstruct_result1314 - self.pretty_monoid_def(unwrapped1315) + _t1821 = None + deconstruct_result1324 = _t1821 + if deconstruct_result1324 is not None: + assert deconstruct_result1324 is not None + unwrapped1325 = deconstruct_result1324 + self.pretty_monoid_def(unwrapped1325) else: _dollar_dollar = msg if _dollar_dollar.HasField("monus_def"): - _t1811 = _dollar_dollar.monus_def + _t1822 = _dollar_dollar.monus_def else: - _t1811 = None - deconstruct_result1312 = _t1811 - if deconstruct_result1312 is not None: - assert deconstruct_result1312 is not None - unwrapped1313 = deconstruct_result1312 - self.pretty_monus_def(unwrapped1313) + _t1822 = None + deconstruct_result1322 = _t1822 + if deconstruct_result1322 is not None: + assert deconstruct_result1322 is not None + unwrapped1323 = deconstruct_result1322 + self.pretty_monus_def(unwrapped1323) else: raise ParseError("No matching rule for instruction") def pretty_assign(self, msg: logic_pb2.Assign): - flat1329 = self._try_flat(msg, self.pretty_assign) - if flat1329 is not None: - assert flat1329 is not None - self.write(flat1329) + flat1339 = self._try_flat(msg, self.pretty_assign) + if flat1339 is not None: + assert flat1339 is not None + self.write(flat1339) return None else: _dollar_dollar = msg if not len(_dollar_dollar.attrs) == 0: - _t1812 = _dollar_dollar.attrs + _t1823 = _dollar_dollar.attrs else: - _t1812 = None - fields1323 = (_dollar_dollar.name, _dollar_dollar.body, _t1812,) - assert fields1323 is not None - unwrapped_fields1324 = fields1323 + _t1823 = None + fields1333 = (_dollar_dollar.name, _dollar_dollar.body, _t1823,) + assert fields1333 is not None + unwrapped_fields1334 = fields1333 self.write("(assign") self.indent_sexp() self.newline() - field1325 = unwrapped_fields1324[0] - self.pretty_relation_id(field1325) + field1335 = unwrapped_fields1334[0] + self.pretty_relation_id(field1335) self.newline() - field1326 = unwrapped_fields1324[1] - self.pretty_abstraction(field1326) - field1327 = unwrapped_fields1324[2] - if field1327 is not None: + field1336 = unwrapped_fields1334[1] + self.pretty_abstraction(field1336) + field1337 = unwrapped_fields1334[2] + if field1337 is not None: self.newline() - assert field1327 is not None - opt_val1328 = field1327 - self.pretty_attrs(opt_val1328) + assert field1337 is not None + opt_val1338 = field1337 + self.pretty_attrs(opt_val1338) self.dedent() self.write(")") def pretty_upsert(self, msg: logic_pb2.Upsert): - flat1336 = self._try_flat(msg, self.pretty_upsert) - if flat1336 is not None: - assert flat1336 is not None - self.write(flat1336) + flat1346 = self._try_flat(msg, self.pretty_upsert) + if flat1346 is not None: + assert flat1346 is not None + self.write(flat1346) return None else: _dollar_dollar = msg if not len(_dollar_dollar.attrs) == 0: - _t1813 = _dollar_dollar.attrs + _t1824 = _dollar_dollar.attrs else: - _t1813 = None - fields1330 = (_dollar_dollar.name, (_dollar_dollar.body, _dollar_dollar.value_arity,), _t1813,) - assert fields1330 is not None - unwrapped_fields1331 = fields1330 + _t1824 = None + fields1340 = (_dollar_dollar.name, (_dollar_dollar.body, _dollar_dollar.value_arity,), _t1824,) + assert fields1340 is not None + unwrapped_fields1341 = fields1340 self.write("(upsert") self.indent_sexp() self.newline() - field1332 = unwrapped_fields1331[0] - self.pretty_relation_id(field1332) + field1342 = unwrapped_fields1341[0] + self.pretty_relation_id(field1342) self.newline() - field1333 = unwrapped_fields1331[1] - self.pretty_abstraction_with_arity(field1333) - field1334 = unwrapped_fields1331[2] - if field1334 is not None: + field1343 = unwrapped_fields1341[1] + self.pretty_abstraction_with_arity(field1343) + field1344 = unwrapped_fields1341[2] + if field1344 is not None: self.newline() - assert field1334 is not None - opt_val1335 = field1334 - self.pretty_attrs(opt_val1335) + assert field1344 is not None + opt_val1345 = field1344 + self.pretty_attrs(opt_val1345) self.dedent() self.write(")") def pretty_abstraction_with_arity(self, msg: tuple[logic_pb2.Abstraction, int]): - flat1341 = self._try_flat(msg, self.pretty_abstraction_with_arity) - if flat1341 is not None: - assert flat1341 is not None - self.write(flat1341) + flat1351 = self._try_flat(msg, self.pretty_abstraction_with_arity) + if flat1351 is not None: + assert flat1351 is not None + self.write(flat1351) return None else: _dollar_dollar = msg - _t1814 = self.deconstruct_bindings_with_arity(_dollar_dollar[0], _dollar_dollar[1]) - fields1337 = (_t1814, _dollar_dollar[0].value,) - assert fields1337 is not None - unwrapped_fields1338 = fields1337 + _t1825 = self.deconstruct_bindings_with_arity(_dollar_dollar[0], _dollar_dollar[1]) + fields1347 = (_t1825, _dollar_dollar[0].value,) + assert fields1347 is not None + unwrapped_fields1348 = fields1347 self.write("(") self.indent() - field1339 = unwrapped_fields1338[0] - self.pretty_bindings(field1339) + field1349 = unwrapped_fields1348[0] + self.pretty_bindings(field1349) self.newline() - field1340 = unwrapped_fields1338[1] - self.pretty_formula(field1340) + field1350 = unwrapped_fields1348[1] + self.pretty_formula(field1350) self.dedent() self.write(")") def pretty_break(self, msg: logic_pb2.Break): - flat1348 = self._try_flat(msg, self.pretty_break) - if flat1348 is not None: - assert flat1348 is not None - self.write(flat1348) + flat1358 = self._try_flat(msg, self.pretty_break) + if flat1358 is not None: + assert flat1358 is not None + self.write(flat1358) return None else: _dollar_dollar = msg if not len(_dollar_dollar.attrs) == 0: - _t1815 = _dollar_dollar.attrs + _t1826 = _dollar_dollar.attrs else: - _t1815 = None - fields1342 = (_dollar_dollar.name, _dollar_dollar.body, _t1815,) - assert fields1342 is not None - unwrapped_fields1343 = fields1342 + _t1826 = None + fields1352 = (_dollar_dollar.name, _dollar_dollar.body, _t1826,) + assert fields1352 is not None + unwrapped_fields1353 = fields1352 self.write("(break") self.indent_sexp() self.newline() - field1344 = unwrapped_fields1343[0] - self.pretty_relation_id(field1344) + field1354 = unwrapped_fields1353[0] + self.pretty_relation_id(field1354) self.newline() - field1345 = unwrapped_fields1343[1] - self.pretty_abstraction(field1345) - field1346 = unwrapped_fields1343[2] - if field1346 is not None: + field1355 = unwrapped_fields1353[1] + self.pretty_abstraction(field1355) + field1356 = unwrapped_fields1353[2] + if field1356 is not None: self.newline() - assert field1346 is not None - opt_val1347 = field1346 - self.pretty_attrs(opt_val1347) + assert field1356 is not None + opt_val1357 = field1356 + self.pretty_attrs(opt_val1357) self.dedent() self.write(")") def pretty_monoid_def(self, msg: logic_pb2.MonoidDef): - flat1356 = self._try_flat(msg, self.pretty_monoid_def) - if flat1356 is not None: - assert flat1356 is not None - self.write(flat1356) + flat1366 = self._try_flat(msg, self.pretty_monoid_def) + if flat1366 is not None: + assert flat1366 is not None + self.write(flat1366) return None else: _dollar_dollar = msg if not len(_dollar_dollar.attrs) == 0: - _t1816 = _dollar_dollar.attrs + _t1827 = _dollar_dollar.attrs else: - _t1816 = None - fields1349 = (_dollar_dollar.monoid, _dollar_dollar.name, (_dollar_dollar.body, _dollar_dollar.value_arity,), _t1816,) - assert fields1349 is not None - unwrapped_fields1350 = fields1349 + _t1827 = None + fields1359 = (_dollar_dollar.monoid, _dollar_dollar.name, (_dollar_dollar.body, _dollar_dollar.value_arity,), _t1827,) + assert fields1359 is not None + unwrapped_fields1360 = fields1359 self.write("(monoid") self.indent_sexp() self.newline() - field1351 = unwrapped_fields1350[0] - self.pretty_monoid(field1351) + field1361 = unwrapped_fields1360[0] + self.pretty_monoid(field1361) self.newline() - field1352 = unwrapped_fields1350[1] - self.pretty_relation_id(field1352) + field1362 = unwrapped_fields1360[1] + self.pretty_relation_id(field1362) self.newline() - field1353 = unwrapped_fields1350[2] - self.pretty_abstraction_with_arity(field1353) - field1354 = unwrapped_fields1350[3] - if field1354 is not None: + field1363 = unwrapped_fields1360[2] + self.pretty_abstraction_with_arity(field1363) + field1364 = unwrapped_fields1360[3] + if field1364 is not None: self.newline() - assert field1354 is not None - opt_val1355 = field1354 - self.pretty_attrs(opt_val1355) + assert field1364 is not None + opt_val1365 = field1364 + self.pretty_attrs(opt_val1365) self.dedent() self.write(")") def pretty_monoid(self, msg: logic_pb2.Monoid): - flat1365 = self._try_flat(msg, self.pretty_monoid) - if flat1365 is not None: - assert flat1365 is not None - self.write(flat1365) + flat1375 = self._try_flat(msg, self.pretty_monoid) + if flat1375 is not None: + assert flat1375 is not None + self.write(flat1375) return None else: _dollar_dollar = msg if _dollar_dollar.HasField("or_monoid"): - _t1817 = _dollar_dollar.or_monoid + _t1828 = _dollar_dollar.or_monoid else: - _t1817 = None - deconstruct_result1363 = _t1817 - if deconstruct_result1363 is not None: - assert deconstruct_result1363 is not None - unwrapped1364 = deconstruct_result1363 - self.pretty_or_monoid(unwrapped1364) + _t1828 = None + deconstruct_result1373 = _t1828 + if deconstruct_result1373 is not None: + assert deconstruct_result1373 is not None + unwrapped1374 = deconstruct_result1373 + self.pretty_or_monoid(unwrapped1374) else: _dollar_dollar = msg if _dollar_dollar.HasField("min_monoid"): - _t1818 = _dollar_dollar.min_monoid + _t1829 = _dollar_dollar.min_monoid else: - _t1818 = None - deconstruct_result1361 = _t1818 - if deconstruct_result1361 is not None: - assert deconstruct_result1361 is not None - unwrapped1362 = deconstruct_result1361 - self.pretty_min_monoid(unwrapped1362) + _t1829 = None + deconstruct_result1371 = _t1829 + if deconstruct_result1371 is not None: + assert deconstruct_result1371 is not None + unwrapped1372 = deconstruct_result1371 + self.pretty_min_monoid(unwrapped1372) else: _dollar_dollar = msg if _dollar_dollar.HasField("max_monoid"): - _t1819 = _dollar_dollar.max_monoid + _t1830 = _dollar_dollar.max_monoid else: - _t1819 = None - deconstruct_result1359 = _t1819 - if deconstruct_result1359 is not None: - assert deconstruct_result1359 is not None - unwrapped1360 = deconstruct_result1359 - self.pretty_max_monoid(unwrapped1360) + _t1830 = None + deconstruct_result1369 = _t1830 + if deconstruct_result1369 is not None: + assert deconstruct_result1369 is not None + unwrapped1370 = deconstruct_result1369 + self.pretty_max_monoid(unwrapped1370) else: _dollar_dollar = msg if _dollar_dollar.HasField("sum_monoid"): - _t1820 = _dollar_dollar.sum_monoid + _t1831 = _dollar_dollar.sum_monoid else: - _t1820 = None - deconstruct_result1357 = _t1820 - if deconstruct_result1357 is not None: - assert deconstruct_result1357 is not None - unwrapped1358 = deconstruct_result1357 - self.pretty_sum_monoid(unwrapped1358) + _t1831 = None + deconstruct_result1367 = _t1831 + if deconstruct_result1367 is not None: + assert deconstruct_result1367 is not None + unwrapped1368 = deconstruct_result1367 + self.pretty_sum_monoid(unwrapped1368) else: raise ParseError("No matching rule for monoid") def pretty_or_monoid(self, msg: logic_pb2.OrMonoid): - fields1366 = msg + fields1376 = msg self.write("(or)") def pretty_min_monoid(self, msg: logic_pb2.MinMonoid): - flat1369 = self._try_flat(msg, self.pretty_min_monoid) - if flat1369 is not None: - assert flat1369 is not None - self.write(flat1369) + flat1379 = self._try_flat(msg, self.pretty_min_monoid) + if flat1379 is not None: + assert flat1379 is not None + self.write(flat1379) return None else: _dollar_dollar = msg - fields1367 = _dollar_dollar.type - assert fields1367 is not None - unwrapped_fields1368 = fields1367 + fields1377 = _dollar_dollar.type + assert fields1377 is not None + unwrapped_fields1378 = fields1377 self.write("(min") self.indent_sexp() self.newline() - self.pretty_type(unwrapped_fields1368) + self.pretty_type(unwrapped_fields1378) self.dedent() self.write(")") def pretty_max_monoid(self, msg: logic_pb2.MaxMonoid): - flat1372 = self._try_flat(msg, self.pretty_max_monoid) - if flat1372 is not None: - assert flat1372 is not None - self.write(flat1372) + flat1382 = self._try_flat(msg, self.pretty_max_monoid) + if flat1382 is not None: + assert flat1382 is not None + self.write(flat1382) return None else: _dollar_dollar = msg - fields1370 = _dollar_dollar.type - assert fields1370 is not None - unwrapped_fields1371 = fields1370 + fields1380 = _dollar_dollar.type + assert fields1380 is not None + unwrapped_fields1381 = fields1380 self.write("(max") self.indent_sexp() self.newline() - self.pretty_type(unwrapped_fields1371) + self.pretty_type(unwrapped_fields1381) self.dedent() self.write(")") def pretty_sum_monoid(self, msg: logic_pb2.SumMonoid): - flat1375 = self._try_flat(msg, self.pretty_sum_monoid) - if flat1375 is not None: - assert flat1375 is not None - self.write(flat1375) + flat1385 = self._try_flat(msg, self.pretty_sum_monoid) + if flat1385 is not None: + assert flat1385 is not None + self.write(flat1385) return None else: _dollar_dollar = msg - fields1373 = _dollar_dollar.type - assert fields1373 is not None - unwrapped_fields1374 = fields1373 + fields1383 = _dollar_dollar.type + assert fields1383 is not None + unwrapped_fields1384 = fields1383 self.write("(sum") self.indent_sexp() self.newline() - self.pretty_type(unwrapped_fields1374) + self.pretty_type(unwrapped_fields1384) self.dedent() self.write(")") def pretty_monus_def(self, msg: logic_pb2.MonusDef): - flat1383 = self._try_flat(msg, self.pretty_monus_def) - if flat1383 is not None: - assert flat1383 is not None - self.write(flat1383) + flat1393 = self._try_flat(msg, self.pretty_monus_def) + if flat1393 is not None: + assert flat1393 is not None + self.write(flat1393) return None else: _dollar_dollar = msg if not len(_dollar_dollar.attrs) == 0: - _t1821 = _dollar_dollar.attrs + _t1832 = _dollar_dollar.attrs else: - _t1821 = None - fields1376 = (_dollar_dollar.monoid, _dollar_dollar.name, (_dollar_dollar.body, _dollar_dollar.value_arity,), _t1821,) - assert fields1376 is not None - unwrapped_fields1377 = fields1376 + _t1832 = None + fields1386 = (_dollar_dollar.monoid, _dollar_dollar.name, (_dollar_dollar.body, _dollar_dollar.value_arity,), _t1832,) + assert fields1386 is not None + unwrapped_fields1387 = fields1386 self.write("(monus") self.indent_sexp() self.newline() - field1378 = unwrapped_fields1377[0] - self.pretty_monoid(field1378) + field1388 = unwrapped_fields1387[0] + self.pretty_monoid(field1388) self.newline() - field1379 = unwrapped_fields1377[1] - self.pretty_relation_id(field1379) + field1389 = unwrapped_fields1387[1] + self.pretty_relation_id(field1389) self.newline() - field1380 = unwrapped_fields1377[2] - self.pretty_abstraction_with_arity(field1380) - field1381 = unwrapped_fields1377[3] - if field1381 is not None: + field1390 = unwrapped_fields1387[2] + self.pretty_abstraction_with_arity(field1390) + field1391 = unwrapped_fields1387[3] + if field1391 is not None: self.newline() - assert field1381 is not None - opt_val1382 = field1381 - self.pretty_attrs(opt_val1382) + assert field1391 is not None + opt_val1392 = field1391 + self.pretty_attrs(opt_val1392) self.dedent() self.write(")") def pretty_constraint(self, msg: logic_pb2.Constraint): - flat1390 = self._try_flat(msg, self.pretty_constraint) - if flat1390 is not None: - assert flat1390 is not None - self.write(flat1390) + flat1400 = self._try_flat(msg, self.pretty_constraint) + if flat1400 is not None: + assert flat1400 is not None + self.write(flat1400) return None else: _dollar_dollar = msg - fields1384 = (_dollar_dollar.name, _dollar_dollar.functional_dependency.guard, _dollar_dollar.functional_dependency.keys, _dollar_dollar.functional_dependency.values,) - assert fields1384 is not None - unwrapped_fields1385 = fields1384 + fields1394 = (_dollar_dollar.name, _dollar_dollar.functional_dependency.guard, _dollar_dollar.functional_dependency.keys, _dollar_dollar.functional_dependency.values,) + assert fields1394 is not None + unwrapped_fields1395 = fields1394 self.write("(functional_dependency") self.indent_sexp() self.newline() - field1386 = unwrapped_fields1385[0] - self.pretty_relation_id(field1386) + field1396 = unwrapped_fields1395[0] + self.pretty_relation_id(field1396) self.newline() - field1387 = unwrapped_fields1385[1] - self.pretty_abstraction(field1387) + field1397 = unwrapped_fields1395[1] + self.pretty_abstraction(field1397) self.newline() - field1388 = unwrapped_fields1385[2] - self.pretty_functional_dependency_keys(field1388) + field1398 = unwrapped_fields1395[2] + self.pretty_functional_dependency_keys(field1398) self.newline() - field1389 = unwrapped_fields1385[3] - self.pretty_functional_dependency_values(field1389) + field1399 = unwrapped_fields1395[3] + self.pretty_functional_dependency_values(field1399) self.dedent() self.write(")") def pretty_functional_dependency_keys(self, msg: Sequence[logic_pb2.Var]): - flat1394 = self._try_flat(msg, self.pretty_functional_dependency_keys) - if flat1394 is not None: - assert flat1394 is not None - self.write(flat1394) + flat1404 = self._try_flat(msg, self.pretty_functional_dependency_keys) + if flat1404 is not None: + assert flat1404 is not None + self.write(flat1404) return None else: - fields1391 = msg + fields1401 = msg self.write("(keys") self.indent_sexp() - if not len(fields1391) == 0: + if not len(fields1401) == 0: self.newline() - for i1393, elem1392 in enumerate(fields1391): - if (i1393 > 0): + for i1403, elem1402 in enumerate(fields1401): + if (i1403 > 0): self.newline() - self.pretty_var(elem1392) + self.pretty_var(elem1402) self.dedent() self.write(")") def pretty_functional_dependency_values(self, msg: Sequence[logic_pb2.Var]): - flat1398 = self._try_flat(msg, self.pretty_functional_dependency_values) - if flat1398 is not None: - assert flat1398 is not None - self.write(flat1398) + flat1408 = self._try_flat(msg, self.pretty_functional_dependency_values) + if flat1408 is not None: + assert flat1408 is not None + self.write(flat1408) return None else: - fields1395 = msg + fields1405 = msg self.write("(values") self.indent_sexp() - if not len(fields1395) == 0: + if not len(fields1405) == 0: self.newline() - for i1397, elem1396 in enumerate(fields1395): - if (i1397 > 0): + for i1407, elem1406 in enumerate(fields1405): + if (i1407 > 0): self.newline() - self.pretty_var(elem1396) + self.pretty_var(elem1406) self.dedent() self.write(")") def pretty_data(self, msg: logic_pb2.Data): - flat1407 = self._try_flat(msg, self.pretty_data) - if flat1407 is not None: - assert flat1407 is not None - self.write(flat1407) + flat1417 = self._try_flat(msg, self.pretty_data) + if flat1417 is not None: + assert flat1417 is not None + self.write(flat1417) return None else: _dollar_dollar = msg if _dollar_dollar.HasField("edb"): - _t1822 = _dollar_dollar.edb + _t1833 = _dollar_dollar.edb else: - _t1822 = None - deconstruct_result1405 = _t1822 - if deconstruct_result1405 is not None: - assert deconstruct_result1405 is not None - unwrapped1406 = deconstruct_result1405 - self.pretty_edb(unwrapped1406) + _t1833 = None + deconstruct_result1415 = _t1833 + if deconstruct_result1415 is not None: + assert deconstruct_result1415 is not None + unwrapped1416 = deconstruct_result1415 + self.pretty_edb(unwrapped1416) else: _dollar_dollar = msg if _dollar_dollar.HasField("betree_relation"): - _t1823 = _dollar_dollar.betree_relation + _t1834 = _dollar_dollar.betree_relation else: - _t1823 = None - deconstruct_result1403 = _t1823 - if deconstruct_result1403 is not None: - assert deconstruct_result1403 is not None - unwrapped1404 = deconstruct_result1403 - self.pretty_betree_relation(unwrapped1404) + _t1834 = None + deconstruct_result1413 = _t1834 + if deconstruct_result1413 is not None: + assert deconstruct_result1413 is not None + unwrapped1414 = deconstruct_result1413 + self.pretty_betree_relation(unwrapped1414) else: _dollar_dollar = msg if _dollar_dollar.HasField("csv_data"): - _t1824 = _dollar_dollar.csv_data + _t1835 = _dollar_dollar.csv_data else: - _t1824 = None - deconstruct_result1401 = _t1824 - if deconstruct_result1401 is not None: - assert deconstruct_result1401 is not None - unwrapped1402 = deconstruct_result1401 - self.pretty_csv_data(unwrapped1402) + _t1835 = None + deconstruct_result1411 = _t1835 + if deconstruct_result1411 is not None: + assert deconstruct_result1411 is not None + unwrapped1412 = deconstruct_result1411 + self.pretty_csv_data(unwrapped1412) else: _dollar_dollar = msg if _dollar_dollar.HasField("iceberg_data"): - _t1825 = _dollar_dollar.iceberg_data + _t1836 = _dollar_dollar.iceberg_data else: - _t1825 = None - deconstruct_result1399 = _t1825 - if deconstruct_result1399 is not None: - assert deconstruct_result1399 is not None - unwrapped1400 = deconstruct_result1399 - self.pretty_iceberg_data(unwrapped1400) + _t1836 = None + deconstruct_result1409 = _t1836 + if deconstruct_result1409 is not None: + assert deconstruct_result1409 is not None + unwrapped1410 = deconstruct_result1409 + self.pretty_iceberg_data(unwrapped1410) else: raise ParseError("No matching rule for data") def pretty_edb(self, msg: logic_pb2.EDB): - flat1413 = self._try_flat(msg, self.pretty_edb) - if flat1413 is not None: - assert flat1413 is not None - self.write(flat1413) + flat1423 = self._try_flat(msg, self.pretty_edb) + if flat1423 is not None: + assert flat1423 is not None + self.write(flat1423) return None else: _dollar_dollar = msg - fields1408 = (_dollar_dollar.target_id, _dollar_dollar.path, _dollar_dollar.types,) - assert fields1408 is not None - unwrapped_fields1409 = fields1408 + fields1418 = (_dollar_dollar.target_id, _dollar_dollar.path, _dollar_dollar.types,) + assert fields1418 is not None + unwrapped_fields1419 = fields1418 self.write("(edb") self.indent_sexp() self.newline() - field1410 = unwrapped_fields1409[0] - self.pretty_relation_id(field1410) + field1420 = unwrapped_fields1419[0] + self.pretty_relation_id(field1420) self.newline() - field1411 = unwrapped_fields1409[1] - self.pretty_edb_path(field1411) + field1421 = unwrapped_fields1419[1] + self.pretty_edb_path(field1421) self.newline() - field1412 = unwrapped_fields1409[2] - self.pretty_edb_types(field1412) + field1422 = unwrapped_fields1419[2] + self.pretty_edb_types(field1422) self.dedent() self.write(")") def pretty_edb_path(self, msg: Sequence[str]): - flat1417 = self._try_flat(msg, self.pretty_edb_path) - if flat1417 is not None: - assert flat1417 is not None - self.write(flat1417) + flat1427 = self._try_flat(msg, self.pretty_edb_path) + if flat1427 is not None: + assert flat1427 is not None + self.write(flat1427) return None else: - fields1414 = msg + fields1424 = msg self.write("[") self.indent() - for i1416, elem1415 in enumerate(fields1414): - if (i1416 > 0): + for i1426, elem1425 in enumerate(fields1424): + if (i1426 > 0): self.newline() - self.write(self.format_string_value(elem1415)) + self.write(self.format_string_value(elem1425)) self.dedent() self.write("]") def pretty_edb_types(self, msg: Sequence[logic_pb2.Type]): - flat1421 = self._try_flat(msg, self.pretty_edb_types) - if flat1421 is not None: - assert flat1421 is not None - self.write(flat1421) + flat1431 = self._try_flat(msg, self.pretty_edb_types) + if flat1431 is not None: + assert flat1431 is not None + self.write(flat1431) return None else: - fields1418 = msg + fields1428 = msg self.write("[") self.indent() - for i1420, elem1419 in enumerate(fields1418): - if (i1420 > 0): + for i1430, elem1429 in enumerate(fields1428): + if (i1430 > 0): self.newline() - self.pretty_type(elem1419) + self.pretty_type(elem1429) self.dedent() self.write("]") def pretty_betree_relation(self, msg: logic_pb2.BeTreeRelation): - flat1426 = self._try_flat(msg, self.pretty_betree_relation) - if flat1426 is not None: - assert flat1426 is not None - self.write(flat1426) + flat1436 = self._try_flat(msg, self.pretty_betree_relation) + if flat1436 is not None: + assert flat1436 is not None + self.write(flat1436) return None else: _dollar_dollar = msg - fields1422 = (_dollar_dollar.name, _dollar_dollar.relation_info,) - assert fields1422 is not None - unwrapped_fields1423 = fields1422 + fields1432 = (_dollar_dollar.name, _dollar_dollar.relation_info,) + assert fields1432 is not None + unwrapped_fields1433 = fields1432 self.write("(betree_relation") self.indent_sexp() self.newline() - field1424 = unwrapped_fields1423[0] - self.pretty_relation_id(field1424) + field1434 = unwrapped_fields1433[0] + self.pretty_relation_id(field1434) self.newline() - field1425 = unwrapped_fields1423[1] - self.pretty_betree_info(field1425) + field1435 = unwrapped_fields1433[1] + self.pretty_betree_info(field1435) self.dedent() self.write(")") def pretty_betree_info(self, msg: logic_pb2.BeTreeInfo): - flat1432 = self._try_flat(msg, self.pretty_betree_info) - if flat1432 is not None: - assert flat1432 is not None - self.write(flat1432) + flat1442 = self._try_flat(msg, self.pretty_betree_info) + if flat1442 is not None: + assert flat1442 is not None + self.write(flat1442) return None else: _dollar_dollar = msg - _t1826 = self.deconstruct_betree_info_config(_dollar_dollar) - fields1427 = (_dollar_dollar.key_types, _dollar_dollar.value_types, _t1826,) - assert fields1427 is not None - unwrapped_fields1428 = fields1427 + _t1837 = self.deconstruct_betree_info_config(_dollar_dollar) + fields1437 = (_dollar_dollar.key_types, _dollar_dollar.value_types, _t1837,) + assert fields1437 is not None + unwrapped_fields1438 = fields1437 self.write("(betree_info") self.indent_sexp() self.newline() - field1429 = unwrapped_fields1428[0] - self.pretty_betree_info_key_types(field1429) + field1439 = unwrapped_fields1438[0] + self.pretty_betree_info_key_types(field1439) self.newline() - field1430 = unwrapped_fields1428[1] - self.pretty_betree_info_value_types(field1430) + field1440 = unwrapped_fields1438[1] + self.pretty_betree_info_value_types(field1440) self.newline() - field1431 = unwrapped_fields1428[2] - self.pretty_config_dict(field1431) + field1441 = unwrapped_fields1438[2] + self.pretty_config_dict(field1441) self.dedent() self.write(")") def pretty_betree_info_key_types(self, msg: Sequence[logic_pb2.Type]): - flat1436 = self._try_flat(msg, self.pretty_betree_info_key_types) - if flat1436 is not None: - assert flat1436 is not None - self.write(flat1436) + flat1446 = self._try_flat(msg, self.pretty_betree_info_key_types) + if flat1446 is not None: + assert flat1446 is not None + self.write(flat1446) return None else: - fields1433 = msg + fields1443 = msg self.write("(key_types") self.indent_sexp() - if not len(fields1433) == 0: + if not len(fields1443) == 0: self.newline() - for i1435, elem1434 in enumerate(fields1433): - if (i1435 > 0): + for i1445, elem1444 in enumerate(fields1443): + if (i1445 > 0): self.newline() - self.pretty_type(elem1434) + self.pretty_type(elem1444) self.dedent() self.write(")") def pretty_betree_info_value_types(self, msg: Sequence[logic_pb2.Type]): - flat1440 = self._try_flat(msg, self.pretty_betree_info_value_types) - if flat1440 is not None: - assert flat1440 is not None - self.write(flat1440) + flat1450 = self._try_flat(msg, self.pretty_betree_info_value_types) + if flat1450 is not None: + assert flat1450 is not None + self.write(flat1450) return None else: - fields1437 = msg + fields1447 = msg self.write("(value_types") self.indent_sexp() - if not len(fields1437) == 0: + if not len(fields1447) == 0: self.newline() - for i1439, elem1438 in enumerate(fields1437): - if (i1439 > 0): + for i1449, elem1448 in enumerate(fields1447): + if (i1449 > 0): self.newline() - self.pretty_type(elem1438) + self.pretty_type(elem1448) self.dedent() self.write(")") def pretty_csv_data(self, msg: logic_pb2.CSVData): - flat1450 = self._try_flat(msg, self.pretty_csv_data) - if flat1450 is not None: - assert flat1450 is not None - self.write(flat1450) + flat1460 = self._try_flat(msg, self.pretty_csv_data) + if flat1460 is not None: + assert flat1460 is not None + self.write(flat1460) return None else: _dollar_dollar = msg - _t1827 = self.deconstruct_csv_data_columns_optional(_dollar_dollar) - _t1828 = self.deconstruct_csv_data_relations_optional(_dollar_dollar) - fields1441 = (_dollar_dollar.locator, _dollar_dollar.config, _t1827, _t1828, _dollar_dollar.asof,) - assert fields1441 is not None - unwrapped_fields1442 = fields1441 + _t1838 = self.deconstruct_csv_data_columns_optional(_dollar_dollar) + _t1839 = self.deconstruct_csv_data_relations_optional(_dollar_dollar) + fields1451 = (_dollar_dollar.locator, _dollar_dollar.config, _t1838, _t1839, _dollar_dollar.asof,) + assert fields1451 is not None + unwrapped_fields1452 = fields1451 self.write("(csv_data") self.indent_sexp() self.newline() - field1443 = unwrapped_fields1442[0] - self.pretty_csvlocator(field1443) + field1453 = unwrapped_fields1452[0] + self.pretty_csvlocator(field1453) self.newline() - field1444 = unwrapped_fields1442[1] - self.pretty_csv_config(field1444) - field1445 = unwrapped_fields1442[2] - if field1445 is not None: + field1454 = unwrapped_fields1452[1] + self.pretty_csv_config(field1454) + field1455 = unwrapped_fields1452[2] + if field1455 is not None: self.newline() - assert field1445 is not None - opt_val1446 = field1445 - self.pretty_gnf_columns(opt_val1446) - field1447 = unwrapped_fields1442[3] - if field1447 is not None: + assert field1455 is not None + opt_val1456 = field1455 + self.pretty_gnf_columns(opt_val1456) + field1457 = unwrapped_fields1452[3] + if field1457 is not None: self.newline() - assert field1447 is not None - opt_val1448 = field1447 - self.pretty_target_relations(opt_val1448) + assert field1457 is not None + opt_val1458 = field1457 + self.pretty_target_relations(opt_val1458) self.newline() - field1449 = unwrapped_fields1442[4] - self.pretty_csv_asof(field1449) + field1459 = unwrapped_fields1452[4] + self.pretty_csv_asof(field1459) self.dedent() self.write(")") def pretty_csvlocator(self, msg: logic_pb2.CSVLocator): - flat1457 = self._try_flat(msg, self.pretty_csvlocator) - if flat1457 is not None: - assert flat1457 is not None - self.write(flat1457) + flat1467 = self._try_flat(msg, self.pretty_csvlocator) + if flat1467 is not None: + assert flat1467 is not None + self.write(flat1467) return None else: _dollar_dollar = msg if not len(_dollar_dollar.paths) == 0: - _t1829 = _dollar_dollar.paths + _t1840 = _dollar_dollar.paths else: - _t1829 = None + _t1840 = None if _dollar_dollar.inline_data.decode('utf-8') != "": - _t1830 = _dollar_dollar.inline_data.decode('utf-8') + _t1841 = _dollar_dollar.inline_data.decode('utf-8') else: - _t1830 = None - fields1451 = (_t1829, _t1830,) - assert fields1451 is not None - unwrapped_fields1452 = fields1451 + _t1841 = None + fields1461 = (_t1840, _t1841,) + assert fields1461 is not None + unwrapped_fields1462 = fields1461 self.write("(csv_locator") self.indent_sexp() - field1453 = unwrapped_fields1452[0] - if field1453 is not None: + field1463 = unwrapped_fields1462[0] + if field1463 is not None: self.newline() - assert field1453 is not None - opt_val1454 = field1453 - self.pretty_csv_locator_paths(opt_val1454) - field1455 = unwrapped_fields1452[1] - if field1455 is not None: + assert field1463 is not None + opt_val1464 = field1463 + self.pretty_csv_locator_paths(opt_val1464) + field1465 = unwrapped_fields1462[1] + if field1465 is not None: self.newline() - assert field1455 is not None - opt_val1456 = field1455 - self.pretty_csv_locator_inline_data(opt_val1456) + assert field1465 is not None + opt_val1466 = field1465 + self.pretty_csv_locator_inline_data(opt_val1466) self.dedent() self.write(")") def pretty_csv_locator_paths(self, msg: Sequence[str]): - flat1461 = self._try_flat(msg, self.pretty_csv_locator_paths) - if flat1461 is not None: - assert flat1461 is not None - self.write(flat1461) + flat1471 = self._try_flat(msg, self.pretty_csv_locator_paths) + if flat1471 is not None: + assert flat1471 is not None + self.write(flat1471) return None else: - fields1458 = msg + fields1468 = msg self.write("(paths") self.indent_sexp() - if not len(fields1458) == 0: + if not len(fields1468) == 0: self.newline() - for i1460, elem1459 in enumerate(fields1458): - if (i1460 > 0): + for i1470, elem1469 in enumerate(fields1468): + if (i1470 > 0): self.newline() - self.write(self.format_string_value(elem1459)) + self.write(self.format_string_value(elem1469)) self.dedent() self.write(")") def pretty_csv_locator_inline_data(self, msg: str): - flat1463 = self._try_flat(msg, self.pretty_csv_locator_inline_data) - if flat1463 is not None: - assert flat1463 is not None - self.write(flat1463) + flat1473 = self._try_flat(msg, self.pretty_csv_locator_inline_data) + if flat1473 is not None: + assert flat1473 is not None + self.write(flat1473) return None else: - fields1462 = msg + fields1472 = msg self.write("(inline_data") self.indent_sexp() self.newline() - self.write(self.format_string_value(fields1462)) + self.write(self.format_string_value(fields1472)) self.dedent() self.write(")") def pretty_csv_config(self, msg: logic_pb2.CSVConfig): - flat1469 = self._try_flat(msg, self.pretty_csv_config) - if flat1469 is not None: - assert flat1469 is not None - self.write(flat1469) + flat1479 = self._try_flat(msg, self.pretty_csv_config) + if flat1479 is not None: + assert flat1479 is not None + self.write(flat1479) return None else: _dollar_dollar = msg - _t1831 = self.deconstruct_csv_config(_dollar_dollar) - _t1832 = self.deconstruct_csv_storage_integration_optional(_dollar_dollar) - fields1464 = (_t1831, _t1832,) - assert fields1464 is not None - unwrapped_fields1465 = fields1464 + _t1842 = self.deconstruct_csv_config(_dollar_dollar) + _t1843 = self.deconstruct_csv_storage_integration_optional(_dollar_dollar) + fields1474 = (_t1842, _t1843,) + assert fields1474 is not None + unwrapped_fields1475 = fields1474 self.write("(csv_config") self.indent_sexp() self.newline() - field1466 = unwrapped_fields1465[0] - self.pretty_config_dict(field1466) - field1467 = unwrapped_fields1465[1] - if field1467 is not None: + field1476 = unwrapped_fields1475[0] + self.pretty_config_dict(field1476) + field1477 = unwrapped_fields1475[1] + if field1477 is not None: self.newline() - assert field1467 is not None - opt_val1468 = field1467 - self.pretty__storage_integration(opt_val1468) + assert field1477 is not None + opt_val1478 = field1477 + self.pretty__storage_integration(opt_val1478) self.dedent() self.write(")") def pretty__storage_integration(self, msg: Sequence[tuple[str, logic_pb2.Value]]): - flat1471 = self._try_flat(msg, self.pretty__storage_integration) - if flat1471 is not None: - assert flat1471 is not None - self.write(flat1471) + flat1481 = self._try_flat(msg, self.pretty__storage_integration) + if flat1481 is not None: + assert flat1481 is not None + self.write(flat1481) return None else: - fields1470 = msg + fields1480 = msg self.write("(storage_integration") self.indent_sexp() self.newline() - self.pretty_config_dict(fields1470) + self.pretty_config_dict(fields1480) self.dedent() self.write(")") def pretty_gnf_columns(self, msg: Sequence[logic_pb2.GNFColumn]): - flat1475 = self._try_flat(msg, self.pretty_gnf_columns) - if flat1475 is not None: - assert flat1475 is not None - self.write(flat1475) + flat1485 = self._try_flat(msg, self.pretty_gnf_columns) + if flat1485 is not None: + assert flat1485 is not None + self.write(flat1485) return None else: - fields1472 = msg + fields1482 = msg self.write("(columns") self.indent_sexp() - if not len(fields1472) == 0: + if not len(fields1482) == 0: self.newline() - for i1474, elem1473 in enumerate(fields1472): - if (i1474 > 0): + for i1484, elem1483 in enumerate(fields1482): + if (i1484 > 0): self.newline() - self.pretty_gnf_column(elem1473) + self.pretty_gnf_column(elem1483) self.dedent() self.write(")") def pretty_gnf_column(self, msg: logic_pb2.GNFColumn): - flat1484 = self._try_flat(msg, self.pretty_gnf_column) - if flat1484 is not None: - assert flat1484 is not None - self.write(flat1484) + flat1494 = self._try_flat(msg, self.pretty_gnf_column) + if flat1494 is not None: + assert flat1494 is not None + self.write(flat1494) return None else: _dollar_dollar = msg if _dollar_dollar.HasField("target_id"): - _t1833 = _dollar_dollar.target_id + _t1844 = _dollar_dollar.target_id else: - _t1833 = None - fields1476 = (_dollar_dollar.column_path, _t1833, _dollar_dollar.types,) - assert fields1476 is not None - unwrapped_fields1477 = fields1476 + _t1844 = None + fields1486 = (_dollar_dollar.column_path, _t1844, _dollar_dollar.types,) + assert fields1486 is not None + unwrapped_fields1487 = fields1486 self.write("(column") self.indent_sexp() self.newline() - field1478 = unwrapped_fields1477[0] - self.pretty_gnf_column_path(field1478) - field1479 = unwrapped_fields1477[1] - if field1479 is not None: + field1488 = unwrapped_fields1487[0] + self.pretty_gnf_column_path(field1488) + field1489 = unwrapped_fields1487[1] + if field1489 is not None: self.newline() - assert field1479 is not None - opt_val1480 = field1479 - self.pretty_relation_id(opt_val1480) + assert field1489 is not None + opt_val1490 = field1489 + self.pretty_relation_id(opt_val1490) self.newline() self.write("[") - field1481 = unwrapped_fields1477[2] - for i1483, elem1482 in enumerate(field1481): - if (i1483 > 0): + field1491 = unwrapped_fields1487[2] + for i1493, elem1492 in enumerate(field1491): + if (i1493 > 0): self.newline() - self.pretty_type(elem1482) + self.pretty_type(elem1492) self.write("]") self.dedent() self.write(")") def pretty_gnf_column_path(self, msg: Sequence[str]): - flat1491 = self._try_flat(msg, self.pretty_gnf_column_path) - if flat1491 is not None: - assert flat1491 is not None - self.write(flat1491) + flat1501 = self._try_flat(msg, self.pretty_gnf_column_path) + if flat1501 is not None: + assert flat1501 is not None + self.write(flat1501) return None else: _dollar_dollar = msg if len(_dollar_dollar) == 1: - _t1834 = _dollar_dollar[0] + _t1845 = _dollar_dollar[0] else: - _t1834 = None - deconstruct_result1489 = _t1834 - if deconstruct_result1489 is not None: - assert deconstruct_result1489 is not None - unwrapped1490 = deconstruct_result1489 - self.write(self.format_string_value(unwrapped1490)) + _t1845 = None + deconstruct_result1499 = _t1845 + if deconstruct_result1499 is not None: + assert deconstruct_result1499 is not None + unwrapped1500 = deconstruct_result1499 + self.write(self.format_string_value(unwrapped1500)) else: _dollar_dollar = msg if len(_dollar_dollar) != 1: - _t1835 = _dollar_dollar + _t1846 = _dollar_dollar else: - _t1835 = None - deconstruct_result1485 = _t1835 - if deconstruct_result1485 is not None: - assert deconstruct_result1485 is not None - unwrapped1486 = deconstruct_result1485 + _t1846 = None + deconstruct_result1495 = _t1846 + if deconstruct_result1495 is not None: + assert deconstruct_result1495 is not None + unwrapped1496 = deconstruct_result1495 self.write("[") self.indent() - for i1488, elem1487 in enumerate(unwrapped1486): - if (i1488 > 0): + for i1498, elem1497 in enumerate(unwrapped1496): + if (i1498 > 0): self.newline() - self.write(self.format_string_value(elem1487)) + self.write(self.format_string_value(elem1497)) self.dedent() self.write("]") else: raise ParseError("No matching rule for gnf_column_path") def pretty_target_relations(self, msg: logic_pb2.TargetRelations): - flat1498 = self._try_flat(msg, self.pretty_target_relations) - if flat1498 is not None: - assert flat1498 is not None - self.write(flat1498) + flat1508 = self._try_flat(msg, self.pretty_target_relations) + if flat1508 is not None: + assert flat1508 is not None + self.write(flat1508) return None else: _dollar_dollar = msg - _t1836 = self.deconstruct_relation_keys(_dollar_dollar) - _t1837 = self.deconstruct_load_errors_optional(_dollar_dollar) - fields1492 = (_t1836, _dollar_dollar, _t1837,) - assert fields1492 is not None - unwrapped_fields1493 = fields1492 + _t1847 = self.deconstruct_relation_keys(_dollar_dollar) + _t1848 = self.deconstruct_load_errors_optional(_dollar_dollar) + fields1502 = (_t1847, _dollar_dollar, _t1848,) + assert fields1502 is not None + unwrapped_fields1503 = fields1502 self.write("(relations") self.indent_sexp() self.newline() - field1494 = unwrapped_fields1493[0] - self.pretty_relation_keys(field1494) + field1504 = unwrapped_fields1503[0] + self.pretty_relation_keys(field1504) self.newline() - field1495 = unwrapped_fields1493[1] - self.pretty_relation_body(field1495) - field1496 = unwrapped_fields1493[2] - if field1496 is not None: + field1505 = unwrapped_fields1503[1] + self.pretty_relation_body(field1505) + field1506 = unwrapped_fields1503[2] + if field1506 is not None: self.newline() - assert field1496 is not None - opt_val1497 = field1496 - self.pretty_load_errors(opt_val1497) + assert field1506 is not None + opt_val1507 = field1506 + self.pretty_load_errors(opt_val1507) self.dedent() self.write(")") def pretty_relation_keys(self, msg: tuple[Sequence[logic_pb2.NamedColumn], bool]): - flat1505 = self._try_flat(msg, self.pretty_relation_keys) - if flat1505 is not None: - assert flat1505 is not None - self.write(flat1505) + flat1515 = self._try_flat(msg, self.pretty_relation_keys) + if flat1515 is not None: + assert flat1515 is not None + self.write(flat1515) return None else: _dollar_dollar = msg if not _dollar_dollar[1]: - _t1838 = _dollar_dollar[0] + _t1849 = _dollar_dollar[0] else: - _t1838 = None - deconstruct_result1501 = _t1838 - if deconstruct_result1501 is not None: - assert deconstruct_result1501 is not None - unwrapped1502 = deconstruct_result1501 + _t1849 = None + deconstruct_result1511 = _t1849 + if deconstruct_result1511 is not None: + assert deconstruct_result1511 is not None + unwrapped1512 = deconstruct_result1511 self.write("(keys") self.indent_sexp() - if not len(unwrapped1502) == 0: + if not len(unwrapped1512) == 0: self.newline() - for i1504, elem1503 in enumerate(unwrapped1502): - if (i1504 > 0): + for i1514, elem1513 in enumerate(unwrapped1512): + if (i1514 > 0): self.newline() - self.pretty_named_column(elem1503) + self.pretty_named_column(elem1513) self.dedent() self.write(")") else: _dollar_dollar = msg if _dollar_dollar[1]: - _t1839 = () + _t1850 = () else: - _t1839 = None - deconstruct_result1499 = _t1839 - if deconstruct_result1499 is not None: - assert deconstruct_result1499 is not None - unwrapped1500 = deconstruct_result1499 + _t1850 = None + deconstruct_result1509 = _t1850 + if deconstruct_result1509 is not None: + assert deconstruct_result1509 is not None + unwrapped1510 = deconstruct_result1509 self.write("(keys") self.newline() self.write("synthetic)") @@ -3666,1023 +3695,1023 @@ def pretty_relation_keys(self, msg: tuple[Sequence[logic_pb2.NamedColumn], bool] raise ParseError("No matching rule for relation_keys") def pretty_named_column(self, msg: logic_pb2.NamedColumn): - flat1510 = self._try_flat(msg, self.pretty_named_column) - if flat1510 is not None: - assert flat1510 is not None - self.write(flat1510) + flat1520 = self._try_flat(msg, self.pretty_named_column) + if flat1520 is not None: + assert flat1520 is not None + self.write(flat1520) return None else: _dollar_dollar = msg - fields1506 = (_dollar_dollar.name, _dollar_dollar.type,) - assert fields1506 is not None - unwrapped_fields1507 = fields1506 + fields1516 = (_dollar_dollar.name, _dollar_dollar.type,) + assert fields1516 is not None + unwrapped_fields1517 = fields1516 self.write("(column") self.indent_sexp() self.newline() - field1508 = unwrapped_fields1507[0] - self.write(self.format_string_value(field1508)) + field1518 = unwrapped_fields1517[0] + self.write(self.format_string_value(field1518)) self.newline() - field1509 = unwrapped_fields1507[1] - self.pretty_type(field1509) + field1519 = unwrapped_fields1517[1] + self.pretty_type(field1519) self.dedent() self.write(")") def pretty_relation_body(self, msg: logic_pb2.TargetRelations): - flat1517 = self._try_flat(msg, self.pretty_relation_body) - if flat1517 is not None: - assert flat1517 is not None - self.write(flat1517) + flat1527 = self._try_flat(msg, self.pretty_relation_body) + if flat1527 is not None: + assert flat1527 is not None + self.write(flat1527) return None else: _dollar_dollar = msg if _dollar_dollar.HasField("plain"): - _t1840 = _dollar_dollar.plain.targets + _t1851 = _dollar_dollar.plain.targets else: - _t1840 = None - deconstruct_result1515 = _t1840 - if deconstruct_result1515 is not None: - assert deconstruct_result1515 is not None - unwrapped1516 = deconstruct_result1515 - self.pretty_non_cdc_relations(unwrapped1516) + _t1851 = None + deconstruct_result1525 = _t1851 + if deconstruct_result1525 is not None: + assert deconstruct_result1525 is not None + unwrapped1526 = deconstruct_result1525 + self.pretty_non_cdc_relations(unwrapped1526) else: _dollar_dollar = msg if _dollar_dollar.HasField("cdc"): - _t1841 = (_dollar_dollar.cdc.inserts, _dollar_dollar.cdc.deletes,) + _t1852 = (_dollar_dollar.cdc.inserts, _dollar_dollar.cdc.deletes,) else: - _t1841 = None - deconstruct_result1511 = _t1841 - if deconstruct_result1511 is not None: - assert deconstruct_result1511 is not None - unwrapped1512 = deconstruct_result1511 - field1513 = unwrapped1512[0] - self.pretty_cdc_inserts(field1513) + _t1852 = None + deconstruct_result1521 = _t1852 + if deconstruct_result1521 is not None: + assert deconstruct_result1521 is not None + unwrapped1522 = deconstruct_result1521 + field1523 = unwrapped1522[0] + self.pretty_cdc_inserts(field1523) self.write(" ") - field1514 = unwrapped1512[1] - self.pretty_cdc_deletes(field1514) + field1524 = unwrapped1522[1] + self.pretty_cdc_deletes(field1524) else: raise ParseError("No matching rule for relation_body") def pretty_non_cdc_relations(self, msg: Sequence[logic_pb2.TargetRelation]): - flat1521 = self._try_flat(msg, self.pretty_non_cdc_relations) - if flat1521 is not None: - assert flat1521 is not None - self.write(flat1521) + flat1531 = self._try_flat(msg, self.pretty_non_cdc_relations) + if flat1531 is not None: + assert flat1531 is not None + self.write(flat1531) return None else: - fields1518 = msg - for i1520, elem1519 in enumerate(fields1518): - if (i1520 > 0): + fields1528 = msg + for i1530, elem1529 in enumerate(fields1528): + if (i1530 > 0): self.newline() - self.pretty_target_relation(elem1519) + self.pretty_target_relation(elem1529) def pretty_target_relation(self, msg: logic_pb2.TargetRelation): - flat1528 = self._try_flat(msg, self.pretty_target_relation) - if flat1528 is not None: - assert flat1528 is not None - self.write(flat1528) + flat1538 = self._try_flat(msg, self.pretty_target_relation) + if flat1538 is not None: + assert flat1538 is not None + self.write(flat1538) return None else: _dollar_dollar = msg - fields1522 = (_dollar_dollar.target_id, _dollar_dollar.values,) - assert fields1522 is not None - unwrapped_fields1523 = fields1522 + fields1532 = (_dollar_dollar.target_id, _dollar_dollar.values,) + assert fields1532 is not None + unwrapped_fields1533 = fields1532 self.write("(relation") self.indent_sexp() self.newline() - field1524 = unwrapped_fields1523[0] - self.pretty_relation_id(field1524) - field1525 = unwrapped_fields1523[1] - if not len(field1525) == 0: + field1534 = unwrapped_fields1533[0] + self.pretty_relation_id(field1534) + field1535 = unwrapped_fields1533[1] + if not len(field1535) == 0: self.newline() - for i1527, elem1526 in enumerate(field1525): - if (i1527 > 0): + for i1537, elem1536 in enumerate(field1535): + if (i1537 > 0): self.newline() - self.pretty_named_column(elem1526) + self.pretty_named_column(elem1536) self.dedent() self.write(")") def pretty_cdc_inserts(self, msg: Sequence[logic_pb2.TargetRelation]): - flat1532 = self._try_flat(msg, self.pretty_cdc_inserts) - if flat1532 is not None: - assert flat1532 is not None - self.write(flat1532) + flat1542 = self._try_flat(msg, self.pretty_cdc_inserts) + if flat1542 is not None: + assert flat1542 is not None + self.write(flat1542) return None else: - fields1529 = msg + fields1539 = msg self.write("(inserts") self.indent_sexp() - if not len(fields1529) == 0: + if not len(fields1539) == 0: self.newline() - for i1531, elem1530 in enumerate(fields1529): - if (i1531 > 0): + for i1541, elem1540 in enumerate(fields1539): + if (i1541 > 0): self.newline() - self.pretty_target_relation(elem1530) + self.pretty_target_relation(elem1540) self.dedent() self.write(")") def pretty_cdc_deletes(self, msg: Sequence[logic_pb2.TargetRelation]): - flat1536 = self._try_flat(msg, self.pretty_cdc_deletes) - if flat1536 is not None: - assert flat1536 is not None - self.write(flat1536) + flat1546 = self._try_flat(msg, self.pretty_cdc_deletes) + if flat1546 is not None: + assert flat1546 is not None + self.write(flat1546) return None else: - fields1533 = msg + fields1543 = msg self.write("(deletes") self.indent_sexp() - if not len(fields1533) == 0: + if not len(fields1543) == 0: self.newline() - for i1535, elem1534 in enumerate(fields1533): - if (i1535 > 0): + for i1545, elem1544 in enumerate(fields1543): + if (i1545 > 0): self.newline() - self.pretty_target_relation(elem1534) + self.pretty_target_relation(elem1544) self.dedent() self.write(")") def pretty_load_errors(self, msg: logic_pb2.RelationId): - flat1538 = self._try_flat(msg, self.pretty_load_errors) - if flat1538 is not None: - assert flat1538 is not None - self.write(flat1538) + flat1548 = self._try_flat(msg, self.pretty_load_errors) + if flat1548 is not None: + assert flat1548 is not None + self.write(flat1548) return None else: - fields1537 = msg + fields1547 = msg self.write("(load_errors") self.indent_sexp() self.newline() - self.pretty_relation_id(fields1537) + self.pretty_relation_id(fields1547) self.dedent() self.write(")") def pretty_csv_asof(self, msg: str): - flat1540 = self._try_flat(msg, self.pretty_csv_asof) - if flat1540 is not None: - assert flat1540 is not None - self.write(flat1540) + flat1550 = self._try_flat(msg, self.pretty_csv_asof) + if flat1550 is not None: + assert flat1550 is not None + self.write(flat1550) return None else: - fields1539 = msg + fields1549 = msg self.write("(asof") self.indent_sexp() self.newline() - self.write(self.format_string_value(fields1539)) + self.write(self.format_string_value(fields1549)) self.dedent() self.write(")") def pretty_iceberg_data(self, msg: logic_pb2.IcebergData): - flat1551 = self._try_flat(msg, self.pretty_iceberg_data) - if flat1551 is not None: - assert flat1551 is not None - self.write(flat1551) + flat1561 = self._try_flat(msg, self.pretty_iceberg_data) + if flat1561 is not None: + assert flat1561 is not None + self.write(flat1561) return None else: _dollar_dollar = msg - _t1842 = self.deconstruct_iceberg_data_from_snapshot_optional(_dollar_dollar) - _t1843 = self.deconstruct_iceberg_data_to_snapshot_optional(_dollar_dollar) - fields1541 = (_dollar_dollar.locator, _dollar_dollar.config, _dollar_dollar.columns, _t1842, _t1843, _dollar_dollar.returns_delta,) - assert fields1541 is not None - unwrapped_fields1542 = fields1541 + _t1853 = self.deconstruct_iceberg_data_from_snapshot_optional(_dollar_dollar) + _t1854 = self.deconstruct_iceberg_data_to_snapshot_optional(_dollar_dollar) + fields1551 = (_dollar_dollar.locator, _dollar_dollar.config, _dollar_dollar.columns, _t1853, _t1854, _dollar_dollar.returns_delta,) + assert fields1551 is not None + unwrapped_fields1552 = fields1551 self.write("(iceberg_data") self.indent_sexp() self.newline() - field1543 = unwrapped_fields1542[0] - self.pretty_iceberg_locator(field1543) + field1553 = unwrapped_fields1552[0] + self.pretty_iceberg_locator(field1553) self.newline() - field1544 = unwrapped_fields1542[1] - self.pretty_iceberg_catalog_config(field1544) + field1554 = unwrapped_fields1552[1] + self.pretty_iceberg_catalog_config(field1554) self.newline() - field1545 = unwrapped_fields1542[2] - self.pretty_gnf_columns(field1545) - field1546 = unwrapped_fields1542[3] - if field1546 is not None: + field1555 = unwrapped_fields1552[2] + self.pretty_gnf_columns(field1555) + field1556 = unwrapped_fields1552[3] + if field1556 is not None: self.newline() - assert field1546 is not None - opt_val1547 = field1546 - self.pretty_iceberg_from_snapshot(opt_val1547) - field1548 = unwrapped_fields1542[4] - if field1548 is not None: + assert field1556 is not None + opt_val1557 = field1556 + self.pretty_iceberg_from_snapshot(opt_val1557) + field1558 = unwrapped_fields1552[4] + if field1558 is not None: self.newline() - assert field1548 is not None - opt_val1549 = field1548 - self.pretty_iceberg_to_snapshot(opt_val1549) + assert field1558 is not None + opt_val1559 = field1558 + self.pretty_iceberg_to_snapshot(opt_val1559) self.newline() - field1550 = unwrapped_fields1542[5] - self.pretty_boolean_value(field1550) + field1560 = unwrapped_fields1552[5] + self.pretty_boolean_value(field1560) self.dedent() self.write(")") def pretty_iceberg_locator(self, msg: logic_pb2.IcebergLocator): - flat1557 = self._try_flat(msg, self.pretty_iceberg_locator) - if flat1557 is not None: - assert flat1557 is not None - self.write(flat1557) + flat1567 = self._try_flat(msg, self.pretty_iceberg_locator) + if flat1567 is not None: + assert flat1567 is not None + self.write(flat1567) return None else: _dollar_dollar = msg - fields1552 = (_dollar_dollar.table_name, _dollar_dollar.namespace, _dollar_dollar.warehouse,) - assert fields1552 is not None - unwrapped_fields1553 = fields1552 + fields1562 = (_dollar_dollar.table_name, _dollar_dollar.namespace, _dollar_dollar.warehouse,) + assert fields1562 is not None + unwrapped_fields1563 = fields1562 self.write("(iceberg_locator") self.indent_sexp() self.newline() - field1554 = unwrapped_fields1553[0] - self.pretty_iceberg_locator_table_name(field1554) + field1564 = unwrapped_fields1563[0] + self.pretty_iceberg_locator_table_name(field1564) self.newline() - field1555 = unwrapped_fields1553[1] - self.pretty_iceberg_locator_namespace(field1555) + field1565 = unwrapped_fields1563[1] + self.pretty_iceberg_locator_namespace(field1565) self.newline() - field1556 = unwrapped_fields1553[2] - self.pretty_iceberg_locator_warehouse(field1556) + field1566 = unwrapped_fields1563[2] + self.pretty_iceberg_locator_warehouse(field1566) self.dedent() self.write(")") def pretty_iceberg_locator_table_name(self, msg: str): - flat1559 = self._try_flat(msg, self.pretty_iceberg_locator_table_name) - if flat1559 is not None: - assert flat1559 is not None - self.write(flat1559) + flat1569 = self._try_flat(msg, self.pretty_iceberg_locator_table_name) + if flat1569 is not None: + assert flat1569 is not None + self.write(flat1569) return None else: - fields1558 = msg + fields1568 = msg self.write("(table_name") self.indent_sexp() self.newline() - self.write(self.format_string_value(fields1558)) + self.write(self.format_string_value(fields1568)) self.dedent() self.write(")") def pretty_iceberg_locator_namespace(self, msg: Sequence[str]): - flat1563 = self._try_flat(msg, self.pretty_iceberg_locator_namespace) - if flat1563 is not None: - assert flat1563 is not None - self.write(flat1563) + flat1573 = self._try_flat(msg, self.pretty_iceberg_locator_namespace) + if flat1573 is not None: + assert flat1573 is not None + self.write(flat1573) return None else: - fields1560 = msg + fields1570 = msg self.write("(namespace") self.indent_sexp() - if not len(fields1560) == 0: + if not len(fields1570) == 0: self.newline() - for i1562, elem1561 in enumerate(fields1560): - if (i1562 > 0): + for i1572, elem1571 in enumerate(fields1570): + if (i1572 > 0): self.newline() - self.write(self.format_string_value(elem1561)) + self.write(self.format_string_value(elem1571)) self.dedent() self.write(")") def pretty_iceberg_locator_warehouse(self, msg: str): - flat1565 = self._try_flat(msg, self.pretty_iceberg_locator_warehouse) - if flat1565 is not None: - assert flat1565 is not None - self.write(flat1565) + flat1575 = self._try_flat(msg, self.pretty_iceberg_locator_warehouse) + if flat1575 is not None: + assert flat1575 is not None + self.write(flat1575) return None else: - fields1564 = msg + fields1574 = msg self.write("(warehouse") self.indent_sexp() self.newline() - self.write(self.format_string_value(fields1564)) + self.write(self.format_string_value(fields1574)) self.dedent() self.write(")") def pretty_iceberg_catalog_config(self, msg: logic_pb2.IcebergCatalogConfig): - flat1573 = self._try_flat(msg, self.pretty_iceberg_catalog_config) - if flat1573 is not None: - assert flat1573 is not None - self.write(flat1573) + flat1583 = self._try_flat(msg, self.pretty_iceberg_catalog_config) + if flat1583 is not None: + assert flat1583 is not None + self.write(flat1583) return None else: _dollar_dollar = msg - _t1844 = self.deconstruct_iceberg_catalog_config_scope_optional(_dollar_dollar) - fields1566 = (_dollar_dollar.catalog_uri, _t1844, sorted(_dollar_dollar.properties.items()), sorted(_dollar_dollar.auth_properties.items()),) - assert fields1566 is not None - unwrapped_fields1567 = fields1566 + _t1855 = self.deconstruct_iceberg_catalog_config_scope_optional(_dollar_dollar) + fields1576 = (_dollar_dollar.catalog_uri, _t1855, sorted(_dollar_dollar.properties.items()), sorted(_dollar_dollar.auth_properties.items()),) + assert fields1576 is not None + unwrapped_fields1577 = fields1576 self.write("(iceberg_catalog_config") self.indent_sexp() self.newline() - field1568 = unwrapped_fields1567[0] - self.pretty_iceberg_catalog_uri(field1568) - field1569 = unwrapped_fields1567[1] - if field1569 is not None: + field1578 = unwrapped_fields1577[0] + self.pretty_iceberg_catalog_uri(field1578) + field1579 = unwrapped_fields1577[1] + if field1579 is not None: self.newline() - assert field1569 is not None - opt_val1570 = field1569 - self.pretty_iceberg_catalog_config_scope(opt_val1570) + assert field1579 is not None + opt_val1580 = field1579 + self.pretty_iceberg_catalog_config_scope(opt_val1580) self.newline() - field1571 = unwrapped_fields1567[2] - self.pretty_iceberg_properties(field1571) + field1581 = unwrapped_fields1577[2] + self.pretty_iceberg_properties(field1581) self.newline() - field1572 = unwrapped_fields1567[3] - self.pretty_iceberg_auth_properties(field1572) + field1582 = unwrapped_fields1577[3] + self.pretty_iceberg_auth_properties(field1582) self.dedent() self.write(")") def pretty_iceberg_catalog_uri(self, msg: str): - flat1575 = self._try_flat(msg, self.pretty_iceberg_catalog_uri) - if flat1575 is not None: - assert flat1575 is not None - self.write(flat1575) + flat1585 = self._try_flat(msg, self.pretty_iceberg_catalog_uri) + if flat1585 is not None: + assert flat1585 is not None + self.write(flat1585) return None else: - fields1574 = msg + fields1584 = msg self.write("(catalog_uri") self.indent_sexp() self.newline() - self.write(self.format_string_value(fields1574)) + self.write(self.format_string_value(fields1584)) self.dedent() self.write(")") def pretty_iceberg_catalog_config_scope(self, msg: str): - flat1577 = self._try_flat(msg, self.pretty_iceberg_catalog_config_scope) - if flat1577 is not None: - assert flat1577 is not None - self.write(flat1577) + flat1587 = self._try_flat(msg, self.pretty_iceberg_catalog_config_scope) + if flat1587 is not None: + assert flat1587 is not None + self.write(flat1587) return None else: - fields1576 = msg + fields1586 = msg self.write("(scope") self.indent_sexp() self.newline() - self.write(self.format_string_value(fields1576)) + self.write(self.format_string_value(fields1586)) self.dedent() self.write(")") def pretty_iceberg_properties(self, msg: Sequence[tuple[str, str]]): - flat1581 = self._try_flat(msg, self.pretty_iceberg_properties) - if flat1581 is not None: - assert flat1581 is not None - self.write(flat1581) + flat1591 = self._try_flat(msg, self.pretty_iceberg_properties) + if flat1591 is not None: + assert flat1591 is not None + self.write(flat1591) return None else: - fields1578 = msg + fields1588 = msg self.write("(properties") self.indent_sexp() - if not len(fields1578) == 0: + if not len(fields1588) == 0: self.newline() - for i1580, elem1579 in enumerate(fields1578): - if (i1580 > 0): + for i1590, elem1589 in enumerate(fields1588): + if (i1590 > 0): self.newline() - self.pretty_iceberg_property_entry(elem1579) + self.pretty_iceberg_property_entry(elem1589) self.dedent() self.write(")") def pretty_iceberg_property_entry(self, msg: tuple[str, str]): - flat1586 = self._try_flat(msg, self.pretty_iceberg_property_entry) - if flat1586 is not None: - assert flat1586 is not None - self.write(flat1586) + flat1596 = self._try_flat(msg, self.pretty_iceberg_property_entry) + if flat1596 is not None: + assert flat1596 is not None + self.write(flat1596) return None else: _dollar_dollar = msg - fields1582 = (_dollar_dollar[0], _dollar_dollar[1],) - assert fields1582 is not None - unwrapped_fields1583 = fields1582 + fields1592 = (_dollar_dollar[0], _dollar_dollar[1],) + assert fields1592 is not None + unwrapped_fields1593 = fields1592 self.write("(prop") self.indent_sexp() self.newline() - field1584 = unwrapped_fields1583[0] - self.write(self.format_string_value(field1584)) + field1594 = unwrapped_fields1593[0] + self.write(self.format_string_value(field1594)) self.newline() - field1585 = unwrapped_fields1583[1] - self.write(self.format_string_value(field1585)) + field1595 = unwrapped_fields1593[1] + self.write(self.format_string_value(field1595)) self.dedent() self.write(")") def pretty_iceberg_auth_properties(self, msg: Sequence[tuple[str, str]]): - flat1590 = self._try_flat(msg, self.pretty_iceberg_auth_properties) - if flat1590 is not None: - assert flat1590 is not None - self.write(flat1590) + flat1600 = self._try_flat(msg, self.pretty_iceberg_auth_properties) + if flat1600 is not None: + assert flat1600 is not None + self.write(flat1600) return None else: - fields1587 = msg + fields1597 = msg self.write("(auth_properties") self.indent_sexp() - if not len(fields1587) == 0: + if not len(fields1597) == 0: self.newline() - for i1589, elem1588 in enumerate(fields1587): - if (i1589 > 0): + for i1599, elem1598 in enumerate(fields1597): + if (i1599 > 0): self.newline() - self.pretty_iceberg_masked_property_entry(elem1588) + self.pretty_iceberg_masked_property_entry(elem1598) self.dedent() self.write(")") def pretty_iceberg_masked_property_entry(self, msg: tuple[str, str]): - flat1595 = self._try_flat(msg, self.pretty_iceberg_masked_property_entry) - if flat1595 is not None: - assert flat1595 is not None - self.write(flat1595) + flat1605 = self._try_flat(msg, self.pretty_iceberg_masked_property_entry) + if flat1605 is not None: + assert flat1605 is not None + self.write(flat1605) return None else: _dollar_dollar = msg - _t1845 = self.mask_secret_value(_dollar_dollar) - fields1591 = (_dollar_dollar[0], _t1845,) - assert fields1591 is not None - unwrapped_fields1592 = fields1591 + _t1856 = self.mask_secret_value(_dollar_dollar) + fields1601 = (_dollar_dollar[0], _t1856,) + assert fields1601 is not None + unwrapped_fields1602 = fields1601 self.write("(prop") self.indent_sexp() self.newline() - field1593 = unwrapped_fields1592[0] - self.write(self.format_string_value(field1593)) + field1603 = unwrapped_fields1602[0] + self.write(self.format_string_value(field1603)) self.newline() - field1594 = unwrapped_fields1592[1] - self.write(self.format_string_value(field1594)) + field1604 = unwrapped_fields1602[1] + self.write(self.format_string_value(field1604)) self.dedent() self.write(")") def pretty_iceberg_from_snapshot(self, msg: str): - flat1597 = self._try_flat(msg, self.pretty_iceberg_from_snapshot) - if flat1597 is not None: - assert flat1597 is not None - self.write(flat1597) + flat1607 = self._try_flat(msg, self.pretty_iceberg_from_snapshot) + if flat1607 is not None: + assert flat1607 is not None + self.write(flat1607) return None else: - fields1596 = msg + fields1606 = msg self.write("(from_snapshot") self.indent_sexp() self.newline() - self.write(self.format_string_value(fields1596)) + self.write(self.format_string_value(fields1606)) self.dedent() self.write(")") def pretty_iceberg_to_snapshot(self, msg: str): - flat1599 = self._try_flat(msg, self.pretty_iceberg_to_snapshot) - if flat1599 is not None: - assert flat1599 is not None - self.write(flat1599) + flat1609 = self._try_flat(msg, self.pretty_iceberg_to_snapshot) + if flat1609 is not None: + assert flat1609 is not None + self.write(flat1609) return None else: - fields1598 = msg + fields1608 = msg self.write("(to_snapshot") self.indent_sexp() self.newline() - self.write(self.format_string_value(fields1598)) + self.write(self.format_string_value(fields1608)) self.dedent() self.write(")") def pretty_undefine(self, msg: transactions_pb2.Undefine): - flat1602 = self._try_flat(msg, self.pretty_undefine) - if flat1602 is not None: - assert flat1602 is not None - self.write(flat1602) + flat1612 = self._try_flat(msg, self.pretty_undefine) + if flat1612 is not None: + assert flat1612 is not None + self.write(flat1612) return None else: _dollar_dollar = msg - fields1600 = _dollar_dollar.fragment_id - assert fields1600 is not None - unwrapped_fields1601 = fields1600 + fields1610 = _dollar_dollar.fragment_id + assert fields1610 is not None + unwrapped_fields1611 = fields1610 self.write("(undefine") self.indent_sexp() self.newline() - self.pretty_fragment_id(unwrapped_fields1601) + self.pretty_fragment_id(unwrapped_fields1611) self.dedent() self.write(")") def pretty_context(self, msg: transactions_pb2.Context): - flat1607 = self._try_flat(msg, self.pretty_context) - if flat1607 is not None: - assert flat1607 is not None - self.write(flat1607) + flat1617 = self._try_flat(msg, self.pretty_context) + if flat1617 is not None: + assert flat1617 is not None + self.write(flat1617) return None else: _dollar_dollar = msg - fields1603 = _dollar_dollar.relations - assert fields1603 is not None - unwrapped_fields1604 = fields1603 + fields1613 = _dollar_dollar.relations + assert fields1613 is not None + unwrapped_fields1614 = fields1613 self.write("(context") self.indent_sexp() - if not len(unwrapped_fields1604) == 0: + if not len(unwrapped_fields1614) == 0: self.newline() - for i1606, elem1605 in enumerate(unwrapped_fields1604): - if (i1606 > 0): + for i1616, elem1615 in enumerate(unwrapped_fields1614): + if (i1616 > 0): self.newline() - self.pretty_relation_id(elem1605) + self.pretty_relation_id(elem1615) self.dedent() self.write(")") def pretty_snapshot(self, msg: transactions_pb2.Snapshot): - flat1614 = self._try_flat(msg, self.pretty_snapshot) - if flat1614 is not None: - assert flat1614 is not None - self.write(flat1614) + flat1624 = self._try_flat(msg, self.pretty_snapshot) + if flat1624 is not None: + assert flat1624 is not None + self.write(flat1624) return None else: _dollar_dollar = msg - fields1608 = (_dollar_dollar.prefix, _dollar_dollar.mappings,) - assert fields1608 is not None - unwrapped_fields1609 = fields1608 + fields1618 = (_dollar_dollar.prefix, _dollar_dollar.mappings,) + assert fields1618 is not None + unwrapped_fields1619 = fields1618 self.write("(snapshot") self.indent_sexp() self.newline() - field1610 = unwrapped_fields1609[0] - self.pretty_edb_path(field1610) - field1611 = unwrapped_fields1609[1] - if not len(field1611) == 0: + field1620 = unwrapped_fields1619[0] + self.pretty_edb_path(field1620) + field1621 = unwrapped_fields1619[1] + if not len(field1621) == 0: self.newline() - for i1613, elem1612 in enumerate(field1611): - if (i1613 > 0): + for i1623, elem1622 in enumerate(field1621): + if (i1623 > 0): self.newline() - self.pretty_snapshot_mapping(elem1612) + self.pretty_snapshot_mapping(elem1622) self.dedent() self.write(")") def pretty_snapshot_mapping(self, msg: transactions_pb2.SnapshotMapping): - flat1619 = self._try_flat(msg, self.pretty_snapshot_mapping) - if flat1619 is not None: - assert flat1619 is not None - self.write(flat1619) + flat1629 = self._try_flat(msg, self.pretty_snapshot_mapping) + if flat1629 is not None: + assert flat1629 is not None + self.write(flat1629) return None else: _dollar_dollar = msg - fields1615 = (_dollar_dollar.destination_path, _dollar_dollar.source_relation,) - assert fields1615 is not None - unwrapped_fields1616 = fields1615 - field1617 = unwrapped_fields1616[0] - self.pretty_edb_path(field1617) + fields1625 = (_dollar_dollar.destination_path, _dollar_dollar.source_relation,) + assert fields1625 is not None + unwrapped_fields1626 = fields1625 + field1627 = unwrapped_fields1626[0] + self.pretty_edb_path(field1627) self.write(" ") - field1618 = unwrapped_fields1616[1] - self.pretty_relation_id(field1618) + field1628 = unwrapped_fields1626[1] + self.pretty_relation_id(field1628) def pretty_epoch_reads(self, msg: Sequence[transactions_pb2.Read]): - flat1623 = self._try_flat(msg, self.pretty_epoch_reads) - if flat1623 is not None: - assert flat1623 is not None - self.write(flat1623) + flat1633 = self._try_flat(msg, self.pretty_epoch_reads) + if flat1633 is not None: + assert flat1633 is not None + self.write(flat1633) return None else: - fields1620 = msg + fields1630 = msg self.write("(reads") self.indent_sexp() - if not len(fields1620) == 0: + if not len(fields1630) == 0: self.newline() - for i1622, elem1621 in enumerate(fields1620): - if (i1622 > 0): + for i1632, elem1631 in enumerate(fields1630): + if (i1632 > 0): self.newline() - self.pretty_read(elem1621) + self.pretty_read(elem1631) self.dedent() self.write(")") def pretty_read(self, msg: transactions_pb2.Read): - flat1634 = self._try_flat(msg, self.pretty_read) - if flat1634 is not None: - assert flat1634 is not None - self.write(flat1634) + flat1644 = self._try_flat(msg, self.pretty_read) + if flat1644 is not None: + assert flat1644 is not None + self.write(flat1644) return None else: _dollar_dollar = msg if _dollar_dollar.HasField("demand"): - _t1846 = _dollar_dollar.demand + _t1857 = _dollar_dollar.demand else: - _t1846 = None - deconstruct_result1632 = _t1846 - if deconstruct_result1632 is not None: - assert deconstruct_result1632 is not None - unwrapped1633 = deconstruct_result1632 - self.pretty_demand(unwrapped1633) + _t1857 = None + deconstruct_result1642 = _t1857 + if deconstruct_result1642 is not None: + assert deconstruct_result1642 is not None + unwrapped1643 = deconstruct_result1642 + self.pretty_demand(unwrapped1643) else: _dollar_dollar = msg if _dollar_dollar.HasField("output"): - _t1847 = _dollar_dollar.output + _t1858 = _dollar_dollar.output else: - _t1847 = None - deconstruct_result1630 = _t1847 - if deconstruct_result1630 is not None: - assert deconstruct_result1630 is not None - unwrapped1631 = deconstruct_result1630 - self.pretty_output(unwrapped1631) + _t1858 = None + deconstruct_result1640 = _t1858 + if deconstruct_result1640 is not None: + assert deconstruct_result1640 is not None + unwrapped1641 = deconstruct_result1640 + self.pretty_output(unwrapped1641) else: _dollar_dollar = msg if _dollar_dollar.HasField("what_if"): - _t1848 = _dollar_dollar.what_if + _t1859 = _dollar_dollar.what_if else: - _t1848 = None - deconstruct_result1628 = _t1848 - if deconstruct_result1628 is not None: - assert deconstruct_result1628 is not None - unwrapped1629 = deconstruct_result1628 - self.pretty_what_if(unwrapped1629) + _t1859 = None + deconstruct_result1638 = _t1859 + if deconstruct_result1638 is not None: + assert deconstruct_result1638 is not None + unwrapped1639 = deconstruct_result1638 + self.pretty_what_if(unwrapped1639) else: _dollar_dollar = msg if _dollar_dollar.HasField("abort"): - _t1849 = _dollar_dollar.abort + _t1860 = _dollar_dollar.abort else: - _t1849 = None - deconstruct_result1626 = _t1849 - if deconstruct_result1626 is not None: - assert deconstruct_result1626 is not None - unwrapped1627 = deconstruct_result1626 - self.pretty_abort(unwrapped1627) + _t1860 = None + deconstruct_result1636 = _t1860 + if deconstruct_result1636 is not None: + assert deconstruct_result1636 is not None + unwrapped1637 = deconstruct_result1636 + self.pretty_abort(unwrapped1637) else: _dollar_dollar = msg if _dollar_dollar.HasField("export"): - _t1850 = _dollar_dollar.export + _t1861 = _dollar_dollar.export else: - _t1850 = None - deconstruct_result1624 = _t1850 - if deconstruct_result1624 is not None: - assert deconstruct_result1624 is not None - unwrapped1625 = deconstruct_result1624 - self.pretty_export(unwrapped1625) + _t1861 = None + deconstruct_result1634 = _t1861 + if deconstruct_result1634 is not None: + assert deconstruct_result1634 is not None + unwrapped1635 = deconstruct_result1634 + self.pretty_export(unwrapped1635) else: raise ParseError("No matching rule for read") def pretty_demand(self, msg: transactions_pb2.Demand): - flat1637 = self._try_flat(msg, self.pretty_demand) - if flat1637 is not None: - assert flat1637 is not None - self.write(flat1637) + flat1647 = self._try_flat(msg, self.pretty_demand) + if flat1647 is not None: + assert flat1647 is not None + self.write(flat1647) return None else: _dollar_dollar = msg - fields1635 = _dollar_dollar.relation_id - assert fields1635 is not None - unwrapped_fields1636 = fields1635 + fields1645 = _dollar_dollar.relation_id + assert fields1645 is not None + unwrapped_fields1646 = fields1645 self.write("(demand") self.indent_sexp() self.newline() - self.pretty_relation_id(unwrapped_fields1636) + self.pretty_relation_id(unwrapped_fields1646) self.dedent() self.write(")") def pretty_output(self, msg: transactions_pb2.Output): - flat1642 = self._try_flat(msg, self.pretty_output) - if flat1642 is not None: - assert flat1642 is not None - self.write(flat1642) + flat1652 = self._try_flat(msg, self.pretty_output) + if flat1652 is not None: + assert flat1652 is not None + self.write(flat1652) return None else: _dollar_dollar = msg - fields1638 = (_dollar_dollar.name, _dollar_dollar.relation_id,) - assert fields1638 is not None - unwrapped_fields1639 = fields1638 + fields1648 = (_dollar_dollar.name, _dollar_dollar.relation_id,) + assert fields1648 is not None + unwrapped_fields1649 = fields1648 self.write("(output") self.indent_sexp() self.newline() - field1640 = unwrapped_fields1639[0] - self.pretty_name(field1640) + field1650 = unwrapped_fields1649[0] + self.pretty_name(field1650) self.newline() - field1641 = unwrapped_fields1639[1] - self.pretty_relation_id(field1641) + field1651 = unwrapped_fields1649[1] + self.pretty_relation_id(field1651) self.dedent() self.write(")") def pretty_what_if(self, msg: transactions_pb2.WhatIf): - flat1647 = self._try_flat(msg, self.pretty_what_if) - if flat1647 is not None: - assert flat1647 is not None - self.write(flat1647) + flat1657 = self._try_flat(msg, self.pretty_what_if) + if flat1657 is not None: + assert flat1657 is not None + self.write(flat1657) return None else: _dollar_dollar = msg - fields1643 = (_dollar_dollar.branch, _dollar_dollar.epoch,) - assert fields1643 is not None - unwrapped_fields1644 = fields1643 + fields1653 = (_dollar_dollar.branch, _dollar_dollar.epoch,) + assert fields1653 is not None + unwrapped_fields1654 = fields1653 self.write("(what_if") self.indent_sexp() self.newline() - field1645 = unwrapped_fields1644[0] - self.pretty_name(field1645) + field1655 = unwrapped_fields1654[0] + self.pretty_name(field1655) self.newline() - field1646 = unwrapped_fields1644[1] - self.pretty_epoch(field1646) + field1656 = unwrapped_fields1654[1] + self.pretty_epoch(field1656) self.dedent() self.write(")") def pretty_abort(self, msg: transactions_pb2.Abort): - flat1653 = self._try_flat(msg, self.pretty_abort) - if flat1653 is not None: - assert flat1653 is not None - self.write(flat1653) + flat1663 = self._try_flat(msg, self.pretty_abort) + if flat1663 is not None: + assert flat1663 is not None + self.write(flat1663) return None else: _dollar_dollar = msg if _dollar_dollar.name != "abort": - _t1851 = _dollar_dollar.name + _t1862 = _dollar_dollar.name else: - _t1851 = None - fields1648 = (_t1851, _dollar_dollar.relation_id,) - assert fields1648 is not None - unwrapped_fields1649 = fields1648 + _t1862 = None + fields1658 = (_t1862, _dollar_dollar.relation_id,) + assert fields1658 is not None + unwrapped_fields1659 = fields1658 self.write("(abort") self.indent_sexp() - field1650 = unwrapped_fields1649[0] - if field1650 is not None: + field1660 = unwrapped_fields1659[0] + if field1660 is not None: self.newline() - assert field1650 is not None - opt_val1651 = field1650 - self.pretty_name(opt_val1651) + assert field1660 is not None + opt_val1661 = field1660 + self.pretty_name(opt_val1661) self.newline() - field1652 = unwrapped_fields1649[1] - self.pretty_relation_id(field1652) + field1662 = unwrapped_fields1659[1] + self.pretty_relation_id(field1662) self.dedent() self.write(")") def pretty_export(self, msg: transactions_pb2.Export): - flat1658 = self._try_flat(msg, self.pretty_export) - if flat1658 is not None: - assert flat1658 is not None - self.write(flat1658) + flat1668 = self._try_flat(msg, self.pretty_export) + if flat1668 is not None: + assert flat1668 is not None + self.write(flat1668) return None else: _dollar_dollar = msg if _dollar_dollar.HasField("csv_config"): - _t1852 = _dollar_dollar.csv_config + _t1863 = _dollar_dollar.csv_config else: - _t1852 = None - deconstruct_result1656 = _t1852 - if deconstruct_result1656 is not None: - assert deconstruct_result1656 is not None - unwrapped1657 = deconstruct_result1656 + _t1863 = None + deconstruct_result1666 = _t1863 + if deconstruct_result1666 is not None: + assert deconstruct_result1666 is not None + unwrapped1667 = deconstruct_result1666 self.write("(export") self.indent_sexp() self.newline() - self.pretty_export_csv_config(unwrapped1657) + self.pretty_export_csv_config(unwrapped1667) self.dedent() self.write(")") else: _dollar_dollar = msg if _dollar_dollar.HasField("iceberg_config"): - _t1853 = _dollar_dollar.iceberg_config + _t1864 = _dollar_dollar.iceberg_config else: - _t1853 = None - deconstruct_result1654 = _t1853 - if deconstruct_result1654 is not None: - assert deconstruct_result1654 is not None - unwrapped1655 = deconstruct_result1654 + _t1864 = None + deconstruct_result1664 = _t1864 + if deconstruct_result1664 is not None: + assert deconstruct_result1664 is not None + unwrapped1665 = deconstruct_result1664 self.write("(export_iceberg") self.indent_sexp() self.newline() - self.pretty_export_iceberg_config(unwrapped1655) + self.pretty_export_iceberg_config(unwrapped1665) self.dedent() self.write(")") else: raise ParseError("No matching rule for export") def pretty_export_csv_config(self, msg: transactions_pb2.ExportCSVConfig): - flat1669 = self._try_flat(msg, self.pretty_export_csv_config) - if flat1669 is not None: - assert flat1669 is not None - self.write(flat1669) + flat1679 = self._try_flat(msg, self.pretty_export_csv_config) + if flat1679 is not None: + assert flat1679 is not None + self.write(flat1679) return None else: _dollar_dollar = msg if len(_dollar_dollar.data_columns) == 0: - _t1855 = self.deconstruct_export_csv_output_location(_dollar_dollar) - _t1854 = (_t1855, _dollar_dollar.csv_source, _dollar_dollar.csv_config,) + _t1866 = self.deconstruct_export_csv_output_location(_dollar_dollar) + _t1865 = (_t1866, _dollar_dollar.csv_source, _dollar_dollar.csv_config,) else: - _t1854 = None - deconstruct_result1664 = _t1854 - if deconstruct_result1664 is not None: - assert deconstruct_result1664 is not None - unwrapped1665 = deconstruct_result1664 + _t1865 = None + deconstruct_result1674 = _t1865 + if deconstruct_result1674 is not None: + assert deconstruct_result1674 is not None + unwrapped1675 = deconstruct_result1674 self.write("(export_csv_config_v2") self.indent_sexp() self.newline() - field1666 = unwrapped1665[0] - self.pretty_export_csv_output_location(field1666) + field1676 = unwrapped1675[0] + self.pretty_export_csv_output_location(field1676) self.newline() - field1667 = unwrapped1665[1] - self.pretty_export_csv_source(field1667) + field1677 = unwrapped1675[1] + self.pretty_export_csv_source(field1677) self.newline() - field1668 = unwrapped1665[2] - self.pretty_csv_config(field1668) + field1678 = unwrapped1675[2] + self.pretty_csv_config(field1678) self.dedent() self.write(")") else: _dollar_dollar = msg if len(_dollar_dollar.data_columns) != 0: - _t1857 = self.deconstruct_export_csv_config(_dollar_dollar) - _t1856 = (_dollar_dollar.path, _dollar_dollar.data_columns, _t1857,) + _t1868 = self.deconstruct_export_csv_config(_dollar_dollar) + _t1867 = (_dollar_dollar.path, _dollar_dollar.data_columns, _t1868,) else: - _t1856 = None - deconstruct_result1659 = _t1856 - if deconstruct_result1659 is not None: - assert deconstruct_result1659 is not None - unwrapped1660 = deconstruct_result1659 + _t1867 = None + deconstruct_result1669 = _t1867 + if deconstruct_result1669 is not None: + assert deconstruct_result1669 is not None + unwrapped1670 = deconstruct_result1669 self.write("(export_csv_config") self.indent_sexp() self.newline() - field1661 = unwrapped1660[0] - self.pretty_export_csv_path(field1661) + field1671 = unwrapped1670[0] + self.pretty_export_csv_path(field1671) self.newline() - field1662 = unwrapped1660[1] - self.pretty_export_csv_columns_list(field1662) + field1672 = unwrapped1670[1] + self.pretty_export_csv_columns_list(field1672) self.newline() - field1663 = unwrapped1660[2] - self.pretty_config_dict(field1663) + field1673 = unwrapped1670[2] + self.pretty_config_dict(field1673) self.dedent() self.write(")") else: raise ParseError("No matching rule for export_csv_config") def pretty_export_csv_output_location(self, msg: tuple[str, str]): - flat1674 = self._try_flat(msg, self.pretty_export_csv_output_location) - if flat1674 is not None: - assert flat1674 is not None - self.write(flat1674) + flat1684 = self._try_flat(msg, self.pretty_export_csv_output_location) + if flat1684 is not None: + assert flat1684 is not None + self.write(flat1684) return None else: _dollar_dollar = msg if _dollar_dollar[0] != "": - _t1858 = _dollar_dollar[0] + _t1869 = _dollar_dollar[0] else: - _t1858 = None - deconstruct_result1672 = _t1858 - if deconstruct_result1672 is not None: - assert deconstruct_result1672 is not None - unwrapped1673 = deconstruct_result1672 + _t1869 = None + deconstruct_result1682 = _t1869 + if deconstruct_result1682 is not None: + assert deconstruct_result1682 is not None + unwrapped1683 = deconstruct_result1682 self.write("(path") self.indent_sexp() self.newline() - self.write(self.format_string_value(unwrapped1673)) + self.write(self.format_string_value(unwrapped1683)) self.dedent() self.write(")") else: _dollar_dollar = msg if _dollar_dollar[1] != "": - _t1859 = _dollar_dollar[1] + _t1870 = _dollar_dollar[1] else: - _t1859 = None - deconstruct_result1670 = _t1859 - if deconstruct_result1670 is not None: - assert deconstruct_result1670 is not None - unwrapped1671 = deconstruct_result1670 + _t1870 = None + deconstruct_result1680 = _t1870 + if deconstruct_result1680 is not None: + assert deconstruct_result1680 is not None + unwrapped1681 = deconstruct_result1680 self.write("(transaction_output_name") self.indent_sexp() self.newline() - self.pretty_name(unwrapped1671) + self.pretty_name(unwrapped1681) self.dedent() self.write(")") else: raise ParseError("No matching rule for export_csv_output_location") def pretty_export_csv_source(self, msg: transactions_pb2.ExportCSVSource): - flat1681 = self._try_flat(msg, self.pretty_export_csv_source) - if flat1681 is not None: - assert flat1681 is not None - self.write(flat1681) + flat1691 = self._try_flat(msg, self.pretty_export_csv_source) + if flat1691 is not None: + assert flat1691 is not None + self.write(flat1691) return None else: _dollar_dollar = msg if _dollar_dollar.HasField("gnf_columns"): - _t1860 = _dollar_dollar.gnf_columns.columns + _t1871 = _dollar_dollar.gnf_columns.columns else: - _t1860 = None - deconstruct_result1677 = _t1860 - if deconstruct_result1677 is not None: - assert deconstruct_result1677 is not None - unwrapped1678 = deconstruct_result1677 + _t1871 = None + deconstruct_result1687 = _t1871 + if deconstruct_result1687 is not None: + assert deconstruct_result1687 is not None + unwrapped1688 = deconstruct_result1687 self.write("(gnf_columns") self.indent_sexp() - if not len(unwrapped1678) == 0: + if not len(unwrapped1688) == 0: self.newline() - for i1680, elem1679 in enumerate(unwrapped1678): - if (i1680 > 0): + for i1690, elem1689 in enumerate(unwrapped1688): + if (i1690 > 0): self.newline() - self.pretty_export_csv_column(elem1679) + self.pretty_export_csv_column(elem1689) self.dedent() self.write(")") else: _dollar_dollar = msg if _dollar_dollar.HasField("table_def"): - _t1861 = _dollar_dollar.table_def + _t1872 = _dollar_dollar.table_def else: - _t1861 = None - deconstruct_result1675 = _t1861 - if deconstruct_result1675 is not None: - assert deconstruct_result1675 is not None - unwrapped1676 = deconstruct_result1675 + _t1872 = None + deconstruct_result1685 = _t1872 + if deconstruct_result1685 is not None: + assert deconstruct_result1685 is not None + unwrapped1686 = deconstruct_result1685 self.write("(table_def") self.indent_sexp() self.newline() - self.pretty_relation_id(unwrapped1676) + self.pretty_relation_id(unwrapped1686) self.dedent() self.write(")") else: raise ParseError("No matching rule for export_csv_source") def pretty_export_csv_column(self, msg: transactions_pb2.ExportCSVColumn): - flat1686 = self._try_flat(msg, self.pretty_export_csv_column) - if flat1686 is not None: - assert flat1686 is not None - self.write(flat1686) + flat1696 = self._try_flat(msg, self.pretty_export_csv_column) + if flat1696 is not None: + assert flat1696 is not None + self.write(flat1696) return None else: _dollar_dollar = msg - fields1682 = (_dollar_dollar.column_name, _dollar_dollar.column_data,) - assert fields1682 is not None - unwrapped_fields1683 = fields1682 + fields1692 = (_dollar_dollar.column_name, _dollar_dollar.column_data,) + assert fields1692 is not None + unwrapped_fields1693 = fields1692 self.write("(column") self.indent_sexp() self.newline() - field1684 = unwrapped_fields1683[0] - self.write(self.format_string_value(field1684)) + field1694 = unwrapped_fields1693[0] + self.write(self.format_string_value(field1694)) self.newline() - field1685 = unwrapped_fields1683[1] - self.pretty_relation_id(field1685) + field1695 = unwrapped_fields1693[1] + self.pretty_relation_id(field1695) self.dedent() self.write(")") def pretty_export_csv_path(self, msg: str): - flat1688 = self._try_flat(msg, self.pretty_export_csv_path) - if flat1688 is not None: - assert flat1688 is not None - self.write(flat1688) + flat1698 = self._try_flat(msg, self.pretty_export_csv_path) + if flat1698 is not None: + assert flat1698 is not None + self.write(flat1698) return None else: - fields1687 = msg + fields1697 = msg self.write("(path") self.indent_sexp() self.newline() - self.write(self.format_string_value(fields1687)) + self.write(self.format_string_value(fields1697)) self.dedent() self.write(")") def pretty_export_csv_columns_list(self, msg: Sequence[transactions_pb2.ExportCSVColumn]): - flat1692 = self._try_flat(msg, self.pretty_export_csv_columns_list) - if flat1692 is not None: - assert flat1692 is not None - self.write(flat1692) + flat1702 = self._try_flat(msg, self.pretty_export_csv_columns_list) + if flat1702 is not None: + assert flat1702 is not None + self.write(flat1702) return None else: - fields1689 = msg + fields1699 = msg self.write("(columns") self.indent_sexp() - if not len(fields1689) == 0: + if not len(fields1699) == 0: self.newline() - for i1691, elem1690 in enumerate(fields1689): - if (i1691 > 0): + for i1701, elem1700 in enumerate(fields1699): + if (i1701 > 0): self.newline() - self.pretty_export_csv_column(elem1690) + self.pretty_export_csv_column(elem1700) self.dedent() self.write(")") def pretty_export_iceberg_config(self, msg: transactions_pb2.ExportIcebergConfig): - flat1701 = self._try_flat(msg, self.pretty_export_iceberg_config) - if flat1701 is not None: - assert flat1701 is not None - self.write(flat1701) + flat1711 = self._try_flat(msg, self.pretty_export_iceberg_config) + if flat1711 is not None: + assert flat1711 is not None + self.write(flat1711) return None else: _dollar_dollar = msg - _t1862 = self.deconstruct_export_iceberg_config_optional(_dollar_dollar) - fields1693 = (_dollar_dollar.locator, _dollar_dollar.config, _dollar_dollar.table_def, sorted(_dollar_dollar.table_properties.items()), _t1862,) - assert fields1693 is not None - unwrapped_fields1694 = fields1693 + _t1873 = self.deconstruct_export_iceberg_config_optional(_dollar_dollar) + fields1703 = (_dollar_dollar.locator, _dollar_dollar.config, _dollar_dollar.table_def, sorted(_dollar_dollar.table_properties.items()), _t1873,) + assert fields1703 is not None + unwrapped_fields1704 = fields1703 self.write("(export_iceberg_config") self.indent_sexp() self.newline() - field1695 = unwrapped_fields1694[0] - self.pretty_iceberg_locator(field1695) + field1705 = unwrapped_fields1704[0] + self.pretty_iceberg_locator(field1705) self.newline() - field1696 = unwrapped_fields1694[1] - self.pretty_iceberg_catalog_config(field1696) + field1706 = unwrapped_fields1704[1] + self.pretty_iceberg_catalog_config(field1706) self.newline() - field1697 = unwrapped_fields1694[2] - self.pretty_export_iceberg_table_def(field1697) + field1707 = unwrapped_fields1704[2] + self.pretty_export_iceberg_table_def(field1707) self.newline() - field1698 = unwrapped_fields1694[3] - self.pretty_iceberg_table_properties(field1698) - field1699 = unwrapped_fields1694[4] - if field1699 is not None: + field1708 = unwrapped_fields1704[3] + self.pretty_iceberg_table_properties(field1708) + field1709 = unwrapped_fields1704[4] + if field1709 is not None: self.newline() - assert field1699 is not None - opt_val1700 = field1699 - self.pretty_config_dict(opt_val1700) + assert field1709 is not None + opt_val1710 = field1709 + self.pretty_config_dict(opt_val1710) self.dedent() self.write(")") def pretty_export_iceberg_table_def(self, msg: logic_pb2.RelationId): - flat1703 = self._try_flat(msg, self.pretty_export_iceberg_table_def) - if flat1703 is not None: - assert flat1703 is not None - self.write(flat1703) + flat1713 = self._try_flat(msg, self.pretty_export_iceberg_table_def) + if flat1713 is not None: + assert flat1713 is not None + self.write(flat1713) return None else: - fields1702 = msg + fields1712 = msg self.write("(table_def") self.indent_sexp() self.newline() - self.pretty_relation_id(fields1702) + self.pretty_relation_id(fields1712) self.dedent() self.write(")") def pretty_iceberg_table_properties(self, msg: Sequence[tuple[str, str]]): - flat1707 = self._try_flat(msg, self.pretty_iceberg_table_properties) - if flat1707 is not None: - assert flat1707 is not None - self.write(flat1707) + flat1717 = self._try_flat(msg, self.pretty_iceberg_table_properties) + if flat1717 is not None: + assert flat1717 is not None + self.write(flat1717) return None else: - fields1704 = msg + fields1714 = msg self.write("(table_properties") self.indent_sexp() - if not len(fields1704) == 0: + if not len(fields1714) == 0: self.newline() - for i1706, elem1705 in enumerate(fields1704): - if (i1706 > 0): + for i1716, elem1715 in enumerate(fields1714): + if (i1716 > 0): self.newline() - self.pretty_iceberg_property_entry(elem1705) + self.pretty_iceberg_property_entry(elem1715) self.dedent() self.write(")") @@ -4695,8 +4724,8 @@ def pretty_debug_info(self, msg: fragments_pb2.DebugInfo): for _idx, _rid in enumerate(msg.ids): self.newline() self.write("(") - _t1917 = logic_pb2.UInt128Value(low=_rid.id_low, high=_rid.id_high) - self.pprint_dispatch(_t1917) + _t1928 = logic_pb2.UInt128Value(low=_rid.id_low, high=_rid.id_high) + self.pprint_dispatch(_t1928) self.write(" ") self.write(self.format_string_value(msg.orig_names[_idx])) self.write(")") @@ -4933,6 +4962,8 @@ def pprint_dispatch(self, msg): self.pretty_float32_type(msg) elif isinstance(msg, logic_pb2.UInt32Type): self.pretty_uint32_type(msg) + elif isinstance(msg, logic_pb2.FixedType): + self.pretty_fixed_type(msg) elif isinstance(msg, logic_pb2.Formula): self.pretty_formula(msg) elif isinstance(msg, logic_pb2.Conjunction): diff --git a/sdks/python/src/lqp/proto/v1/logic_pb2.py b/sdks/python/src/lqp/proto/v1/logic_pb2.py index a9afea64..6c921abf 100644 --- a/sdks/python/src/lqp/proto/v1/logic_pb2.py +++ b/sdks/python/src/lqp/proto/v1/logic_pb2.py @@ -24,7 +24,7 @@ -DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x1frelationalai/lqp/v1/logic.proto\x12\x13relationalai.lqp.v1\"\x83\x02\n\x0b\x44\x65\x63laration\x12,\n\x03\x64\x65\x66\x18\x01 \x01(\x0b\x32\x18.relationalai.lqp.v1.DefH\x00R\x03\x64\x65\x66\x12>\n\talgorithm\x18\x02 \x01(\x0b\x32\x1e.relationalai.lqp.v1.AlgorithmH\x00R\talgorithm\x12\x41\n\nconstraint\x18\x03 \x01(\x0b\x32\x1f.relationalai.lqp.v1.ConstraintH\x00R\nconstraint\x12/\n\x04\x64\x61ta\x18\x04 \x01(\x0b\x32\x19.relationalai.lqp.v1.DataH\x00R\x04\x64\x61taB\x12\n\x10\x64\x65\x63laration_type\"\xa6\x01\n\x03\x44\x65\x66\x12\x33\n\x04name\x18\x01 \x01(\x0b\x32\x1f.relationalai.lqp.v1.RelationIdR\x04name\x12\x34\n\x04\x62ody\x18\x02 \x01(\x0b\x32 .relationalai.lqp.v1.AbstractionR\x04\x62ody\x12\x34\n\x05\x61ttrs\x18\x03 \x03(\x0b\x32\x1e.relationalai.lqp.v1.AttributeR\x05\x61ttrs\"\xb6\x01\n\nConstraint\x12\x33\n\x04name\x18\x02 \x01(\x0b\x32\x1f.relationalai.lqp.v1.RelationIdR\x04name\x12`\n\x15\x66unctional_dependency\x18\x01 \x01(\x0b\x32).relationalai.lqp.v1.FunctionalDependencyH\x00R\x14\x66unctionalDependencyB\x11\n\x0f\x63onstraint_type\"\xae\x01\n\x14\x46unctionalDependency\x12\x36\n\x05guard\x18\x01 \x01(\x0b\x32 .relationalai.lqp.v1.AbstractionR\x05guard\x12,\n\x04keys\x18\x02 \x03(\x0b\x32\x18.relationalai.lqp.v1.VarR\x04keys\x12\x30\n\x06values\x18\x03 \x03(\x0b\x32\x18.relationalai.lqp.v1.VarR\x06values\"\xab\x01\n\tAlgorithm\x12\x37\n\x06global\x18\x01 \x03(\x0b\x32\x1f.relationalai.lqp.v1.RelationIdR\x06global\x12/\n\x04\x62ody\x18\x02 \x01(\x0b\x32\x1b.relationalai.lqp.v1.ScriptR\x04\x62ody\x12\x34\n\x05\x61ttrs\x18\x03 \x03(\x0b\x32\x1e.relationalai.lqp.v1.AttributeR\x05\x61ttrs\"H\n\x06Script\x12>\n\nconstructs\x18\x01 \x03(\x0b\x32\x1e.relationalai.lqp.v1.ConstructR\nconstructs\"\x94\x01\n\tConstruct\x12/\n\x04loop\x18\x01 \x01(\x0b\x32\x19.relationalai.lqp.v1.LoopH\x00R\x04loop\x12\x44\n\x0binstruction\x18\x02 \x01(\x0b\x32 .relationalai.lqp.v1.InstructionH\x00R\x0binstructionB\x10\n\x0e\x63onstruct_type\"\xa3\x01\n\x04Loop\x12\x34\n\x04init\x18\x01 \x03(\x0b\x32 .relationalai.lqp.v1.InstructionR\x04init\x12/\n\x04\x62ody\x18\x02 \x01(\x0b\x32\x1b.relationalai.lqp.v1.ScriptR\x04\x62ody\x12\x34\n\x05\x61ttrs\x18\x03 \x03(\x0b\x32\x1e.relationalai.lqp.v1.AttributeR\x05\x61ttrs\"\xc2\x02\n\x0bInstruction\x12\x35\n\x06\x61ssign\x18\x01 \x01(\x0b\x32\x1b.relationalai.lqp.v1.AssignH\x00R\x06\x61ssign\x12\x35\n\x06upsert\x18\x02 \x01(\x0b\x32\x1b.relationalai.lqp.v1.UpsertH\x00R\x06upsert\x12\x32\n\x05\x62reak\x18\x03 \x01(\x0b\x32\x1a.relationalai.lqp.v1.BreakH\x00R\x05\x62reak\x12?\n\nmonoid_def\x18\x05 \x01(\x0b\x32\x1e.relationalai.lqp.v1.MonoidDefH\x00R\tmonoidDef\x12<\n\tmonus_def\x18\x06 \x01(\x0b\x32\x1d.relationalai.lqp.v1.MonusDefH\x00R\x08monusDefB\x0c\n\ninstr_typeJ\x04\x08\x04\x10\x05\"\xa9\x01\n\x06\x41ssign\x12\x33\n\x04name\x18\x01 \x01(\x0b\x32\x1f.relationalai.lqp.v1.RelationIdR\x04name\x12\x34\n\x04\x62ody\x18\x02 \x01(\x0b\x32 .relationalai.lqp.v1.AbstractionR\x04\x62ody\x12\x34\n\x05\x61ttrs\x18\x03 \x03(\x0b\x32\x1e.relationalai.lqp.v1.AttributeR\x05\x61ttrs\"\xca\x01\n\x06Upsert\x12\x33\n\x04name\x18\x01 \x01(\x0b\x32\x1f.relationalai.lqp.v1.RelationIdR\x04name\x12\x34\n\x04\x62ody\x18\x02 \x01(\x0b\x32 .relationalai.lqp.v1.AbstractionR\x04\x62ody\x12\x34\n\x05\x61ttrs\x18\x03 \x03(\x0b\x32\x1e.relationalai.lqp.v1.AttributeR\x05\x61ttrs\x12\x1f\n\x0bvalue_arity\x18\x04 \x01(\x03R\nvalueArity\"\xa8\x01\n\x05\x42reak\x12\x33\n\x04name\x18\x01 \x01(\x0b\x32\x1f.relationalai.lqp.v1.RelationIdR\x04name\x12\x34\n\x04\x62ody\x18\x02 \x01(\x0b\x32 .relationalai.lqp.v1.AbstractionR\x04\x62ody\x12\x34\n\x05\x61ttrs\x18\x03 \x03(\x0b\x32\x1e.relationalai.lqp.v1.AttributeR\x05\x61ttrs\"\x82\x02\n\tMonoidDef\x12\x33\n\x06monoid\x18\x01 \x01(\x0b\x32\x1b.relationalai.lqp.v1.MonoidR\x06monoid\x12\x33\n\x04name\x18\x02 \x01(\x0b\x32\x1f.relationalai.lqp.v1.RelationIdR\x04name\x12\x34\n\x04\x62ody\x18\x03 \x01(\x0b\x32 .relationalai.lqp.v1.AbstractionR\x04\x62ody\x12\x34\n\x05\x61ttrs\x18\x04 \x03(\x0b\x32\x1e.relationalai.lqp.v1.AttributeR\x05\x61ttrs\x12\x1f\n\x0bvalue_arity\x18\x05 \x01(\x03R\nvalueArity\"\x81\x02\n\x08MonusDef\x12\x33\n\x06monoid\x18\x01 \x01(\x0b\x32\x1b.relationalai.lqp.v1.MonoidR\x06monoid\x12\x33\n\x04name\x18\x02 \x01(\x0b\x32\x1f.relationalai.lqp.v1.RelationIdR\x04name\x12\x34\n\x04\x62ody\x18\x03 \x01(\x0b\x32 .relationalai.lqp.v1.AbstractionR\x04\x62ody\x12\x34\n\x05\x61ttrs\x18\x04 \x03(\x0b\x32\x1e.relationalai.lqp.v1.AttributeR\x05\x61ttrs\x12\x1f\n\x0bvalue_arity\x18\x05 \x01(\x03R\nvalueArity\"\x92\x02\n\x06Monoid\x12<\n\tor_monoid\x18\x01 \x01(\x0b\x32\x1d.relationalai.lqp.v1.OrMonoidH\x00R\x08orMonoid\x12?\n\nmin_monoid\x18\x02 \x01(\x0b\x32\x1e.relationalai.lqp.v1.MinMonoidH\x00R\tminMonoid\x12?\n\nmax_monoid\x18\x03 \x01(\x0b\x32\x1e.relationalai.lqp.v1.MaxMonoidH\x00R\tmaxMonoid\x12?\n\nsum_monoid\x18\x04 \x01(\x0b\x32\x1e.relationalai.lqp.v1.SumMonoidH\x00R\tsumMonoidB\x07\n\x05value\"\n\n\x08OrMonoid\":\n\tMinMonoid\x12-\n\x04type\x18\x01 \x01(\x0b\x32\x19.relationalai.lqp.v1.TypeR\x04type\":\n\tMaxMonoid\x12-\n\x04type\x18\x01 \x01(\x0b\x32\x19.relationalai.lqp.v1.TypeR\x04type\":\n\tSumMonoid\x12-\n\x04type\x18\x01 \x01(\x0b\x32\x19.relationalai.lqp.v1.TypeR\x04type\"d\n\x07\x42inding\x12*\n\x03var\x18\x01 \x01(\x0b\x32\x18.relationalai.lqp.v1.VarR\x03var\x12-\n\x04type\x18\x02 \x01(\x0b\x32\x19.relationalai.lqp.v1.TypeR\x04type\"s\n\x0b\x41\x62straction\x12\x30\n\x04vars\x18\x01 \x03(\x0b\x32\x1c.relationalai.lqp.v1.BindingR\x04vars\x12\x32\n\x05value\x18\x02 \x01(\x0b\x32\x1c.relationalai.lqp.v1.FormulaR\x05value\"\x83\x05\n\x07\x46ormula\x12\x35\n\x06\x65xists\x18\x01 \x01(\x0b\x32\x1b.relationalai.lqp.v1.ExistsH\x00R\x06\x65xists\x12\x35\n\x06reduce\x18\x02 \x01(\x0b\x32\x1b.relationalai.lqp.v1.ReduceH\x00R\x06reduce\x12\x44\n\x0b\x63onjunction\x18\x03 \x01(\x0b\x32 .relationalai.lqp.v1.ConjunctionH\x00R\x0b\x63onjunction\x12\x44\n\x0b\x64isjunction\x18\x04 \x01(\x0b\x32 .relationalai.lqp.v1.DisjunctionH\x00R\x0b\x64isjunction\x12,\n\x03not\x18\x05 \x01(\x0b\x32\x18.relationalai.lqp.v1.NotH\x00R\x03not\x12,\n\x03\x66\x66i\x18\x06 \x01(\x0b\x32\x18.relationalai.lqp.v1.FFIH\x00R\x03\x66\x66i\x12/\n\x04\x61tom\x18\x07 \x01(\x0b\x32\x19.relationalai.lqp.v1.AtomH\x00R\x04\x61tom\x12\x35\n\x06pragma\x18\x08 \x01(\x0b\x32\x1b.relationalai.lqp.v1.PragmaH\x00R\x06pragma\x12>\n\tprimitive\x18\t \x01(\x0b\x32\x1e.relationalai.lqp.v1.PrimitiveH\x00R\tprimitive\x12\x39\n\x08rel_atom\x18\n \x01(\x0b\x32\x1c.relationalai.lqp.v1.RelAtomH\x00R\x07relAtom\x12/\n\x04\x63\x61st\x18\x0b \x01(\x0b\x32\x19.relationalai.lqp.v1.CastH\x00R\x04\x63\x61stB\x0e\n\x0c\x66ormula_type\">\n\x06\x45xists\x12\x34\n\x04\x62ody\x18\x03 \x01(\x0b\x32 .relationalai.lqp.v1.AbstractionR\x04\x62ody\"\xa1\x01\n\x06Reduce\x12\x30\n\x02op\x18\x01 \x01(\x0b\x32 .relationalai.lqp.v1.AbstractionR\x02op\x12\x34\n\x04\x62ody\x18\x02 \x01(\x0b\x32 .relationalai.lqp.v1.AbstractionR\x04\x62ody\x12/\n\x05terms\x18\x03 \x03(\x0b\x32\x19.relationalai.lqp.v1.TermR\x05terms\"?\n\x0b\x43onjunction\x12\x30\n\x04\x61rgs\x18\x01 \x03(\x0b\x32\x1c.relationalai.lqp.v1.FormulaR\x04\x61rgs\"?\n\x0b\x44isjunction\x12\x30\n\x04\x61rgs\x18\x01 \x03(\x0b\x32\x1c.relationalai.lqp.v1.FormulaR\x04\x61rgs\"5\n\x03Not\x12.\n\x03\x61rg\x18\x01 \x01(\x0b\x32\x1c.relationalai.lqp.v1.FormulaR\x03\x61rg\"\x80\x01\n\x03\x46\x46I\x12\x12\n\x04name\x18\x01 \x01(\tR\x04name\x12\x34\n\x04\x61rgs\x18\x02 \x03(\x0b\x32 .relationalai.lqp.v1.AbstractionR\x04\x61rgs\x12/\n\x05terms\x18\x03 \x03(\x0b\x32\x19.relationalai.lqp.v1.TermR\x05terms\"l\n\x04\x41tom\x12\x33\n\x04name\x18\x01 \x01(\x0b\x32\x1f.relationalai.lqp.v1.RelationIdR\x04name\x12/\n\x05terms\x18\x02 \x03(\x0b\x32\x19.relationalai.lqp.v1.TermR\x05terms\"M\n\x06Pragma\x12\x12\n\x04name\x18\x01 \x01(\tR\x04name\x12/\n\x05terms\x18\x02 \x03(\x0b\x32\x19.relationalai.lqp.v1.TermR\x05terms\"S\n\tPrimitive\x12\x12\n\x04name\x18\x01 \x01(\tR\x04name\x12\x32\n\x05terms\x18\x02 \x03(\x0b\x32\x1c.relationalai.lqp.v1.RelTermR\x05terms\"Q\n\x07RelAtom\x12\x12\n\x04name\x18\x03 \x01(\tR\x04name\x12\x32\n\x05terms\x18\x02 \x03(\x0b\x32\x1c.relationalai.lqp.v1.RelTermR\x05terms\"j\n\x04\x43\x61st\x12/\n\x05input\x18\x02 \x01(\x0b\x32\x19.relationalai.lqp.v1.TermR\x05input\x12\x31\n\x06result\x18\x03 \x01(\x0b\x32\x19.relationalai.lqp.v1.TermR\x06result\"\x96\x01\n\x07RelTerm\x12I\n\x11specialized_value\x18\x01 \x01(\x0b\x32\x1a.relationalai.lqp.v1.ValueH\x00R\x10specializedValue\x12/\n\x04term\x18\x02 \x01(\x0b\x32\x19.relationalai.lqp.v1.TermH\x00R\x04termB\x0f\n\rrel_term_type\"{\n\x04Term\x12,\n\x03var\x18\x01 \x01(\x0b\x32\x18.relationalai.lqp.v1.VarH\x00R\x03var\x12\x38\n\x08\x63onstant\x18\x02 \x01(\x0b\x32\x1a.relationalai.lqp.v1.ValueH\x00R\x08\x63onstantB\x0b\n\tterm_type\"\x19\n\x03Var\x12\x12\n\x04name\x18\x01 \x01(\tR\x04name\"O\n\tAttribute\x12\x12\n\x04name\x18\x01 \x01(\tR\x04name\x12.\n\x04\x61rgs\x18\x02 \x03(\x0b\x32\x1a.relationalai.lqp.v1.ValueR\x04\x61rgs\"\x93\x02\n\x04\x44\x61ta\x12,\n\x03\x65\x64\x62\x18\x01 \x01(\x0b\x32\x18.relationalai.lqp.v1.EDBH\x00R\x03\x65\x64\x62\x12N\n\x0f\x62\x65tree_relation\x18\x02 \x01(\x0b\x32#.relationalai.lqp.v1.BeTreeRelationH\x00R\x0e\x62\x65treeRelation\x12\x39\n\x08\x63sv_data\x18\x03 \x01(\x0b\x32\x1c.relationalai.lqp.v1.CSVDataH\x00R\x07\x63svData\x12\x45\n\x0ciceberg_data\x18\x04 \x01(\x0b\x32 .relationalai.lqp.v1.IcebergDataH\x00R\x0bicebergDataB\x0b\n\tdata_type\"\x88\x01\n\x03\x45\x44\x42\x12<\n\ttarget_id\x18\x01 \x01(\x0b\x32\x1f.relationalai.lqp.v1.RelationIdR\x08targetId\x12\x12\n\x04path\x18\x02 \x03(\tR\x04path\x12/\n\x05types\x18\x03 \x03(\x0b\x32\x19.relationalai.lqp.v1.TypeR\x05types\"\x8b\x01\n\x0e\x42\x65TreeRelation\x12\x33\n\x04name\x18\x01 \x01(\x0b\x32\x1f.relationalai.lqp.v1.RelationIdR\x04name\x12\x44\n\rrelation_info\x18\x02 \x01(\x0b\x32\x1f.relationalai.lqp.v1.BeTreeInfoR\x0crelationInfo\"\x9f\x02\n\nBeTreeInfo\x12\x36\n\tkey_types\x18\x01 \x03(\x0b\x32\x19.relationalai.lqp.v1.TypeR\x08keyTypes\x12:\n\x0bvalue_types\x18\x02 \x03(\x0b\x32\x19.relationalai.lqp.v1.TypeR\nvalueTypes\x12H\n\x0estorage_config\x18\x04 \x01(\x0b\x32!.relationalai.lqp.v1.BeTreeConfigR\rstorageConfig\x12M\n\x10relation_locator\x18\x05 \x01(\x0b\x32\".relationalai.lqp.v1.BeTreeLocatorR\x0frelationLocatorJ\x04\x08\x03\x10\x04\"\x81\x01\n\x0c\x42\x65TreeConfig\x12\x18\n\x07\x65psilon\x18\x01 \x01(\x01R\x07\x65psilon\x12\x1d\n\nmax_pivots\x18\x02 \x01(\x03R\tmaxPivots\x12\x1d\n\nmax_deltas\x18\x03 \x01(\x03R\tmaxDeltas\x12\x19\n\x08max_leaf\x18\x04 \x01(\x03R\x07maxLeaf\"\xca\x01\n\rBeTreeLocator\x12\x44\n\x0broot_pageid\x18\x01 \x01(\x0b\x32!.relationalai.lqp.v1.UInt128ValueH\x00R\nrootPageid\x12!\n\x0binline_data\x18\x04 \x01(\x0cH\x00R\ninlineData\x12#\n\relement_count\x18\x02 \x01(\x03R\x0c\x65lementCount\x12\x1f\n\x0btree_height\x18\x03 \x01(\x03R\ntreeHeightB\n\n\x08location\"\xcf\x01\n\x12StorageIntegration\x12\x1a\n\x08provider\x18\x01 \x01(\tR\x08provider\x12&\n\x0f\x61zure_sas_token\x18\x02 \x01(\tR\razureSasToken\x12\x1b\n\ts3_region\x18\x03 \x01(\tR\x08s3Region\x12\'\n\x10s3_access_key_id\x18\x04 \x01(\tR\rs3AccessKeyId\x12/\n\x14s3_secret_access_key\x18\x05 \x01(\tR\x11s3SecretAccessKey\"P\n\x0bNamedColumn\x12\x12\n\x04name\x18\x01 \x01(\tR\x04name\x12-\n\x04type\x18\x02 \x01(\x0b\x32\x19.relationalai.lqp.v1.TypeR\x04type\"\x88\x01\n\x0eTargetRelation\x12<\n\ttarget_id\x18\x01 \x01(\x0b\x32\x1f.relationalai.lqp.v1.RelationIdR\x08targetId\x12\x38\n\x06values\x18\x02 \x03(\x0b\x32 .relationalai.lqp.v1.NamedColumnR\x06values\"M\n\x0cPlainTargets\x12=\n\x07targets\x18\x01 \x03(\x0b\x32#.relationalai.lqp.v1.TargetRelationR\x07targets\"\x8a\x01\n\nCDCTargets\x12=\n\x07inserts\x18\x01 \x03(\x0b\x32#.relationalai.lqp.v1.TargetRelationR\x07inserts\x12=\n\x07\x64\x65letes\x18\x02 \x03(\x0b\x32#.relationalai.lqp.v1.TargetRelationR\x07\x64\x65letes\"\xbb\x02\n\x0fTargetRelations\x12\x34\n\x04keys\x18\x01 \x03(\x0b\x32 .relationalai.lqp.v1.NamedColumnR\x04keys\x12\x39\n\x05plain\x18\x02 \x01(\x0b\x32!.relationalai.lqp.v1.PlainTargetsH\x00R\x05plain\x12\x33\n\x03\x63\x64\x63\x18\x03 \x01(\x0b\x32\x1f.relationalai.lqp.v1.CDCTargetsH\x00R\x03\x63\x64\x63\x12#\n\rsynthetic_key\x18\x04 \x01(\x08R\x0csyntheticKey\x12\x45\n\x0bload_errors\x18\x05 \x01(\x0b\x32\x1f.relationalai.lqp.v1.RelationIdH\x01R\nloadErrors\x88\x01\x01\x42\x06\n\x04\x62odyB\x0e\n\x0c_load_errors\"\xa1\x02\n\x07\x43SVData\x12\x39\n\x07locator\x18\x01 \x01(\x0b\x32\x1f.relationalai.lqp.v1.CSVLocatorR\x07locator\x12\x36\n\x06\x63onfig\x18\x02 \x01(\x0b\x32\x1e.relationalai.lqp.v1.CSVConfigR\x06\x63onfig\x12\x38\n\x07\x63olumns\x18\x03 \x03(\x0b\x32\x1e.relationalai.lqp.v1.GNFColumnR\x07\x63olumns\x12\x12\n\x04\x61sof\x18\x04 \x01(\tR\x04\x61sof\x12G\n\trelations\x18\x05 \x01(\x0b\x32$.relationalai.lqp.v1.TargetRelationsH\x00R\trelations\x88\x01\x01\x42\x0c\n\n_relations\"C\n\nCSVLocator\x12\x14\n\x05paths\x18\x01 \x03(\tR\x05paths\x12\x1f\n\x0binline_data\x18\x02 \x01(\x0cR\ninlineData\"\x86\x04\n\tCSVConfig\x12\x1d\n\nheader_row\x18\x01 \x01(\x05R\theaderRow\x12\x12\n\x04skip\x18\x02 \x01(\x03R\x04skip\x12\x19\n\x08new_line\x18\x03 \x01(\tR\x07newLine\x12\x1c\n\tdelimiter\x18\x04 \x01(\tR\tdelimiter\x12\x1c\n\tquotechar\x18\x05 \x01(\tR\tquotechar\x12\x1e\n\nescapechar\x18\x06 \x01(\tR\nescapechar\x12\x18\n\x07\x63omment\x18\x07 \x01(\tR\x07\x63omment\x12\'\n\x0fmissing_strings\x18\x08 \x03(\tR\x0emissingStrings\x12+\n\x11\x64\x65\x63imal_separator\x18\t \x01(\tR\x10\x64\x65\x63imalSeparator\x12\x1a\n\x08\x65ncoding\x18\n \x01(\tR\x08\x65ncoding\x12 \n\x0b\x63ompression\x18\x0b \x01(\tR\x0b\x63ompression\x12*\n\x11partition_size_mb\x18\x0c \x01(\x03R\x0fpartitionSizeMb\x12]\n\x13storage_integration\x18\r \x01(\x0b\x32\'.relationalai.lqp.v1.StorageIntegrationH\x00R\x12storageIntegration\x88\x01\x01\x42\x16\n\x14_storage_integration\"\xe0\x02\n\x0bIcebergData\x12=\n\x07locator\x18\x01 \x01(\x0b\x32#.relationalai.lqp.v1.IcebergLocatorR\x07locator\x12\x41\n\x06\x63onfig\x18\x02 \x01(\x0b\x32).relationalai.lqp.v1.IcebergCatalogConfigR\x06\x63onfig\x12\x38\n\x07\x63olumns\x18\x03 \x03(\x0b\x32\x1e.relationalai.lqp.v1.GNFColumnR\x07\x63olumns\x12(\n\rfrom_snapshot\x18\x04 \x01(\tH\x00R\x0c\x66romSnapshot\x88\x01\x01\x12$\n\x0bto_snapshot\x18\x05 \x01(\tH\x01R\ntoSnapshot\x88\x01\x01\x12#\n\rreturns_delta\x18\x06 \x01(\x08R\x0creturnsDeltaB\x10\n\x0e_from_snapshotB\x0e\n\x0c_to_snapshot\"k\n\x0eIcebergLocator\x12\x1d\n\ntable_name\x18\x01 \x01(\tR\ttableName\x12\x1c\n\tnamespace\x18\x02 \x03(\tR\tnamespace\x12\x1c\n\twarehouse\x18\x03 \x01(\tR\twarehouse\"\xa1\x03\n\x14IcebergCatalogConfig\x12\x1f\n\x0b\x63\x61talog_uri\x18\x01 \x01(\tR\ncatalogUri\x12\x19\n\x05scope\x18\x02 \x01(\tH\x00R\x05scope\x88\x01\x01\x12Y\n\nproperties\x18\x03 \x03(\x0b\x32\x39.relationalai.lqp.v1.IcebergCatalogConfig.PropertiesEntryR\nproperties\x12\x66\n\x0f\x61uth_properties\x18\x04 \x03(\x0b\x32=.relationalai.lqp.v1.IcebergCatalogConfig.AuthPropertiesEntryR\x0e\x61uthProperties\x1a=\n\x0fPropertiesEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n\x05value\x18\x02 \x01(\tR\x05value:\x02\x38\x01\x1a\x41\n\x13\x41uthPropertiesEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n\x05value\x18\x02 \x01(\tR\x05value:\x02\x38\x01\x42\x08\n\x06_scope\"\xae\x01\n\tGNFColumn\x12\x1f\n\x0b\x63olumn_path\x18\x01 \x03(\tR\ncolumnPath\x12\x41\n\ttarget_id\x18\x02 \x01(\x0b\x32\x1f.relationalai.lqp.v1.RelationIdH\x00R\x08targetId\x88\x01\x01\x12/\n\x05types\x18\x03 \x03(\x0b\x32\x19.relationalai.lqp.v1.TypeR\x05typesB\x0c\n\n_target_id\"<\n\nRelationId\x12\x15\n\x06id_low\x18\x01 \x01(\x06R\x05idLow\x12\x17\n\x07id_high\x18\x02 \x01(\x06R\x06idHigh\"\xd5\x07\n\x04Type\x12Q\n\x10unspecified_type\x18\x01 \x01(\x0b\x32$.relationalai.lqp.v1.UnspecifiedTypeH\x00R\x0funspecifiedType\x12\x42\n\x0bstring_type\x18\x02 \x01(\x0b\x32\x1f.relationalai.lqp.v1.StringTypeH\x00R\nstringType\x12\x39\n\x08int_type\x18\x03 \x01(\x0b\x32\x1c.relationalai.lqp.v1.IntTypeH\x00R\x07intType\x12?\n\nfloat_type\x18\x04 \x01(\x0b\x32\x1e.relationalai.lqp.v1.FloatTypeH\x00R\tfloatType\x12\x45\n\x0cuint128_type\x18\x05 \x01(\x0b\x32 .relationalai.lqp.v1.UInt128TypeH\x00R\x0buint128Type\x12\x42\n\x0bint128_type\x18\x06 \x01(\x0b\x32\x1f.relationalai.lqp.v1.Int128TypeH\x00R\nint128Type\x12<\n\tdate_type\x18\x07 \x01(\x0b\x32\x1d.relationalai.lqp.v1.DateTypeH\x00R\x08\x64\x61teType\x12H\n\rdatetime_type\x18\x08 \x01(\x0b\x32!.relationalai.lqp.v1.DateTimeTypeH\x00R\x0c\x64\x61tetimeType\x12\x45\n\x0cmissing_type\x18\t \x01(\x0b\x32 .relationalai.lqp.v1.MissingTypeH\x00R\x0bmissingType\x12\x45\n\x0c\x64\x65\x63imal_type\x18\n \x01(\x0b\x32 .relationalai.lqp.v1.DecimalTypeH\x00R\x0b\x64\x65\x63imalType\x12\x45\n\x0c\x62oolean_type\x18\x0b \x01(\x0b\x32 .relationalai.lqp.v1.BooleanTypeH\x00R\x0b\x62ooleanType\x12?\n\nint32_type\x18\x0c \x01(\x0b\x32\x1e.relationalai.lqp.v1.Int32TypeH\x00R\tint32Type\x12\x45\n\x0c\x66loat32_type\x18\r \x01(\x0b\x32 .relationalai.lqp.v1.Float32TypeH\x00R\x0b\x66loat32Type\x12\x42\n\x0buint32_type\x18\x0e \x01(\x0b\x32\x1f.relationalai.lqp.v1.UInt32TypeH\x00R\nuint32TypeB\x06\n\x04type\"\x11\n\x0fUnspecifiedType\"\x0c\n\nStringType\"\t\n\x07IntType\"\x0b\n\tFloatType\"\r\n\x0bUInt128Type\"\x0c\n\nInt128Type\"\n\n\x08\x44\x61teType\"\x0e\n\x0c\x44\x61teTimeType\"\r\n\x0bMissingType\"A\n\x0b\x44\x65\x63imalType\x12\x1c\n\tprecision\x18\x01 \x01(\x05R\tprecision\x12\x14\n\x05scale\x18\x02 \x01(\x05R\x05scale\"\r\n\x0b\x42ooleanType\"\x0b\n\tInt32Type\"\r\n\x0b\x46loat32Type\"\x0c\n\nUInt32Type\"\xc0\x05\n\x05Value\x12#\n\x0cstring_value\x18\x01 \x01(\tH\x00R\x0bstringValue\x12\x1d\n\tint_value\x18\x02 \x01(\x03H\x00R\x08intValue\x12!\n\x0b\x66loat_value\x18\x03 \x01(\x01H\x00R\nfloatValue\x12H\n\ruint128_value\x18\x04 \x01(\x0b\x32!.relationalai.lqp.v1.UInt128ValueH\x00R\x0cuint128Value\x12\x45\n\x0cint128_value\x18\x05 \x01(\x0b\x32 .relationalai.lqp.v1.Int128ValueH\x00R\x0bint128Value\x12H\n\rmissing_value\x18\x06 \x01(\x0b\x32!.relationalai.lqp.v1.MissingValueH\x00R\x0cmissingValue\x12?\n\ndate_value\x18\x07 \x01(\x0b\x32\x1e.relationalai.lqp.v1.DateValueH\x00R\tdateValue\x12K\n\x0e\x64\x61tetime_value\x18\x08 \x01(\x0b\x32\".relationalai.lqp.v1.DateTimeValueH\x00R\rdatetimeValue\x12H\n\rdecimal_value\x18\t \x01(\x0b\x32!.relationalai.lqp.v1.DecimalValueH\x00R\x0c\x64\x65\x63imalValue\x12%\n\rboolean_value\x18\n \x01(\x08H\x00R\x0c\x62ooleanValue\x12!\n\x0bint32_value\x18\x0b \x01(\x05H\x00R\nint32Value\x12%\n\rfloat32_value\x18\x0c \x01(\x02H\x00R\x0c\x66loat32Value\x12#\n\x0cuint32_value\x18\r \x01(\rH\x00R\x0buint32ValueB\x07\n\x05value\"4\n\x0cUInt128Value\x12\x10\n\x03low\x18\x01 \x01(\x06R\x03low\x12\x12\n\x04high\x18\x02 \x01(\x06R\x04high\"3\n\x0bInt128Value\x12\x10\n\x03low\x18\x01 \x01(\x06R\x03low\x12\x12\n\x04high\x18\x02 \x01(\x06R\x04high\"\x0e\n\x0cMissingValue\"G\n\tDateValue\x12\x12\n\x04year\x18\x01 \x01(\x05R\x04year\x12\x14\n\x05month\x18\x02 \x01(\x05R\x05month\x12\x10\n\x03\x64\x61y\x18\x03 \x01(\x05R\x03\x64\x61y\"\xb1\x01\n\rDateTimeValue\x12\x12\n\x04year\x18\x01 \x01(\x05R\x04year\x12\x14\n\x05month\x18\x02 \x01(\x05R\x05month\x12\x10\n\x03\x64\x61y\x18\x03 \x01(\x05R\x03\x64\x61y\x12\x12\n\x04hour\x18\x04 \x01(\x05R\x04hour\x12\x16\n\x06minute\x18\x05 \x01(\x05R\x06minute\x12\x16\n\x06second\x18\x06 \x01(\x05R\x06second\x12 \n\x0bmicrosecond\x18\x07 \x01(\x05R\x0bmicrosecond\"z\n\x0c\x44\x65\x63imalValue\x12\x1c\n\tprecision\x18\x01 \x01(\x05R\tprecision\x12\x14\n\x05scale\x18\x02 \x01(\x05R\x05scale\x12\x36\n\x05value\x18\x03 \x01(\x0b\x32 .relationalai.lqp.v1.Int128ValueR\x05valueBCZAgithub.com/RelationalAI/logical-query-protocol/sdks/go/src/lqp/v1b\x06proto3') +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x1frelationalai/lqp/v1/logic.proto\x12\x13relationalai.lqp.v1\"\x83\x02\n\x0b\x44\x65\x63laration\x12,\n\x03\x64\x65\x66\x18\x01 \x01(\x0b\x32\x18.relationalai.lqp.v1.DefH\x00R\x03\x64\x65\x66\x12>\n\talgorithm\x18\x02 \x01(\x0b\x32\x1e.relationalai.lqp.v1.AlgorithmH\x00R\talgorithm\x12\x41\n\nconstraint\x18\x03 \x01(\x0b\x32\x1f.relationalai.lqp.v1.ConstraintH\x00R\nconstraint\x12/\n\x04\x64\x61ta\x18\x04 \x01(\x0b\x32\x19.relationalai.lqp.v1.DataH\x00R\x04\x64\x61taB\x12\n\x10\x64\x65\x63laration_type\"\xa6\x01\n\x03\x44\x65\x66\x12\x33\n\x04name\x18\x01 \x01(\x0b\x32\x1f.relationalai.lqp.v1.RelationIdR\x04name\x12\x34\n\x04\x62ody\x18\x02 \x01(\x0b\x32 .relationalai.lqp.v1.AbstractionR\x04\x62ody\x12\x34\n\x05\x61ttrs\x18\x03 \x03(\x0b\x32\x1e.relationalai.lqp.v1.AttributeR\x05\x61ttrs\"\xb6\x01\n\nConstraint\x12\x33\n\x04name\x18\x02 \x01(\x0b\x32\x1f.relationalai.lqp.v1.RelationIdR\x04name\x12`\n\x15\x66unctional_dependency\x18\x01 \x01(\x0b\x32).relationalai.lqp.v1.FunctionalDependencyH\x00R\x14\x66unctionalDependencyB\x11\n\x0f\x63onstraint_type\"\xae\x01\n\x14\x46unctionalDependency\x12\x36\n\x05guard\x18\x01 \x01(\x0b\x32 .relationalai.lqp.v1.AbstractionR\x05guard\x12,\n\x04keys\x18\x02 \x03(\x0b\x32\x18.relationalai.lqp.v1.VarR\x04keys\x12\x30\n\x06values\x18\x03 \x03(\x0b\x32\x18.relationalai.lqp.v1.VarR\x06values\"\xab\x01\n\tAlgorithm\x12\x37\n\x06global\x18\x01 \x03(\x0b\x32\x1f.relationalai.lqp.v1.RelationIdR\x06global\x12/\n\x04\x62ody\x18\x02 \x01(\x0b\x32\x1b.relationalai.lqp.v1.ScriptR\x04\x62ody\x12\x34\n\x05\x61ttrs\x18\x03 \x03(\x0b\x32\x1e.relationalai.lqp.v1.AttributeR\x05\x61ttrs\"H\n\x06Script\x12>\n\nconstructs\x18\x01 \x03(\x0b\x32\x1e.relationalai.lqp.v1.ConstructR\nconstructs\"\x94\x01\n\tConstruct\x12/\n\x04loop\x18\x01 \x01(\x0b\x32\x19.relationalai.lqp.v1.LoopH\x00R\x04loop\x12\x44\n\x0binstruction\x18\x02 \x01(\x0b\x32 .relationalai.lqp.v1.InstructionH\x00R\x0binstructionB\x10\n\x0e\x63onstruct_type\"\xa3\x01\n\x04Loop\x12\x34\n\x04init\x18\x01 \x03(\x0b\x32 .relationalai.lqp.v1.InstructionR\x04init\x12/\n\x04\x62ody\x18\x02 \x01(\x0b\x32\x1b.relationalai.lqp.v1.ScriptR\x04\x62ody\x12\x34\n\x05\x61ttrs\x18\x03 \x03(\x0b\x32\x1e.relationalai.lqp.v1.AttributeR\x05\x61ttrs\"\xc2\x02\n\x0bInstruction\x12\x35\n\x06\x61ssign\x18\x01 \x01(\x0b\x32\x1b.relationalai.lqp.v1.AssignH\x00R\x06\x61ssign\x12\x35\n\x06upsert\x18\x02 \x01(\x0b\x32\x1b.relationalai.lqp.v1.UpsertH\x00R\x06upsert\x12\x32\n\x05\x62reak\x18\x03 \x01(\x0b\x32\x1a.relationalai.lqp.v1.BreakH\x00R\x05\x62reak\x12?\n\nmonoid_def\x18\x05 \x01(\x0b\x32\x1e.relationalai.lqp.v1.MonoidDefH\x00R\tmonoidDef\x12<\n\tmonus_def\x18\x06 \x01(\x0b\x32\x1d.relationalai.lqp.v1.MonusDefH\x00R\x08monusDefB\x0c\n\ninstr_typeJ\x04\x08\x04\x10\x05\"\xa9\x01\n\x06\x41ssign\x12\x33\n\x04name\x18\x01 \x01(\x0b\x32\x1f.relationalai.lqp.v1.RelationIdR\x04name\x12\x34\n\x04\x62ody\x18\x02 \x01(\x0b\x32 .relationalai.lqp.v1.AbstractionR\x04\x62ody\x12\x34\n\x05\x61ttrs\x18\x03 \x03(\x0b\x32\x1e.relationalai.lqp.v1.AttributeR\x05\x61ttrs\"\xca\x01\n\x06Upsert\x12\x33\n\x04name\x18\x01 \x01(\x0b\x32\x1f.relationalai.lqp.v1.RelationIdR\x04name\x12\x34\n\x04\x62ody\x18\x02 \x01(\x0b\x32 .relationalai.lqp.v1.AbstractionR\x04\x62ody\x12\x34\n\x05\x61ttrs\x18\x03 \x03(\x0b\x32\x1e.relationalai.lqp.v1.AttributeR\x05\x61ttrs\x12\x1f\n\x0bvalue_arity\x18\x04 \x01(\x03R\nvalueArity\"\xa8\x01\n\x05\x42reak\x12\x33\n\x04name\x18\x01 \x01(\x0b\x32\x1f.relationalai.lqp.v1.RelationIdR\x04name\x12\x34\n\x04\x62ody\x18\x02 \x01(\x0b\x32 .relationalai.lqp.v1.AbstractionR\x04\x62ody\x12\x34\n\x05\x61ttrs\x18\x03 \x03(\x0b\x32\x1e.relationalai.lqp.v1.AttributeR\x05\x61ttrs\"\x82\x02\n\tMonoidDef\x12\x33\n\x06monoid\x18\x01 \x01(\x0b\x32\x1b.relationalai.lqp.v1.MonoidR\x06monoid\x12\x33\n\x04name\x18\x02 \x01(\x0b\x32\x1f.relationalai.lqp.v1.RelationIdR\x04name\x12\x34\n\x04\x62ody\x18\x03 \x01(\x0b\x32 .relationalai.lqp.v1.AbstractionR\x04\x62ody\x12\x34\n\x05\x61ttrs\x18\x04 \x03(\x0b\x32\x1e.relationalai.lqp.v1.AttributeR\x05\x61ttrs\x12\x1f\n\x0bvalue_arity\x18\x05 \x01(\x03R\nvalueArity\"\x81\x02\n\x08MonusDef\x12\x33\n\x06monoid\x18\x01 \x01(\x0b\x32\x1b.relationalai.lqp.v1.MonoidR\x06monoid\x12\x33\n\x04name\x18\x02 \x01(\x0b\x32\x1f.relationalai.lqp.v1.RelationIdR\x04name\x12\x34\n\x04\x62ody\x18\x03 \x01(\x0b\x32 .relationalai.lqp.v1.AbstractionR\x04\x62ody\x12\x34\n\x05\x61ttrs\x18\x04 \x03(\x0b\x32\x1e.relationalai.lqp.v1.AttributeR\x05\x61ttrs\x12\x1f\n\x0bvalue_arity\x18\x05 \x01(\x03R\nvalueArity\"\x92\x02\n\x06Monoid\x12<\n\tor_monoid\x18\x01 \x01(\x0b\x32\x1d.relationalai.lqp.v1.OrMonoidH\x00R\x08orMonoid\x12?\n\nmin_monoid\x18\x02 \x01(\x0b\x32\x1e.relationalai.lqp.v1.MinMonoidH\x00R\tminMonoid\x12?\n\nmax_monoid\x18\x03 \x01(\x0b\x32\x1e.relationalai.lqp.v1.MaxMonoidH\x00R\tmaxMonoid\x12?\n\nsum_monoid\x18\x04 \x01(\x0b\x32\x1e.relationalai.lqp.v1.SumMonoidH\x00R\tsumMonoidB\x07\n\x05value\"\n\n\x08OrMonoid\":\n\tMinMonoid\x12-\n\x04type\x18\x01 \x01(\x0b\x32\x19.relationalai.lqp.v1.TypeR\x04type\":\n\tMaxMonoid\x12-\n\x04type\x18\x01 \x01(\x0b\x32\x19.relationalai.lqp.v1.TypeR\x04type\":\n\tSumMonoid\x12-\n\x04type\x18\x01 \x01(\x0b\x32\x19.relationalai.lqp.v1.TypeR\x04type\"d\n\x07\x42inding\x12*\n\x03var\x18\x01 \x01(\x0b\x32\x18.relationalai.lqp.v1.VarR\x03var\x12-\n\x04type\x18\x02 \x01(\x0b\x32\x19.relationalai.lqp.v1.TypeR\x04type\"s\n\x0b\x41\x62straction\x12\x30\n\x04vars\x18\x01 \x03(\x0b\x32\x1c.relationalai.lqp.v1.BindingR\x04vars\x12\x32\n\x05value\x18\x02 \x01(\x0b\x32\x1c.relationalai.lqp.v1.FormulaR\x05value\"\x83\x05\n\x07\x46ormula\x12\x35\n\x06\x65xists\x18\x01 \x01(\x0b\x32\x1b.relationalai.lqp.v1.ExistsH\x00R\x06\x65xists\x12\x35\n\x06reduce\x18\x02 \x01(\x0b\x32\x1b.relationalai.lqp.v1.ReduceH\x00R\x06reduce\x12\x44\n\x0b\x63onjunction\x18\x03 \x01(\x0b\x32 .relationalai.lqp.v1.ConjunctionH\x00R\x0b\x63onjunction\x12\x44\n\x0b\x64isjunction\x18\x04 \x01(\x0b\x32 .relationalai.lqp.v1.DisjunctionH\x00R\x0b\x64isjunction\x12,\n\x03not\x18\x05 \x01(\x0b\x32\x18.relationalai.lqp.v1.NotH\x00R\x03not\x12,\n\x03\x66\x66i\x18\x06 \x01(\x0b\x32\x18.relationalai.lqp.v1.FFIH\x00R\x03\x66\x66i\x12/\n\x04\x61tom\x18\x07 \x01(\x0b\x32\x19.relationalai.lqp.v1.AtomH\x00R\x04\x61tom\x12\x35\n\x06pragma\x18\x08 \x01(\x0b\x32\x1b.relationalai.lqp.v1.PragmaH\x00R\x06pragma\x12>\n\tprimitive\x18\t \x01(\x0b\x32\x1e.relationalai.lqp.v1.PrimitiveH\x00R\tprimitive\x12\x39\n\x08rel_atom\x18\n \x01(\x0b\x32\x1c.relationalai.lqp.v1.RelAtomH\x00R\x07relAtom\x12/\n\x04\x63\x61st\x18\x0b \x01(\x0b\x32\x19.relationalai.lqp.v1.CastH\x00R\x04\x63\x61stB\x0e\n\x0c\x66ormula_type\">\n\x06\x45xists\x12\x34\n\x04\x62ody\x18\x03 \x01(\x0b\x32 .relationalai.lqp.v1.AbstractionR\x04\x62ody\"\xa1\x01\n\x06Reduce\x12\x30\n\x02op\x18\x01 \x01(\x0b\x32 .relationalai.lqp.v1.AbstractionR\x02op\x12\x34\n\x04\x62ody\x18\x02 \x01(\x0b\x32 .relationalai.lqp.v1.AbstractionR\x04\x62ody\x12/\n\x05terms\x18\x03 \x03(\x0b\x32\x19.relationalai.lqp.v1.TermR\x05terms\"?\n\x0b\x43onjunction\x12\x30\n\x04\x61rgs\x18\x01 \x03(\x0b\x32\x1c.relationalai.lqp.v1.FormulaR\x04\x61rgs\"?\n\x0b\x44isjunction\x12\x30\n\x04\x61rgs\x18\x01 \x03(\x0b\x32\x1c.relationalai.lqp.v1.FormulaR\x04\x61rgs\"5\n\x03Not\x12.\n\x03\x61rg\x18\x01 \x01(\x0b\x32\x1c.relationalai.lqp.v1.FormulaR\x03\x61rg\"\x80\x01\n\x03\x46\x46I\x12\x12\n\x04name\x18\x01 \x01(\tR\x04name\x12\x34\n\x04\x61rgs\x18\x02 \x03(\x0b\x32 .relationalai.lqp.v1.AbstractionR\x04\x61rgs\x12/\n\x05terms\x18\x03 \x03(\x0b\x32\x19.relationalai.lqp.v1.TermR\x05terms\"l\n\x04\x41tom\x12\x33\n\x04name\x18\x01 \x01(\x0b\x32\x1f.relationalai.lqp.v1.RelationIdR\x04name\x12/\n\x05terms\x18\x02 \x03(\x0b\x32\x19.relationalai.lqp.v1.TermR\x05terms\"M\n\x06Pragma\x12\x12\n\x04name\x18\x01 \x01(\tR\x04name\x12/\n\x05terms\x18\x02 \x03(\x0b\x32\x19.relationalai.lqp.v1.TermR\x05terms\"S\n\tPrimitive\x12\x12\n\x04name\x18\x01 \x01(\tR\x04name\x12\x32\n\x05terms\x18\x02 \x03(\x0b\x32\x1c.relationalai.lqp.v1.RelTermR\x05terms\"Q\n\x07RelAtom\x12\x12\n\x04name\x18\x03 \x01(\tR\x04name\x12\x32\n\x05terms\x18\x02 \x03(\x0b\x32\x1c.relationalai.lqp.v1.RelTermR\x05terms\"j\n\x04\x43\x61st\x12/\n\x05input\x18\x02 \x01(\x0b\x32\x19.relationalai.lqp.v1.TermR\x05input\x12\x31\n\x06result\x18\x03 \x01(\x0b\x32\x19.relationalai.lqp.v1.TermR\x06result\"\x96\x01\n\x07RelTerm\x12I\n\x11specialized_value\x18\x01 \x01(\x0b\x32\x1a.relationalai.lqp.v1.ValueH\x00R\x10specializedValue\x12/\n\x04term\x18\x02 \x01(\x0b\x32\x19.relationalai.lqp.v1.TermH\x00R\x04termB\x0f\n\rrel_term_type\"{\n\x04Term\x12,\n\x03var\x18\x01 \x01(\x0b\x32\x18.relationalai.lqp.v1.VarH\x00R\x03var\x12\x38\n\x08\x63onstant\x18\x02 \x01(\x0b\x32\x1a.relationalai.lqp.v1.ValueH\x00R\x08\x63onstantB\x0b\n\tterm_type\"\x19\n\x03Var\x12\x12\n\x04name\x18\x01 \x01(\tR\x04name\"O\n\tAttribute\x12\x12\n\x04name\x18\x01 \x01(\tR\x04name\x12.\n\x04\x61rgs\x18\x02 \x03(\x0b\x32\x1a.relationalai.lqp.v1.ValueR\x04\x61rgs\"\x93\x02\n\x04\x44\x61ta\x12,\n\x03\x65\x64\x62\x18\x01 \x01(\x0b\x32\x18.relationalai.lqp.v1.EDBH\x00R\x03\x65\x64\x62\x12N\n\x0f\x62\x65tree_relation\x18\x02 \x01(\x0b\x32#.relationalai.lqp.v1.BeTreeRelationH\x00R\x0e\x62\x65treeRelation\x12\x39\n\x08\x63sv_data\x18\x03 \x01(\x0b\x32\x1c.relationalai.lqp.v1.CSVDataH\x00R\x07\x63svData\x12\x45\n\x0ciceberg_data\x18\x04 \x01(\x0b\x32 .relationalai.lqp.v1.IcebergDataH\x00R\x0bicebergDataB\x0b\n\tdata_type\"\x88\x01\n\x03\x45\x44\x42\x12<\n\ttarget_id\x18\x01 \x01(\x0b\x32\x1f.relationalai.lqp.v1.RelationIdR\x08targetId\x12\x12\n\x04path\x18\x02 \x03(\tR\x04path\x12/\n\x05types\x18\x03 \x03(\x0b\x32\x19.relationalai.lqp.v1.TypeR\x05types\"\x8b\x01\n\x0e\x42\x65TreeRelation\x12\x33\n\x04name\x18\x01 \x01(\x0b\x32\x1f.relationalai.lqp.v1.RelationIdR\x04name\x12\x44\n\rrelation_info\x18\x02 \x01(\x0b\x32\x1f.relationalai.lqp.v1.BeTreeInfoR\x0crelationInfo\"\x9f\x02\n\nBeTreeInfo\x12\x36\n\tkey_types\x18\x01 \x03(\x0b\x32\x19.relationalai.lqp.v1.TypeR\x08keyTypes\x12:\n\x0bvalue_types\x18\x02 \x03(\x0b\x32\x19.relationalai.lqp.v1.TypeR\nvalueTypes\x12H\n\x0estorage_config\x18\x04 \x01(\x0b\x32!.relationalai.lqp.v1.BeTreeConfigR\rstorageConfig\x12M\n\x10relation_locator\x18\x05 \x01(\x0b\x32\".relationalai.lqp.v1.BeTreeLocatorR\x0frelationLocatorJ\x04\x08\x03\x10\x04\"\x81\x01\n\x0c\x42\x65TreeConfig\x12\x18\n\x07\x65psilon\x18\x01 \x01(\x01R\x07\x65psilon\x12\x1d\n\nmax_pivots\x18\x02 \x01(\x03R\tmaxPivots\x12\x1d\n\nmax_deltas\x18\x03 \x01(\x03R\tmaxDeltas\x12\x19\n\x08max_leaf\x18\x04 \x01(\x03R\x07maxLeaf\"\xca\x01\n\rBeTreeLocator\x12\x44\n\x0broot_pageid\x18\x01 \x01(\x0b\x32!.relationalai.lqp.v1.UInt128ValueH\x00R\nrootPageid\x12!\n\x0binline_data\x18\x04 \x01(\x0cH\x00R\ninlineData\x12#\n\relement_count\x18\x02 \x01(\x03R\x0c\x65lementCount\x12\x1f\n\x0btree_height\x18\x03 \x01(\x03R\ntreeHeightB\n\n\x08location\"\xcf\x01\n\x12StorageIntegration\x12\x1a\n\x08provider\x18\x01 \x01(\tR\x08provider\x12&\n\x0f\x61zure_sas_token\x18\x02 \x01(\tR\razureSasToken\x12\x1b\n\ts3_region\x18\x03 \x01(\tR\x08s3Region\x12\'\n\x10s3_access_key_id\x18\x04 \x01(\tR\rs3AccessKeyId\x12/\n\x14s3_secret_access_key\x18\x05 \x01(\tR\x11s3SecretAccessKey\"P\n\x0bNamedColumn\x12\x12\n\x04name\x18\x01 \x01(\tR\x04name\x12-\n\x04type\x18\x02 \x01(\x0b\x32\x19.relationalai.lqp.v1.TypeR\x04type\"\x88\x01\n\x0eTargetRelation\x12<\n\ttarget_id\x18\x01 \x01(\x0b\x32\x1f.relationalai.lqp.v1.RelationIdR\x08targetId\x12\x38\n\x06values\x18\x02 \x03(\x0b\x32 .relationalai.lqp.v1.NamedColumnR\x06values\"M\n\x0cPlainTargets\x12=\n\x07targets\x18\x01 \x03(\x0b\x32#.relationalai.lqp.v1.TargetRelationR\x07targets\"\x8a\x01\n\nCDCTargets\x12=\n\x07inserts\x18\x01 \x03(\x0b\x32#.relationalai.lqp.v1.TargetRelationR\x07inserts\x12=\n\x07\x64\x65letes\x18\x02 \x03(\x0b\x32#.relationalai.lqp.v1.TargetRelationR\x07\x64\x65letes\"\xbb\x02\n\x0fTargetRelations\x12\x34\n\x04keys\x18\x01 \x03(\x0b\x32 .relationalai.lqp.v1.NamedColumnR\x04keys\x12\x39\n\x05plain\x18\x02 \x01(\x0b\x32!.relationalai.lqp.v1.PlainTargetsH\x00R\x05plain\x12\x33\n\x03\x63\x64\x63\x18\x03 \x01(\x0b\x32\x1f.relationalai.lqp.v1.CDCTargetsH\x00R\x03\x63\x64\x63\x12#\n\rsynthetic_key\x18\x04 \x01(\x08R\x0csyntheticKey\x12\x45\n\x0bload_errors\x18\x05 \x01(\x0b\x32\x1f.relationalai.lqp.v1.RelationIdH\x01R\nloadErrors\x88\x01\x01\x42\x06\n\x04\x62odyB\x0e\n\x0c_load_errors\"\xa1\x02\n\x07\x43SVData\x12\x39\n\x07locator\x18\x01 \x01(\x0b\x32\x1f.relationalai.lqp.v1.CSVLocatorR\x07locator\x12\x36\n\x06\x63onfig\x18\x02 \x01(\x0b\x32\x1e.relationalai.lqp.v1.CSVConfigR\x06\x63onfig\x12\x38\n\x07\x63olumns\x18\x03 \x03(\x0b\x32\x1e.relationalai.lqp.v1.GNFColumnR\x07\x63olumns\x12\x12\n\x04\x61sof\x18\x04 \x01(\tR\x04\x61sof\x12G\n\trelations\x18\x05 \x01(\x0b\x32$.relationalai.lqp.v1.TargetRelationsH\x00R\trelations\x88\x01\x01\x42\x0c\n\n_relations\"C\n\nCSVLocator\x12\x14\n\x05paths\x18\x01 \x03(\tR\x05paths\x12\x1f\n\x0binline_data\x18\x02 \x01(\x0cR\ninlineData\"\x86\x04\n\tCSVConfig\x12\x1d\n\nheader_row\x18\x01 \x01(\x05R\theaderRow\x12\x12\n\x04skip\x18\x02 \x01(\x03R\x04skip\x12\x19\n\x08new_line\x18\x03 \x01(\tR\x07newLine\x12\x1c\n\tdelimiter\x18\x04 \x01(\tR\tdelimiter\x12\x1c\n\tquotechar\x18\x05 \x01(\tR\tquotechar\x12\x1e\n\nescapechar\x18\x06 \x01(\tR\nescapechar\x12\x18\n\x07\x63omment\x18\x07 \x01(\tR\x07\x63omment\x12\'\n\x0fmissing_strings\x18\x08 \x03(\tR\x0emissingStrings\x12+\n\x11\x64\x65\x63imal_separator\x18\t \x01(\tR\x10\x64\x65\x63imalSeparator\x12\x1a\n\x08\x65ncoding\x18\n \x01(\tR\x08\x65ncoding\x12 \n\x0b\x63ompression\x18\x0b \x01(\tR\x0b\x63ompression\x12*\n\x11partition_size_mb\x18\x0c \x01(\x03R\x0fpartitionSizeMb\x12]\n\x13storage_integration\x18\r \x01(\x0b\x32\'.relationalai.lqp.v1.StorageIntegrationH\x00R\x12storageIntegration\x88\x01\x01\x42\x16\n\x14_storage_integration\"\xe0\x02\n\x0bIcebergData\x12=\n\x07locator\x18\x01 \x01(\x0b\x32#.relationalai.lqp.v1.IcebergLocatorR\x07locator\x12\x41\n\x06\x63onfig\x18\x02 \x01(\x0b\x32).relationalai.lqp.v1.IcebergCatalogConfigR\x06\x63onfig\x12\x38\n\x07\x63olumns\x18\x03 \x03(\x0b\x32\x1e.relationalai.lqp.v1.GNFColumnR\x07\x63olumns\x12(\n\rfrom_snapshot\x18\x04 \x01(\tH\x00R\x0c\x66romSnapshot\x88\x01\x01\x12$\n\x0bto_snapshot\x18\x05 \x01(\tH\x01R\ntoSnapshot\x88\x01\x01\x12#\n\rreturns_delta\x18\x06 \x01(\x08R\x0creturnsDeltaB\x10\n\x0e_from_snapshotB\x0e\n\x0c_to_snapshot\"k\n\x0eIcebergLocator\x12\x1d\n\ntable_name\x18\x01 \x01(\tR\ttableName\x12\x1c\n\tnamespace\x18\x02 \x03(\tR\tnamespace\x12\x1c\n\twarehouse\x18\x03 \x01(\tR\twarehouse\"\xa1\x03\n\x14IcebergCatalogConfig\x12\x1f\n\x0b\x63\x61talog_uri\x18\x01 \x01(\tR\ncatalogUri\x12\x19\n\x05scope\x18\x02 \x01(\tH\x00R\x05scope\x88\x01\x01\x12Y\n\nproperties\x18\x03 \x03(\x0b\x32\x39.relationalai.lqp.v1.IcebergCatalogConfig.PropertiesEntryR\nproperties\x12\x66\n\x0f\x61uth_properties\x18\x04 \x03(\x0b\x32=.relationalai.lqp.v1.IcebergCatalogConfig.AuthPropertiesEntryR\x0e\x61uthProperties\x1a=\n\x0fPropertiesEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n\x05value\x18\x02 \x01(\tR\x05value:\x02\x38\x01\x1a\x41\n\x13\x41uthPropertiesEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n\x05value\x18\x02 \x01(\tR\x05value:\x02\x38\x01\x42\x08\n\x06_scope\"\xae\x01\n\tGNFColumn\x12\x1f\n\x0b\x63olumn_path\x18\x01 \x03(\tR\ncolumnPath\x12\x41\n\ttarget_id\x18\x02 \x01(\x0b\x32\x1f.relationalai.lqp.v1.RelationIdH\x00R\x08targetId\x88\x01\x01\x12/\n\x05types\x18\x03 \x03(\x0b\x32\x19.relationalai.lqp.v1.TypeR\x05typesB\x0c\n\n_target_id\"<\n\nRelationId\x12\x15\n\x06id_low\x18\x01 \x01(\x06R\x05idLow\x12\x17\n\x07id_high\x18\x02 \x01(\x06R\x06idHigh\"\x96\x08\n\x04Type\x12Q\n\x10unspecified_type\x18\x01 \x01(\x0b\x32$.relationalai.lqp.v1.UnspecifiedTypeH\x00R\x0funspecifiedType\x12\x42\n\x0bstring_type\x18\x02 \x01(\x0b\x32\x1f.relationalai.lqp.v1.StringTypeH\x00R\nstringType\x12\x39\n\x08int_type\x18\x03 \x01(\x0b\x32\x1c.relationalai.lqp.v1.IntTypeH\x00R\x07intType\x12?\n\nfloat_type\x18\x04 \x01(\x0b\x32\x1e.relationalai.lqp.v1.FloatTypeH\x00R\tfloatType\x12\x45\n\x0cuint128_type\x18\x05 \x01(\x0b\x32 .relationalai.lqp.v1.UInt128TypeH\x00R\x0buint128Type\x12\x42\n\x0bint128_type\x18\x06 \x01(\x0b\x32\x1f.relationalai.lqp.v1.Int128TypeH\x00R\nint128Type\x12<\n\tdate_type\x18\x07 \x01(\x0b\x32\x1d.relationalai.lqp.v1.DateTypeH\x00R\x08\x64\x61teType\x12H\n\rdatetime_type\x18\x08 \x01(\x0b\x32!.relationalai.lqp.v1.DateTimeTypeH\x00R\x0c\x64\x61tetimeType\x12\x45\n\x0cmissing_type\x18\t \x01(\x0b\x32 .relationalai.lqp.v1.MissingTypeH\x00R\x0bmissingType\x12\x45\n\x0c\x64\x65\x63imal_type\x18\n \x01(\x0b\x32 .relationalai.lqp.v1.DecimalTypeH\x00R\x0b\x64\x65\x63imalType\x12\x45\n\x0c\x62oolean_type\x18\x0b \x01(\x0b\x32 .relationalai.lqp.v1.BooleanTypeH\x00R\x0b\x62ooleanType\x12?\n\nint32_type\x18\x0c \x01(\x0b\x32\x1e.relationalai.lqp.v1.Int32TypeH\x00R\tint32Type\x12\x45\n\x0c\x66loat32_type\x18\r \x01(\x0b\x32 .relationalai.lqp.v1.Float32TypeH\x00R\x0b\x66loat32Type\x12\x42\n\x0buint32_type\x18\x0e \x01(\x0b\x32\x1f.relationalai.lqp.v1.UInt32TypeH\x00R\nuint32Type\x12?\n\nfixed_type\x18\x0f \x01(\x0b\x32\x1e.relationalai.lqp.v1.FixedTypeH\x00R\tfixedTypeB\x06\n\x04type\"\x11\n\x0fUnspecifiedType\"\x0c\n\nStringType\"\t\n\x07IntType\"\x0b\n\tFloatType\"\r\n\x0bUInt128Type\"\x0c\n\nInt128Type\"\n\n\x08\x44\x61teType\"\x0e\n\x0c\x44\x61teTimeType\"\r\n\x0bMissingType\"A\n\x0b\x44\x65\x63imalType\x12\x1c\n\tprecision\x18\x01 \x01(\x05R\tprecision\x12\x14\n\x05scale\x18\x02 \x01(\x05R\x05scale\"\r\n\x0b\x42ooleanType\"\x0b\n\tInt32Type\"\r\n\x0b\x46loat32Type\"\x0c\n\nUInt32Type\"#\n\tFixedType\x12\x16\n\x06length\x18\x01 \x01(\x05R\x06length\"\xc0\x05\n\x05Value\x12#\n\x0cstring_value\x18\x01 \x01(\tH\x00R\x0bstringValue\x12\x1d\n\tint_value\x18\x02 \x01(\x03H\x00R\x08intValue\x12!\n\x0b\x66loat_value\x18\x03 \x01(\x01H\x00R\nfloatValue\x12H\n\ruint128_value\x18\x04 \x01(\x0b\x32!.relationalai.lqp.v1.UInt128ValueH\x00R\x0cuint128Value\x12\x45\n\x0cint128_value\x18\x05 \x01(\x0b\x32 .relationalai.lqp.v1.Int128ValueH\x00R\x0bint128Value\x12H\n\rmissing_value\x18\x06 \x01(\x0b\x32!.relationalai.lqp.v1.MissingValueH\x00R\x0cmissingValue\x12?\n\ndate_value\x18\x07 \x01(\x0b\x32\x1e.relationalai.lqp.v1.DateValueH\x00R\tdateValue\x12K\n\x0e\x64\x61tetime_value\x18\x08 \x01(\x0b\x32\".relationalai.lqp.v1.DateTimeValueH\x00R\rdatetimeValue\x12H\n\rdecimal_value\x18\t \x01(\x0b\x32!.relationalai.lqp.v1.DecimalValueH\x00R\x0c\x64\x65\x63imalValue\x12%\n\rboolean_value\x18\n \x01(\x08H\x00R\x0c\x62ooleanValue\x12!\n\x0bint32_value\x18\x0b \x01(\x05H\x00R\nint32Value\x12%\n\rfloat32_value\x18\x0c \x01(\x02H\x00R\x0c\x66loat32Value\x12#\n\x0cuint32_value\x18\r \x01(\rH\x00R\x0buint32ValueB\x07\n\x05value\"4\n\x0cUInt128Value\x12\x10\n\x03low\x18\x01 \x01(\x06R\x03low\x12\x12\n\x04high\x18\x02 \x01(\x06R\x04high\"3\n\x0bInt128Value\x12\x10\n\x03low\x18\x01 \x01(\x06R\x03low\x12\x12\n\x04high\x18\x02 \x01(\x06R\x04high\"\x0e\n\x0cMissingValue\"G\n\tDateValue\x12\x12\n\x04year\x18\x01 \x01(\x05R\x04year\x12\x14\n\x05month\x18\x02 \x01(\x05R\x05month\x12\x10\n\x03\x64\x61y\x18\x03 \x01(\x05R\x03\x64\x61y\"\xb1\x01\n\rDateTimeValue\x12\x12\n\x04year\x18\x01 \x01(\x05R\x04year\x12\x14\n\x05month\x18\x02 \x01(\x05R\x05month\x12\x10\n\x03\x64\x61y\x18\x03 \x01(\x05R\x03\x64\x61y\x12\x12\n\x04hour\x18\x04 \x01(\x05R\x04hour\x12\x16\n\x06minute\x18\x05 \x01(\x05R\x06minute\x12\x16\n\x06second\x18\x06 \x01(\x05R\x06second\x12 \n\x0bmicrosecond\x18\x07 \x01(\x05R\x0bmicrosecond\"z\n\x0c\x44\x65\x63imalValue\x12\x1c\n\tprecision\x18\x01 \x01(\x05R\tprecision\x12\x14\n\x05scale\x18\x02 \x01(\x05R\x05scale\x12\x36\n\x05value\x18\x03 \x01(\x0b\x32 .relationalai.lqp.v1.Int128ValueR\x05valueBCZAgithub.com/RelationalAI/logical-query-protocol/sdks/go/src/lqp/v1b\x06proto3') _globals = globals() _builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) @@ -155,47 +155,49 @@ _globals['_RELATIONID']._serialized_start=9635 _globals['_RELATIONID']._serialized_end=9695 _globals['_TYPE']._serialized_start=9698 - _globals['_TYPE']._serialized_end=10679 - _globals['_UNSPECIFIEDTYPE']._serialized_start=10681 - _globals['_UNSPECIFIEDTYPE']._serialized_end=10698 - _globals['_STRINGTYPE']._serialized_start=10700 - _globals['_STRINGTYPE']._serialized_end=10712 - _globals['_INTTYPE']._serialized_start=10714 - _globals['_INTTYPE']._serialized_end=10723 - _globals['_FLOATTYPE']._serialized_start=10725 - _globals['_FLOATTYPE']._serialized_end=10736 - _globals['_UINT128TYPE']._serialized_start=10738 - _globals['_UINT128TYPE']._serialized_end=10751 - _globals['_INT128TYPE']._serialized_start=10753 - _globals['_INT128TYPE']._serialized_end=10765 - _globals['_DATETYPE']._serialized_start=10767 - _globals['_DATETYPE']._serialized_end=10777 - _globals['_DATETIMETYPE']._serialized_start=10779 - _globals['_DATETIMETYPE']._serialized_end=10793 - _globals['_MISSINGTYPE']._serialized_start=10795 - _globals['_MISSINGTYPE']._serialized_end=10808 - _globals['_DECIMALTYPE']._serialized_start=10810 - _globals['_DECIMALTYPE']._serialized_end=10875 - _globals['_BOOLEANTYPE']._serialized_start=10877 - _globals['_BOOLEANTYPE']._serialized_end=10890 - _globals['_INT32TYPE']._serialized_start=10892 - _globals['_INT32TYPE']._serialized_end=10903 - _globals['_FLOAT32TYPE']._serialized_start=10905 - _globals['_FLOAT32TYPE']._serialized_end=10918 - _globals['_UINT32TYPE']._serialized_start=10920 - _globals['_UINT32TYPE']._serialized_end=10932 - _globals['_VALUE']._serialized_start=10935 - _globals['_VALUE']._serialized_end=11639 - _globals['_UINT128VALUE']._serialized_start=11641 - _globals['_UINT128VALUE']._serialized_end=11693 - _globals['_INT128VALUE']._serialized_start=11695 - _globals['_INT128VALUE']._serialized_end=11746 - _globals['_MISSINGVALUE']._serialized_start=11748 - _globals['_MISSINGVALUE']._serialized_end=11762 - _globals['_DATEVALUE']._serialized_start=11764 - _globals['_DATEVALUE']._serialized_end=11835 - _globals['_DATETIMEVALUE']._serialized_start=11838 - _globals['_DATETIMEVALUE']._serialized_end=12015 - _globals['_DECIMALVALUE']._serialized_start=12017 - _globals['_DECIMALVALUE']._serialized_end=12139 + _globals['_TYPE']._serialized_end=10744 + _globals['_UNSPECIFIEDTYPE']._serialized_start=10746 + _globals['_UNSPECIFIEDTYPE']._serialized_end=10763 + _globals['_STRINGTYPE']._serialized_start=10765 + _globals['_STRINGTYPE']._serialized_end=10777 + _globals['_INTTYPE']._serialized_start=10779 + _globals['_INTTYPE']._serialized_end=10788 + _globals['_FLOATTYPE']._serialized_start=10790 + _globals['_FLOATTYPE']._serialized_end=10801 + _globals['_UINT128TYPE']._serialized_start=10803 + _globals['_UINT128TYPE']._serialized_end=10816 + _globals['_INT128TYPE']._serialized_start=10818 + _globals['_INT128TYPE']._serialized_end=10830 + _globals['_DATETYPE']._serialized_start=10832 + _globals['_DATETYPE']._serialized_end=10842 + _globals['_DATETIMETYPE']._serialized_start=10844 + _globals['_DATETIMETYPE']._serialized_end=10858 + _globals['_MISSINGTYPE']._serialized_start=10860 + _globals['_MISSINGTYPE']._serialized_end=10873 + _globals['_DECIMALTYPE']._serialized_start=10875 + _globals['_DECIMALTYPE']._serialized_end=10940 + _globals['_BOOLEANTYPE']._serialized_start=10942 + _globals['_BOOLEANTYPE']._serialized_end=10955 + _globals['_INT32TYPE']._serialized_start=10957 + _globals['_INT32TYPE']._serialized_end=10968 + _globals['_FLOAT32TYPE']._serialized_start=10970 + _globals['_FLOAT32TYPE']._serialized_end=10983 + _globals['_UINT32TYPE']._serialized_start=10985 + _globals['_UINT32TYPE']._serialized_end=10997 + _globals['_FIXEDTYPE']._serialized_start=10999 + _globals['_FIXEDTYPE']._serialized_end=11034 + _globals['_VALUE']._serialized_start=11037 + _globals['_VALUE']._serialized_end=11741 + _globals['_UINT128VALUE']._serialized_start=11743 + _globals['_UINT128VALUE']._serialized_end=11795 + _globals['_INT128VALUE']._serialized_start=11797 + _globals['_INT128VALUE']._serialized_end=11848 + _globals['_MISSINGVALUE']._serialized_start=11850 + _globals['_MISSINGVALUE']._serialized_end=11864 + _globals['_DATEVALUE']._serialized_start=11866 + _globals['_DATEVALUE']._serialized_end=11937 + _globals['_DATETIMEVALUE']._serialized_start=11940 + _globals['_DATETIMEVALUE']._serialized_end=12117 + _globals['_DECIMALVALUE']._serialized_start=12119 + _globals['_DECIMALVALUE']._serialized_end=12241 # @@protoc_insertion_point(module_scope) diff --git a/sdks/python/src/lqp/proto/v1/logic_pb2.pyi b/sdks/python/src/lqp/proto/v1/logic_pb2.pyi index b851552e..77212c10 100644 --- a/sdks/python/src/lqp/proto/v1/logic_pb2.pyi +++ b/sdks/python/src/lqp/proto/v1/logic_pb2.pyi @@ -587,7 +587,7 @@ class RelationId(_message.Message): def __init__(self, id_low: _Optional[int] = ..., id_high: _Optional[int] = ...) -> None: ... class Type(_message.Message): - __slots__ = ("unspecified_type", "string_type", "int_type", "float_type", "uint128_type", "int128_type", "date_type", "datetime_type", "missing_type", "decimal_type", "boolean_type", "int32_type", "float32_type", "uint32_type") + __slots__ = ("unspecified_type", "string_type", "int_type", "float_type", "uint128_type", "int128_type", "date_type", "datetime_type", "missing_type", "decimal_type", "boolean_type", "int32_type", "float32_type", "uint32_type", "fixed_type") UNSPECIFIED_TYPE_FIELD_NUMBER: _ClassVar[int] STRING_TYPE_FIELD_NUMBER: _ClassVar[int] INT_TYPE_FIELD_NUMBER: _ClassVar[int] @@ -602,6 +602,7 @@ class Type(_message.Message): INT32_TYPE_FIELD_NUMBER: _ClassVar[int] FLOAT32_TYPE_FIELD_NUMBER: _ClassVar[int] UINT32_TYPE_FIELD_NUMBER: _ClassVar[int] + FIXED_TYPE_FIELD_NUMBER: _ClassVar[int] unspecified_type: UnspecifiedType string_type: StringType int_type: IntType @@ -616,7 +617,8 @@ class Type(_message.Message): int32_type: Int32Type float32_type: Float32Type uint32_type: UInt32Type - def __init__(self, unspecified_type: _Optional[_Union[UnspecifiedType, _Mapping]] = ..., string_type: _Optional[_Union[StringType, _Mapping]] = ..., int_type: _Optional[_Union[IntType, _Mapping]] = ..., float_type: _Optional[_Union[FloatType, _Mapping]] = ..., uint128_type: _Optional[_Union[UInt128Type, _Mapping]] = ..., int128_type: _Optional[_Union[Int128Type, _Mapping]] = ..., date_type: _Optional[_Union[DateType, _Mapping]] = ..., datetime_type: _Optional[_Union[DateTimeType, _Mapping]] = ..., missing_type: _Optional[_Union[MissingType, _Mapping]] = ..., decimal_type: _Optional[_Union[DecimalType, _Mapping]] = ..., boolean_type: _Optional[_Union[BooleanType, _Mapping]] = ..., int32_type: _Optional[_Union[Int32Type, _Mapping]] = ..., float32_type: _Optional[_Union[Float32Type, _Mapping]] = ..., uint32_type: _Optional[_Union[UInt32Type, _Mapping]] = ...) -> None: ... + fixed_type: FixedType + def __init__(self, unspecified_type: _Optional[_Union[UnspecifiedType, _Mapping]] = ..., string_type: _Optional[_Union[StringType, _Mapping]] = ..., int_type: _Optional[_Union[IntType, _Mapping]] = ..., float_type: _Optional[_Union[FloatType, _Mapping]] = ..., uint128_type: _Optional[_Union[UInt128Type, _Mapping]] = ..., int128_type: _Optional[_Union[Int128Type, _Mapping]] = ..., date_type: _Optional[_Union[DateType, _Mapping]] = ..., datetime_type: _Optional[_Union[DateTimeType, _Mapping]] = ..., missing_type: _Optional[_Union[MissingType, _Mapping]] = ..., decimal_type: _Optional[_Union[DecimalType, _Mapping]] = ..., boolean_type: _Optional[_Union[BooleanType, _Mapping]] = ..., int32_type: _Optional[_Union[Int32Type, _Mapping]] = ..., float32_type: _Optional[_Union[Float32Type, _Mapping]] = ..., uint32_type: _Optional[_Union[UInt32Type, _Mapping]] = ..., fixed_type: _Optional[_Union[FixedType, _Mapping]] = ...) -> None: ... class UnspecifiedType(_message.Message): __slots__ = () @@ -678,6 +680,12 @@ class UInt32Type(_message.Message): __slots__ = () def __init__(self) -> None: ... +class FixedType(_message.Message): + __slots__ = ("length",) + LENGTH_FIELD_NUMBER: _ClassVar[int] + length: int + def __init__(self, length: _Optional[int] = ...) -> None: ... + class Value(_message.Message): __slots__ = ("string_value", "int_value", "float_value", "uint128_value", "int128_value", "missing_value", "date_value", "datetime_value", "decimal_value", "boolean_value", "int32_value", "float32_value", "uint32_value") STRING_VALUE_FIELD_NUMBER: _ClassVar[int] diff --git a/sdks/python/src/lqp/proto_validator.py b/sdks/python/src/lqp/proto_validator.py index e70de806..b1c03d4f 100644 --- a/sdks/python/src/lqp/proto_validator.py +++ b/sdks/python/src/lqp/proto_validator.py @@ -44,6 +44,7 @@ def relation_id_hex(rid: logic_pb2.RelationId) -> str: "missing_type": "MISSING", "decimal_type": "DECIMAL", "boolean_type": "BOOLEAN", + "fixed_type": "FIXED", } diff --git a/tests/bin/relations_fixed.bin b/tests/bin/relations_fixed.bin new file mode 100644 index 00000000..6f59f761 --- /dev/null +++ b/tests/bin/relations_fixed.bin @@ -0,0 +1,38 @@ + + + + + + +f1" + +s3://bucket/nodes.csv",*"2"J.Rutf-8"2025-06-01T00:00:00Z*A + + +idz3 +1 + F92;&o? +parentz +tagzr +p + Ϲ[`ޱm^bZ + + +vzK +IG + + +pz + + +tz+:) + F92;&o? + +v + +p + +t8 + F92;&o? + Ϲ[`ޱm^bnoderoot_ids  +root_ids Ϲ[`ޱm^b \ No newline at end of file diff --git a/tests/lqp/relations_fixed.lqp b/tests/lqp/relations_fixed.lqp new file mode 100644 index 00000000..b7a61a2d --- /dev/null +++ b/tests/lqp/relations_fixed.lqp @@ -0,0 +1,22 @@ +(transaction + (epoch + (writes + (define + (fragment :f1 + ;; Generalized CSV loading with fixed-length byte-array columns: `node` is keyed + ;; by a 16-byte `id` and carries a 16-byte `parent` and an 8-byte `tag`. + (csv_data + (csv_locator + (paths "s3://bucket/nodes.csv")) + (csv_config {}) + (relations + (keys + (column "id" (FIXED 16))) + (relation :node + (column "parent" (FIXED 16)) + (column "tag" (FIXED 8)))) + (asof "2025-06-01T00:00:00Z")) + (def :root_ids ([v::(FIXED 16)] (exists [p::(FIXED 16) t::(FIXED 8)] (atom :node v p t))))))) + + (reads + (output :root_ids :root_ids)))) diff --git a/tests/pretty/relations_fixed.lqp b/tests/pretty/relations_fixed.lqp new file mode 100644 index 00000000..397028c4 --- /dev/null +++ b/tests/pretty/relations_fixed.lqp @@ -0,0 +1,27 @@ +(transaction + (configure { :ivm.maintenance_level "off" :semantics_version 0}) + (epoch + (writes + (define + (fragment + :f1 + (csv_data + (csv_locator (paths "s3://bucket/nodes.csv")) + (csv_config + { + :csv_compression "" + :csv_decimal_separator "." + :csv_delimiter "," + :csv_encoding "utf-8" + :csv_escapechar "\"" + :csv_header_row 1i32 + :csv_quotechar "\"" + :csv_skip 0}) + (relations + (keys (column "id" (FIXED 16))) + (relation :node (column "parent" (FIXED 16)) (column "tag" (FIXED 8)))) + (asof "2025-06-01T00:00:00Z")) + (def + :root_ids + ([v::(FIXED 16)] (exists [p::(FIXED 16) t::(FIXED 8)] (atom :node v p t))))))) + (reads (output :root_ids :root_ids)))) diff --git a/tests/pretty_debug/relations_fixed.lqp b/tests/pretty_debug/relations_fixed.lqp new file mode 100644 index 00000000..dd9e723c --- /dev/null +++ b/tests/pretty_debug/relations_fixed.lqp @@ -0,0 +1,39 @@ +(transaction + (configure { :ivm.maintenance_level "off" :semantics_version 0}) + (epoch + (writes + (define + (fragment + :f1 + (csv_data + (csv_locator (paths "s3://bucket/nodes.csv")) + (csv_config + { + :csv_compression "" + :csv_decimal_separator "." + :csv_delimiter "," + :csv_encoding "utf-8" + :csv_escapechar "\"" + :csv_header_row 1i32 + :csv_quotechar "\"" + :csv_skip 0}) + (relations + (keys (column "id" (FIXED 16))) + (relation + 0x3f6f26cfccf6c0073b3239fdedf49446 + (column "parent" (FIXED 16)) + (column "tag" (FIXED 8)))) + (asof "2025-06-01T00:00:00Z")) + (def + 0x625e6db1de60a0a59a5b03b9cf8f950b + ([v::(FIXED 16)] + (exists + [p::(FIXED 16) t::(FIXED 8)] + (atom 0x3f6f26cfccf6c0073b3239fdedf49446 v p t))))))) + (reads (output :root_ids 0x625e6db1de60a0a59a5b03b9cf8f950b)))) + +;; Debug information +;; ----------------------- +;; Original names +;; ID `0x3f6f26cfccf6c0073b3239fdedf49446` -> `node` +;; ID `0x625e6db1de60a0a59a5b03b9cf8f950b` -> `root_ids`